honkit 6.1.6 → 6.1.8

package/lib/api/deprecate.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_1 = __importDefault(require("is"));
-const object_path_1 = __importDefault(require("object-path"));
+const safeObjectPath_1 = require("../utils/safeObjectPath");
 const logged = {};
 const disabled = {};
 /**
@@ -101,7 +101,7 @@ function disableDeprecation(key) {
  */
 function deprecateRenamedMethod(book, key, instance, oldName, newName, msg) {
     msg = msg || `"${oldName}" is deprecated, use "${newName}()" instead`;
-    const fn = object_path_1.default.get(instance, newName);
+    const fn = (0, safeObjectPath_1.getAtPath)(instance, newName);
     instance[oldName] = deprecateMethod(book, key, fn, msg);
 }
 exports.default = {

package/lib/api/encodeConfig.d.ts

@@ -5,8 +5,8 @@ import Config from "../models/config";
  */
 declare function encodeConfig(output: Output, config: Config): {
     values: any;
-    get: (key: any, defaultValue: any) => any;
-    set: (key: any, value: any) => any;
+    get: (key: any, defaultValue: any) => unknown;
+    set: (key: any, value: any) => void;
 };
 export default encodeConfig;
 //# sourceMappingURL=encodeConfig.d.ts.map

package/lib/api/encodeConfig.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const object_path_1 = __importDefault(require("object-path"));
+const safeObjectPath_1 = require("../utils/safeObjectPath");
 const deprecate_1 = __importDefault(require("./deprecate"));
 /**
  Encode a config object into a JS config api
@@ -12,10 +12,10 @@ function encodeConfig(output, config) {
     const result = {
         values: config.getValues().toJS(),
         get: function (key, defaultValue) {
-            return object_path_1.default.get(result.values, key, defaultValue);
+            return (0, safeObjectPath_1.getAtPath)(result.values, key, defaultValue);
         },
         set: function (key, value) {
-            return object_path_1.default.set(result.values, key, value);
+            (0, safeObjectPath_1.setAtPath)(result.values, key, value);
         }
     };
     deprecate_1.default.field(output, "config.options", result, "options", result.values, '"config.options" property is deprecated, use "config.get(key)" instead');

package/lib/api/encodeGlobal.d.ts

@@ -10,8 +10,8 @@ declare function encodeGlobal(output: any): {
     log: any;
     config: {
         values: any;
-        get: (key: any, defaultValue: any) => any;
-        set: (key: any, value: any) => any;
+        get: (key: any, defaultValue: any) => unknown;
+        set: (key: any, value: any) => void;
     };
     summary: {
         walk: (iter: any) => void;

package/lib/constants/defaultFilters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultFilters.d.ts","sourceRoot":"","sources":["../../src/constants/defaultFilters.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,WAAW,CAAC;;AAGlC,wBAWG"}
+{"version":3,"file":"defaultFilters.d.ts","sourceRoot":"","sources":["../../src/constants/defaultFilters.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,WAAW,CAAC;;AAQlC,wBAWG"}

package/lib/constants/defaultFilters.js

@@ -4,15 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const immutable_1 = __importDefault(require("immutable"));
-const moment_1 = __importDefault(require("moment"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const relativeTime_1 = __importDefault(require("dayjs/plugin/relativeTime"));
+const advancedFormat_1 = __importDefault(require("dayjs/plugin/advancedFormat"));
+dayjs_1.default.extend(relativeTime_1.default);
+dayjs_1.default.extend(advancedFormat_1.default);
 exports.default = immutable_1.default.Map({
     // Format a date
     // ex: 'MMMM Do YYYY, h:mm:ss a
     date: function (time, format) {
-        return (0, moment_1.default)(time).format(format);
+        return (0, dayjs_1.default)(time).format(format);
     },
     // Relative Time
     dateFromNow: function (time) {
-        return (0, moment_1.default)(time).fromNow();
+        return (0, dayjs_1.default)(time).fromNow();
     }
 });

package/lib/models/fs.d.ts

@@ -1,6 +1,5 @@
 import Immutable from "immutable";
 import File from "./file";
-import Promise from "../utils/promise";
 declare const FS_base: Immutable.Record.Class;
 declare class FS extends FS_base {
     /**
@@ -39,7 +38,7 @@ declare class FS extends FS_base {
      Read a file as a string (utf-8)
      @return {Promise<String>}
      */
-    readAsString(filename: string, encoding?: string): Promise<string>;
+    readAsString(filename: string, encoding?: BufferEncoding): Promise<string>;
     /**
      Read file as a stream
 
@@ -94,7 +93,7 @@ declare class FS extends FS_base {
      @param {string} filename
      @return {Promise<Object>}
      */
-    loadAsObject(filename: string): any;
+    loadAsObject(filename: string): Promise<any>;
     /**
      Create a FS instance
 

package/lib/models/fs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../src/models/fs.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,MAAM,WAAW,CAAC;AAElC,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,OAAO,MAAM,kBAAkB,CAAC;;AAIvC,cAAM,EAAG,SAAQ,OAUf;IACE;;;;OAIG;IACH,OAAO,IAAI,MAAM;IAIjB;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAOpC;;;OAGG;IACH,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM;IAelC;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAW1C;;;;;OAKG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAWvC;;;OAGG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAM1E;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM;IAiB7B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAezC;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM;IAevB;;;;;;OAMG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM;IAMzB;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO;IA4BjE;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAQ1C;;;;;;OAMG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM;IAwB7B;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,GAAG,KAAA;IAIjB;;;;;;OAMG;IACH,MAAM,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,EAAE;CAGhD;AAQD,eAAe,EAAE,CAAC"}
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../src/models/fs.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,MAAM,WAAW,CAAC;AAElC,OAAO,IAAI,MAAM,QAAQ,CAAC;;AAK1B,cAAM,EAAG,SAAQ,OAUf;IACE;;;;OAIG;IACH,OAAO,IAAI,MAAM;IAIjB;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAOpC;;;OAGG;IACH,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM;IAelC;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAW1C;;;;;OAKG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAWvC;;;OAGG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,cAAuB,GAAG,OAAO,CAAC,MAAM,CAAC;IAMlF;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM;IAiB7B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAezC;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM;IAevB;;;;;;OAMG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM;IAMzB;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO;IA4BjE;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAQ1C;;;;;;OAMG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM;IAwB7B;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,GAAG,KAAA;IAIjB;;;;;;OAMG;IACH,MAAM,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,EAAE;CAGhD;AAQD,eAAe,EAAE,CAAC"}

package/lib/models/page.js

@@ -38,7 +38,7 @@ class Page extends immutable_1.default.Record({
         if (attrs.size === 0) {
             return content;
         }
-        const frontMatter = `---\n${js_yaml_1.default.safeDump(attrs.toJS(), { skipInvalid: true })}---\n\n`;
+        const frontMatter = `---\n${js_yaml_1.default.dump(attrs.toJS(), { skipInvalid: true })}---\n\n`;
         return frontMatter + (content || "");
     }
     /**

package/lib/utils/__tests__/objectPath.contract.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=objectPath.contract.test.d.ts.map

package/lib/utils/__tests__/objectPath.contract.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectPath.contract.test.d.ts","sourceRoot":"","sources":["../../../src/utils/__tests__/objectPath.contract.test.ts"],"names":[],"mappings":""}

package/lib/utils/__tests__/objectPath.contract.test.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Same scenarios as `safeObjectPath` contract tests on the refactored branch, run here against
+ * the real `object-path` dependency (pre-#508). Expectations match object-path@0.11.8, not
+ * `safeObjectPath` (see PR review discussion).
+ */
+const object_path_1 = __importDefault(require("object-path"));
+describe("object-path baseline (pre safeObjectPath)", () => {
+    describe("get", () => {
+        test("returns nested value by dot path", () => {
+            const obj = { structure: { readme: "README.md" } };
+            expect(object_path_1.default.get(obj, "structure.readme")).toBe("README.md");
+        });
+        test("accepts array path", () => {
+            const obj = { structure: { readme: "README.md" } };
+            expect(object_path_1.default.get(obj, ["structure", "readme"])).toBe("README.md");
+        });
+        test("returns default when path missing", () => {
+            const obj = { a: 1 };
+            expect(object_path_1.default.get(obj, "b", "fallback")).toBe("fallback");
+            expect(object_path_1.default.get(obj, "a.c", "fallback")).toBe("fallback");
+        });
+        test("returns default for null / undefined root", () => {
+            expect(object_path_1.default.get(null, "a", "d")).toBe("d");
+            expect(object_path_1.default.get(undefined, "a", "d")).toBe("d");
+        });
+        test("empty path returns the object (object-path semantics)", () => {
+            expect(object_path_1.default.get({ a: 1 }, "", "d")).toEqual({ a: 1 });
+        });
+        test("returns null when key exists with null value", () => {
+            expect(object_path_1.default.get({ x: null }, "x", "d")).toBeNull();
+        });
+        test("returns default when traversing into null intermediate", () => {
+            expect(object_path_1.default.get({ x: null }, "x.y", "d")).toBe("d");
+        });
+        test("returns default when traversing into non-object", () => {
+            expect(object_path_1.default.get({ x: "str" }, "x.y", "d")).toBe("d");
+        });
+        test("undefined leaf with default returns default", () => {
+            expect(object_path_1.default.get({ a: {} }, "a.missing", "d")).toBe("d");
+        });
+        test("prototype-ish keys with default", () => {
+            const obj = { safe: 1 };
+            expect(object_path_1.default.get(obj, "__proto__.polluted", "d")).toBe("d");
+            expect(object_path_1.default.get(obj, "constructor.prototype.polluted", "d")).toBe("d");
+            expect(obj.polluted).toBeUndefined();
+        });
+        test("does not trim segment whitespace (object-path)", () => {
+            expect(object_path_1.default.get({ a: { b: 2 } }, " a . b ", "d")).toBe("d");
+        });
+    });
+    describe("set", () => {
+        test("sets nested value by dot path", () => {
+            const obj = {};
+            object_path_1.default.set(obj, "structure.readme", "INTRO.md");
+            expect(obj).toEqual({ structure: { readme: "INTRO.md" } });
+        });
+        test("accepts array path", () => {
+            const obj = {};
+            object_path_1.default.set(obj, ["structure", "readme"], "INTRO.md");
+            expect(obj).toEqual({ structure: { readme: "INTRO.md" } });
+        });
+        test("overwrites existing nested value", () => {
+            const obj = { structure: { readme: "A.md" } };
+            object_path_1.default.set(obj, "structure.readme", "B.md");
+            expect(obj.structure.readme).toBe("B.md");
+        });
+        test("throws when intermediate is a non-object (object-path)", () => {
+            const obj = { a: "was-string" };
+            expect(() => object_path_1.default.set(obj, "a.b", 1)).toThrow();
+        });
+        test("throws when intermediate is null (object-path / native JS)", () => {
+            const obj = { a: null };
+            expect(() => object_path_1.default.set(obj, "a.b", 1)).toThrow();
+            expect(obj.a).toBeNull();
+        });
+        test("uses array index segments like object-path", () => {
+            const obj = {};
+            object_path_1.default.set(obj, "items.0.name", "first");
+            expect(obj.items).toEqual([{ name: "first" }]);
+        });
+        test("set on __proto__ path is a no-op for own keys (object-path)", () => {
+            const obj = { ok: true };
+            expect(object_path_1.default.set(obj, "__proto__", "ignored")).toBeUndefined();
+            expect(obj).toEqual({ ok: true });
+        });
+        test("set returns undefined (object-path)", () => {
+            const obj = {};
+            expect(object_path_1.default.set(obj, "x", 42)).toBeUndefined();
+            expect(obj.x).toBe(42);
+        });
+    });
+});

package/lib/utils/__tests__/promise.contract.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=promise.contract.test.d.ts.map

package/lib/utils/__tests__/promise.contract.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.contract.test.d.ts","sourceRoot":"","sources":["../../../src/utils/__tests__/promise.contract.test.ts"],"names":[],"mappings":""}

package/lib/utils/__tests__/promise.contract.test.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Contract tests for {@link ../promise} — encodes the Q-style API from `q` before the native
+ * shim (see PR review: https://github.com/honkit/honkit/pull/508#pullrequestreview-4268311613).
+ */
+const immutable_1 = __importDefault(require("immutable"));
+const promise_1 = __importDefault(require("../promise"));
+describe("promise contract (Q implementation)", () => {
+    test("factory resolves value", async () => {
+        await expect((0, promise_1.default)(7)).resolves.toBe(7);
+    });
+    test("thenResolve replaces result", async () => {
+        const p = (0, promise_1.default)("a").thenResolve("b");
+        await expect(p).resolves.toBe("b");
+    });
+    test("spread unpacks array fulfillment", async () => {
+        const p = (0, promise_1.default)([1, 2, 3]).spread((a, b, c) => a + b + c);
+        await expect(p).resolves.toBe(6);
+    });
+    test.skip("spread with non-array fulfillment (Q never settles)", async () => {
+        const p = (0, promise_1.default)("solo").spread((x) => x + "!");
+        await expect(p).resolves.toBe("solo!");
+    });
+    test("fail is catch alias", async () => {
+        const p = promise_1.default.reject(new Error("x")).fail(() => "recovered");
+        await expect(p).resolves.toBe("recovered");
+    });
+    test("tap runs side effect and preserves value", async () => {
+        let tapped;
+        const p = (0, promise_1.default)(5).tap((v) => {
+            tapped = v;
+        });
+        await expect(p).resolves.toBe(5);
+        expect(tapped).toBe(5);
+    });
+    test("tap awaits async side effect", async () => {
+        const order = [];
+        const p = (0, promise_1.default)("x").tap(async () => {
+            order.push("tap");
+        });
+        await p;
+        order.push("after");
+        expect(order).toEqual(["tap", "after"]);
+    });
+    test("fin runs on success and preserves value", async () => {
+        let ran = false;
+        const p = (0, promise_1.default)(9).fin(() => {
+            ran = true;
+        });
+        await expect(p).resolves.toBe(9);
+        expect(ran).toBe(true);
+    });
+    test("fin runs on failure and preserves rejection", async () => {
+        let ran = false;
+        const err = new Error("boom");
+        const p = promise_1.default.reject(err).fin(() => {
+            ran = true;
+        });
+        await expect(p).rejects.toThrow("boom");
+        expect(ran).toBe(true);
+    });
+    test("defer resolve / reject", async () => {
+        const d = promise_1.default.defer();
+        d.resolve(123);
+        await expect(d.promise).resolves.toBe(123);
+        const d2 = promise_1.default.defer();
+        d2.reject(new Error("no"));
+        await expect(d2.promise).rejects.toThrow("no");
+    });
+    test("defer makeNodeResolver (single result)", async () => {
+        const d = promise_1.default.defer();
+        d.makeNodeResolver()(null, "ok");
+        await expect(d.promise).resolves.toBe("ok");
+    });
+    test("defer makeNodeResolver (multiple results become array)", async () => {
+        const d = promise_1.default.defer();
+        d.makeNodeResolver()(null, "a", "b");
+        await expect(d.promise).resolves.toEqual(["a", "b"]);
+    });
+    test("defer notify invokes progress handlers", async () => {
+        const d = promise_1.default.defer();
+        const seen = [];
+        d.promise.progress((x) => seen.push(x));
+        d.notify("chunk");
+        d.resolve("done");
+        await d.promise;
+        expect(seen).toEqual(["chunk"]);
+    });
+    test("nfcall and get(index)", async () => {
+        function read(cb) {
+            cb(null, "x", "y");
+        }
+        const p = promise_1.default.nfcall(read).get(1);
+        await expect(p).resolves.toBe("y");
+    });
+    test("nfbind binds this", async () => {
+        const ctx = {
+            val: 3,
+            run(cb) {
+                cb(null, this.val);
+            }
+        };
+        const bound = promise_1.default.nfbind(ctx.run.bind(ctx));
+        await expect(bound()).resolves.toBe(3);
+    });
+    test("reduce over array", async () => {
+        const p = promise_1.default.reduce([1, 2, 3], (acc, n) => acc + n, 0);
+        await expect(p).resolves.toBe(6);
+    });
+    test("reduce over Immutable.List", async () => {
+        const p = promise_1.default.reduce(immutable_1.default.List([2, 3]), (acc, n) => acc * n, 2);
+        await expect(p).resolves.toBe(12);
+    });
+    test("forEach", async () => {
+        const acc = [];
+        await promise_1.default.forEach([10, 20], (n) => {
+            acc.push(n);
+        });
+        expect(acc).toEqual([10, 20]);
+    });
+    test("serie collects mapped results in order", async () => {
+        const p = promise_1.default.serie(["a", "b"], (s) => s.toUpperCase());
+        await expect(p).resolves.toEqual(["A", "B"]);
+    });
+    test("some returns first truthy iter result", async () => {
+        const p = promise_1.default.some([0, "", 42, 99], (x) => x);
+        await expect(p).resolves.toBe(42);
+    });
+    test("some yields last iter result when no value is truthy", async () => {
+        const p = promise_1.default.some([0, "", null], (x) => x);
+        await expect(p).resolves.toBeNull();
+    });
+    test("map over array returns Immutable.List", async () => {
+        const p = promise_1.default.map([1, 2], (n) => n * 2);
+        const list = await p;
+        expect(immutable_1.default.List.isList(list)).toBe(true);
+        expect(list.toJS()).toEqual([2, 4]);
+    });
+    test("map over Immutable.Map preserves Map", async () => {
+        const m = immutable_1.default.Map({ a: 1, b: 2 });
+        const p = promise_1.default.map(m, (v) => v + 10);
+        const out = await p;
+        expect(immutable_1.default.Map.isMap(out)).toBe(true);
+        expect(out.toJS()).toEqual({ a: 11, b: 12 });
+    });
+    test("map over Immutable.OrderedMap preserves OrderedMap", async () => {
+        const m = immutable_1.default.OrderedMap({ z: 1, a: 2 });
+        const p = promise_1.default.map(m, (v) => v + 10);
+        const out = await p;
+        expect(immutable_1.default.OrderedMap.isOrderedMap(out)).toBe(true);
+        expect(out.toJS()).toEqual({ z: 11, a: 12 });
+    });
+    test("wrap defers sync function", async () => {
+        const fn = promise_1.default.wrap((a, b) => a + b);
+        await expect(fn(2, 3)).resolves.toBe(5);
+    });
+    test("reject", async () => {
+        await expect(promise_1.default.reject(new Error("r"))).rejects.toThrow("r");
+    });
+    test("all", async () => {
+        await expect(promise_1.default.all([1, Promise.resolve(2)])).resolves.toEqual([1, 2]);
+    });
+    test("isPromiseAlike", () => {
+        expect(promise_1.default.isPromiseAlike(null)).toBe(false);
+        expect(promise_1.default.isPromiseAlike({})).toBe(false);
+        expect(promise_1.default.isPromiseAlike(Promise.resolve())).toBe(true);
+        expect(promise_1.default.isPromiseAlike({ then() { } })).toBe(true);
+    });
+    test("nodeify with callback", async () => {
+        await new Promise((resolve, reject) => {
+            (0, promise_1.default)(88).nodeify((err, val) => {
+                if (err)
+                    reject(err);
+                else {
+                    expect(val).toBe(88);
+                    resolve();
+                }
+            });
+        });
+    });
+    test("nodeify without callback returns promise", async () => {
+        const p = (0, promise_1.default)(1).nodeify();
+        await expect(p).resolves.toBe(1);
+    });
+    test("top-level progress is no-op chain passthrough", async () => {
+        const p = (0, promise_1.default)(5).progress(() => {
+            /* unused for non-deferred promises */
+        });
+        await expect(p).resolves.toBe(5);
+    });
+});

package/lib/utils/__tests__/safeObjectPath.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=safeObjectPath.d.ts.map

package/lib/utils/__tests__/safeObjectPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeObjectPath.d.ts","sourceRoot":"","sources":["../../../src/utils/__tests__/safeObjectPath.ts"],"names":[],"mappings":""}

package/lib/utils/__tests__/safeObjectPath.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Direct unit tests for {@link ../safeObjectPath} — mirrors {@link ./objectPath.contract.test.ts}
+ * to keep object-path compatibility. Documents intentional differences (empty path, trimmed
+ * segments, unsafe segment handling).
+ */
+const safeObjectPath_1 = require("../safeObjectPath");
+describe("safeObjectPath", () => {
+    describe("getAtPath", () => {
+        test("returns nested value by dot path", () => {
+            const obj = { structure: { readme: "README.md" } };
+            expect((0, safeObjectPath_1.getAtPath)(obj, "structure.readme")).toBe("README.md");
+        });
+        test("accepts array path", () => {
+            const obj = { structure: { readme: "README.md" } };
+            expect((0, safeObjectPath_1.getAtPath)(obj, ["structure", "readme"])).toBe("README.md");
+        });
+        test("array path preserves empty-string segments as literal keys", () => {
+            const obj = { "": { key: 1 }, a: { "": 2 } };
+            expect((0, safeObjectPath_1.getAtPath)(obj, ["", "key"], "d")).toBe(1);
+            expect((0, safeObjectPath_1.getAtPath)(obj, ["a", ""], "d")).toBe(2);
+        });
+        test("returns default when path missing", () => {
+            const obj = { a: 1 };
+            expect((0, safeObjectPath_1.getAtPath)(obj, "b", "fallback")).toBe("fallback");
+            expect((0, safeObjectPath_1.getAtPath)(obj, "a.c", "fallback")).toBe("fallback");
+        });
+        test("returns default for null / undefined root", () => {
+            expect((0, safeObjectPath_1.getAtPath)(null, "a", "d")).toBe("d");
+            expect((0, safeObjectPath_1.getAtPath)(undefined, "a", "d")).toBe("d");
+        });
+        test("empty path returns default (unlike object-path empty-path root)", () => {
+            expect((0, safeObjectPath_1.getAtPath)({ a: 1 }, "", "d")).toBe("d");
+            expect((0, safeObjectPath_1.getAtPath)({ a: 1 }, [], "d")).toBe("d");
+        });
+        test("returns null when key exists with null value", () => {
+            expect((0, safeObjectPath_1.getAtPath)({ x: null }, "x", "d")).toBeNull();
+        });
+        test("returns default when traversing into null intermediate", () => {
+            expect((0, safeObjectPath_1.getAtPath)({ x: null }, "x.y", "d")).toBe("d");
+        });
+        test("returns default when traversing into non-object", () => {
+            expect((0, safeObjectPath_1.getAtPath)({ x: "str" }, "x.y", "d")).toBe("d");
+        });
+        test("undefined leaf with default returns default", () => {
+            expect((0, safeObjectPath_1.getAtPath)({ a: {} }, "a.missing", "d")).toBe("d");
+        });
+        test("does not read inherited prototype properties (matches object-path)", () => {
+            const obj = Object.create({ inherited: 1 });
+            obj.own = 2;
+            expect((0, safeObjectPath_1.getAtPath)(obj, "inherited", "d")).toBe("d");
+            expect((0, safeObjectPath_1.getAtPath)(obj, "own", "d")).toBe(2);
+        });
+        test("rejects whole path containing unsafe segments", () => {
+            const obj = { safe: 1, polluted: "real-value" };
+            expect((0, safeObjectPath_1.getAtPath)(obj, "__proto__.polluted", "d")).toBe("d");
+            expect((0, safeObjectPath_1.getAtPath)(obj, "constructor.prototype.polluted", "d")).toBe("d");
+            // path is not rewritten to "polluted" by stripping __proto__
+            expect((0, safeObjectPath_1.getAtPath)(obj, "__proto__", "d")).toBe("d");
+        });
+        test("trims segment whitespace for string paths (differs from object-path)", () => {
+            expect((0, safeObjectPath_1.getAtPath)({ a: { b: 2 } }, " a . b ", "d")).toBe(2);
+        });
+    });
+    describe("setAtPath", () => {
+        test("sets nested value by dot path", () => {
+            const obj = {};
+            (0, safeObjectPath_1.setAtPath)(obj, "structure.readme", "INTRO.md");
+            expect(obj).toEqual({ structure: { readme: "INTRO.md" } });
+        });
+        test("accepts array path", () => {
+            const obj = {};
+            (0, safeObjectPath_1.setAtPath)(obj, ["structure", "readme"], "INTRO.md");
+            expect(obj).toEqual({ structure: { readme: "INTRO.md" } });
+        });
+        test("array path preserves empty-string segments when writing", () => {
+            const obj = {};
+            (0, safeObjectPath_1.setAtPath)(obj, ["", "key"], "v");
+            expect(obj).toEqual({ "": { key: "v" } });
+        });
+        test("overwrites existing nested value", () => {
+            const obj = { structure: { readme: "A.md" } };
+            (0, safeObjectPath_1.setAtPath)(obj, "structure.readme", "B.md");
+            expect(obj.structure.readme).toBe("B.md");
+        });
+        test("uses array index segments for numeric keys", () => {
+            const obj = {};
+            (0, safeObjectPath_1.setAtPath)(obj, "items.0.name", "first");
+            expect(obj.items).toEqual([{ name: "first" }]);
+        });
+        test("throws when intermediate is a non-object scalar (matches object-path)", () => {
+            const obj = { a: "was-string" };
+            expect(() => (0, safeObjectPath_1.setAtPath)(obj, "a.b", 1)).toThrow();
+        });
+        test("throws when intermediate is null (matches object-path / native JS)", () => {
+            const obj = { a: null };
+            expect(() => (0, safeObjectPath_1.setAtPath)(obj, "a.b", 1)).toThrow();
+            // original null is left untouched
+            expect(obj.a).toBeNull();
+        });
+        test("creates missing intermediate when the existing key is undefined", () => {
+            const obj = {};
+            (0, safeObjectPath_1.setAtPath)(obj, "a.b", 1);
+            expect(obj).toEqual({ a: { b: 1 } });
+        });
+        test("set on path containing __proto__ is a no-op (does not write top-level)", () => {
+            const obj = { ok: true };
+            expect((0, safeObjectPath_1.setAtPath)(obj, "__proto__", "ignored")).toBeUndefined();
+            expect((0, safeObjectPath_1.setAtPath)(obj, "__proto__.polluted", "ignored")).toBeUndefined();
+            expect(obj).toEqual({ ok: true });
+            expect(obj.polluted).toBeUndefined();
+        });
+        test("does not descend into inherited objects when setting", () => {
+            const proto = { nested: { shared: 1 } };
+            const obj = Object.create(proto);
+            (0, safeObjectPath_1.setAtPath)(obj, "nested.shared", 2);
+            // own "nested" was created on obj, not mutated on proto
+            expect(Object.prototype.hasOwnProperty.call(obj, "nested")).toBe(true);
+            expect(proto.nested).toEqual({ shared: 1 });
+            expect(obj.nested.shared).toBe(2);
+        });
+        test("returns undefined (matches object-path)", () => {
+            const obj = {};
+            expect((0, safeObjectPath_1.setAtPath)(obj, "x", 42)).toBeUndefined();
+            expect(obj.x).toBe(42);
+        });
+    });
+});

package/lib/utils/git.d.ts

@@ -3,7 +3,7 @@ declare namespace Git {
     var isUrl: (giturl: any) => boolean;
     var parseUrl: (giturl: any) => {
         host: any;
-        ref: any;
+        ref: string;
         filepath: any;
     };
 }

package/lib/utils/git.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/utils/git.ts"],"names":[],"mappings":"AAWA,iBAAS,GAAG,SAGX;kBAHQ,GAAG;;;;;;;;AA4HZ,eAAe,GAAG,CAAC"}
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/utils/git.ts"],"names":[],"mappings":"AAUA,iBAAS,GAAG,SAGX;kBAHQ,GAAG;;;;;;;;AAkIZ,eAAe,GAAG,CAAC"}

package/lib/utils/git.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const is_1 = __importDefault(require("is"));
 const path_1 = __importDefault(require("path"));
 const crc_1 = __importDefault(require("crc"));
-const urijs_1 = __importDefault(require("urijs"));
 const path_2 = __importDefault(require("./path"));
 const promise_1 = __importDefault(require("./promise"));
 const command_1 = __importDefault(require("./command"));
@@ -91,26 +90,32 @@ Git.prototype.resolveRoot = function (filepath) {
 Git.isUrl = function (giturl) {
     return giturl.indexOf(GIT_PREFIX) === 0;
 };
-// Parse and extract infos
+// Parse and extract information (git+https://... and git+git@host:path/repo.git/... — no URI.js)
 Git.parseUrl = function (giturl) {
     if (!Git.isUrl(giturl))
         return null;
     giturl = giturl.slice(GIT_PREFIX.length);
-    const uri = new urijs_1.default(giturl);
-    const ref = uri.fragment() || null;
-    uri.fragment(null);
-    // Extract file inside the repo (after the .git)
-    const fileParts = uri.path().split(".git");
-    let filepath = fileParts.length > 1 ? fileParts.slice(1).join(".git") : "";
-    if (filepath[0] == "/") {
+    let ref = null;
+    const hashIdx = giturl.indexOf("#");
+    if (hashIdx >= 0) {
+        ref = giturl.slice(hashIdx + 1) || null;
+        giturl = giturl.slice(0, hashIdx);
+    }
+    // Match a real repository ".git" suffix (not e.g. "gist.github.com" where ".git" appears inside the hostname)
+    const gitSuffix = /\.git(\/|$)/;
+    const m = gitSuffix.exec(giturl);
+    if (!m) {
+        return null;
+    }
+    const host = giturl.slice(0, m.index + 4);
+    let filepath = giturl.slice(m.index + 4);
+    if (filepath.startsWith("/")) {
         filepath = filepath.slice(1);
     }
-    // Recreate pathname without the real filename
-    uri.path(`${fileParts[0]}.git`);
     return {
-        host: uri.toString(),
-        ref: ref,
-        filepath: filepath
+        host,
+        ref,
+        filepath
     };
 };
 exports.default = Git;

package/lib/utils/promise.d.ts

@@ -1,52 +1,23 @@
-import Q from "q";
-/**
- * Reduce an array to a promise
- *
- * @param {Array|List} arr
- * @param {Function(value, element, index)} iter
- * @param {Array|List} base
- * @return {Promise<Mixed>}
- */
-declare function reduce(arr: any, iter: any, base: any): any;
-/**
- * Iterate over an array using an async iter
- *
- * @param {Array|List} arr
- * @param {Function(value, element, index)}
- * @return {Promise}
- */
-declare function forEach(arr: any, iter: any): any;
-/**
- * Transform an array
- *
- * @param {Array|List} arr
- * @param {Function(value, element, index)}
- * @return {Promise}
- */
-declare function serie(arr: any, iter: any, base: any): any;
-/**
- * Iter over an array and return first result (not null)
- *
- * @param {Array|List} arr
- * @param {Function(element, index)}
- * @return {Promise<Mixed>}
- */
-declare function some(arr: any, iter: any): any;
-/**
- * Map an array or map
- *
- * @param {Array|List|Map|OrderedMap} arr
- * @param {Function(element, key)}
- * @return {Promise<List|Map|OrderedMap>}
- */
-declare function map(arr: any, iter: any): any;
-/**
- * Wrap a function in a promise
- *
- * @param {Function} func
- * @return {Funciton}
- */
-declare function wrap(func: Function): () => any;
-export default Q;
+import Immutable from "immutable";
+/** HonKit historically used `q`; this module keeps the same surface on top of native Promises. */
+export type ExtendedPromise<T> = Promise<T> & {
+    thenResolve<U>(value: U): ExtendedPromise<U>;
+    spread(fn: (...args: any[]) => any): ExtendedPromise<any>;
+    fail(onRejected: (reason: unknown) => unknown): ExtendedPromise<unknown>;
+    get?(index: number): ExtendedPromise<unknown>;
+    tap(onFulfilled: (value: T) => unknown): ExtendedPromise<T>;
+    progress(onProgress: (data: unknown) => void): ExtendedPromise<T>;
+    nodeify(callback?: (err: unknown, result?: T) => void): ExtendedPromise<T> | void;
+    /** Q `fin` — like `finally`; preserves fulfillment value or rejection reason. */
+    fin(onFinally: () => unknown): ExtendedPromise<T>;
+};
+declare function reduce<TAcc, TElem>(arr: Immutable.List<TElem> | unknown[] | Immutable.Iterable<TElem, unknown>, iter: (acc: TAcc, elem: TElem, key: unknown) => unknown, base?: TAcc): ExtendedPromise<TAcc>;
+declare function forEach<T>(arr: Immutable.List<T> | unknown[] | Immutable.Iterable<T, unknown>, iter: (el: T, key: unknown) => unknown): ExtendedPromise<any>;
+declare function serie<T, R>(arr: Immutable.List<T> | unknown[] | Immutable.Iterable<T, unknown>, iter: (item: T, key: unknown) => unknown): ExtendedPromise<R[]>;
+declare function some<T>(arr: Immutable.List<T> | unknown[] | Immutable.Iterable<T, unknown>, iter: (el: T, i: unknown) => unknown): Promise<unknown>;
+declare function map<T, R>(arr: Immutable.Map<string, T> | Immutable.OrderedMap<string, T> | Immutable.List<T> | unknown[] | Immutable.Iterable<T, unknown>, iter: (el: T, key: unknown) => unknown): Promise<Immutable.Map<unknown, unknown>> | Promise<Immutable.List<R>>;
+declare function wrap(func: (...args: unknown[]) => unknown): (this: unknown, ...args: unknown[]) => Promise<any>;
+declare const _default: any;
+export default _default;
 export { forEach, reduce, map, serie, some, wrap };
 //# sourceMappingURL=promise.d.ts.map

package/lib/utils/promise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../../src/utils/promise.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,GAAG,CAAC;AAQlB;;;;;;;GAOG;AACH,iBAAS,MAAM,CAAC,GAAG,KAAA,EAAE,IAAI,KAAA,EAAE,IAAI,KAAA,OAQ9B;AAED;;;;;;GAMG;AACH,iBAAS,OAAO,CAAC,GAAG,KAAA,EAAE,IAAI,KAAA,OAKzB;AAED;;;;;;GAMG;AACH,iBAAS,KAAK,CAAC,GAAG,KAAA,EAAE,IAAI,KAAA,EAAE,IAAI,KAAA,OAW7B;AAED;;;;;;GAMG;AACH,iBAAS,IAAI,CAAC,GAAG,KAAA,EAAE,IAAI,KAAA,OAUtB;AAsBD;;;;;;GAMG;AACH,iBAAS,GAAG,CAAC,GAAG,KAAA,EAAE,IAAI,KAAA,OAmBrB;AAED;;;;;GAKG;AACH,iBAAS,IAAI,CAAC,IAAI,EAAE,QAAQ,aAQ3B;AAQD,eAAe,CAAC,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC"}
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../../src/utils/promise.ts"],"names":[],"mappings":"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"}

package/lib/utils/promise.js

@@ -9,106 +9,168 @@ exports.map = map;
 exports.serie = serie;
 exports.some = some;
 exports.wrap = wrap;
-const q_1 = __importDefault(require("q"));
 const immutable_1 = __importDefault(require("immutable"));
-// Debugging for long stack traces
-if (process.env.DEBUG || process.env.CI) {
-    q_1.default.longStackSupport = true;
+const HONKIT = Symbol("honkitPromise");
+function extendPromise(p) {
+    const ep = p;
+    if (ep[HONKIT]) {
+        return ep;
+    }
+    ep[HONKIT] = true;
+    const origThen = p.then.bind(p);
+    const origCatch = p.catch.bind(p);
+    ep.then = function (onFulfilled, onRejected) {
+        return extendPromise(origThen(onFulfilled, onRejected));
+    };
+    ep.catch = function (onRejected) {
+        return extendPromise(origCatch(onRejected));
+    };
+    ep.thenResolve = function (value) {
+        return extendPromise(this.then(() => value));
+    };
+    ep.spread = function (fn) {
+        return extendPromise(this.then((arr) => {
+            if (Array.isArray(arr)) {
+                return fn(...arr);
+            }
+            return fn(arr);
+        }));
+    };
+    ep.fail = function (onRejected) {
+        return extendPromise(this.catch(onRejected));
+    };
+    ep.tap = function (onFulfilled) {
+        return extendPromise(this.then((value) => Promise.resolve(onFulfilled(value)).then(() => value)));
+    };
+    ep.progress = function (_onProgress) {
+        return ep;
+    };
+    ep.nodeify = function (callback) {
+        if (!callback) {
+            return ep;
+        }
+        this.then((result) => {
+            callback(null, result);
+        }, (err) => {
+            callback(err);
+        });
+        return undefined;
+    };
+    ep.fin = function (onFinally) {
+        return extendPromise(this.finally(() => {
+            return onFinally();
+        }));
+    };
+    return ep;
+}
+function defer() {
+    const progressHandlers = new Set();
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    const ext = extendPromise(promise);
+    ext.progress = function (_onProgress) {
+        progressHandlers.add(_onProgress);
+        return ext;
+    };
+    return {
+        promise: ext,
+        resolve,
+        reject,
+        notify(data) {
+            progressHandlers.forEach((f) => f(data));
+        },
+        makeNodeResolver() {
+            return (err, ...args) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(args.length <= 1 ? args[0] : args);
+                }
+            };
+        }
+    };
+}
+function nfcall(fn, ...args) {
+    const inner = new Promise((resolve, reject) => {
+        const callback = (err, ...cbArgs) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(cbArgs.length <= 1 ? cbArgs[0] : cbArgs);
+            }
+        };
+        fn(...args, callback);
+    });
+    const ext = extendPromise(inner);
+    ext.get = (index) => extendPromise(inner.then((val) => {
+        if (Array.isArray(val)) {
+            return val[index];
+        }
+        return index === 0 ? val : undefined;
+    }));
+    return ext;
+}
+function nfbind(fn) {
+    return function (...args) {
+        return nfcall(fn.bind(this), ...args);
+    };
 }
-/**
- * Reduce an array to a promise
- *
- * @param {Array|List} arr
- * @param {Function(value, element, index)} iter
- * @param {Array|List} base
- * @return {Promise<Mixed>}
- */
 function reduce(arr, iter, base) {
-    arr = immutable_1.default.Iterable.isIterable(arr) ? arr : immutable_1.default.List(arr);
-    return arr.reduce((prev, elem, key) => {
-        return prev.then((val) => {
-            return iter(val, elem, key);
-        });
-    }, (0, q_1.default)(base));
+    const list = immutable_1.default.Iterable.isIterable(arr) ? arr : immutable_1.default.List(arr);
+    return list.reduce((prev, elem, key) => {
+        return prev.then((val) => iter(val, elem, key));
+    }, extendPromise(Promise.resolve(base)));
 }
-/**
- * Iterate over an array using an async iter
- *
- * @param {Array|List} arr
- * @param {Function(value, element, index)}
- * @return {Promise}
- */
 function forEach(arr, iter) {
-    // @ts-expect-error ts-migrate(2554) FIXME: Expected 3 arguments, but got 2.
-    return reduce(arr, (val, el, key) => {
+    return reduce(arr, (_val, el, key) => {
         return iter(el, key);
-    });
+    }, undefined);
 }
-/**
- * Transform an array
- *
- * @param {Array|List} arr
- * @param {Function(value, element, index)}
- * @return {Promise}
- */
-function serie(arr, iter, base) {
+function serie(arr, iter) {
     return reduce(arr, (before, item, key) => {
-        return (0, q_1.default)(iter(item, key)).then((r) => {
+        return extendPromise(Promise.resolve(iter(item, key))).then((r) => {
             before.push(r);
             return before;
         });
     }, []);
 }
-/**
- * Iter over an array and return first result (not null)
- *
- * @param {Array|List} arr
- * @param {Function(element, index)}
- * @return {Promise<Mixed>}
- */
 function some(arr, iter) {
-    arr = immutable_1.default.List(arr);
-    return arr.reduce((prev, elem, i) => {
+    const list = immutable_1.default.List.isList(arr) ? arr : immutable_1.default.List(arr);
+    return list.reduce((prev, elem, i) => {
         return prev.then((val) => {
-            if (val)
+            if (val) {
                 return val;
+            }
             return iter(elem, i);
         });
-    }, (0, q_1.default)());
+    }, extendPromise(Promise.resolve(undefined)));
 }
-/**
- * Map an array using an async (promised) iterator
- *
- * @param {Array|List} arr
- * @param {Function(element, index)}
- * @return {Promise<List>}
- */
 function mapAsList(arr, iter) {
     return reduce(arr, (prev, entry, i) => {
-        return (0, q_1.default)(iter(entry, i)).then((out) => {
+        return extendPromise(Promise.resolve(iter(entry, i))).then((out) => {
             prev.push(out);
             return prev;
         });
     }, []);
 }
-/**
- * Map an array or map
- *
- * @param {Array|List|Map|OrderedMap} arr
- * @param {Function(element, key)}
- * @return {Promise<List|Map|OrderedMap>}
- */
 function map(arr, iter) {
     if (immutable_1.default.Map.isMap(arr)) {
         let type = "Map";
         if (immutable_1.default.OrderedMap.isOrderedMap(arr)) {
             type = "OrderedMap";
         }
-        return mapAsList(arr, (value, key) => {
-            return (0, q_1.default)(iter(value, key)).then((result) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return mapAsList(arr, ((value, key) => {
+            return extendPromise(Promise.resolve(iter(value, key))).then((result) => {
                 return [key, result];
             });
-        }).then((result) => {
+        })).then((result) => {
             return immutable_1.default[type](result);
         });
     }
@@ -118,24 +180,31 @@ function map(arr, iter) {
         });
     }
 }
-/**
- * Wrap a function in a promise
- *
- * @param {Function} func
- * @return {Funciton}
- */
 function wrap(func) {
-    return function () {
-        const args = Array.prototype.slice.call(arguments, 0);
-        return (0, q_1.default)().then(() => {
-            return func.apply(null, args);
+    return function (...args) {
+        return extendPromise(Promise.resolve()).then(() => {
+            return func.apply(this, args);
         });
     };
 }
-q_1.default.forEach = forEach;
-q_1.default.reduce = reduce;
-q_1.default.map = map;
-q_1.default.serie = serie;
-q_1.default.some = some;
-q_1.default.wrap = wrap;
-exports.default = q_1.default;
+function isPromiseAlike(x) {
+    return x != null && typeof x.then === "function";
+}
+/* eslint-disable @typescript-eslint/no-explicit-any -- Q-compatible surface is intentionally loose for chaining */
+const HonkitPromiseRoot = Object.assign(function HonkitPromise(value) {
+    return extendPromise(Promise.resolve(value));
+}, {
+    defer,
+    nfcall,
+    nfbind,
+    reject: (reason) => extendPromise(Promise.reject(reason)),
+    all: (values) => extendPromise(Promise.all(Array.from(values))),
+    reduce,
+    forEach,
+    map,
+    serie,
+    some,
+    wrap,
+    isPromiseAlike
+});
+exports.default = HonkitPromiseRoot;

package/lib/utils/safeObjectPath.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Minimal dot-path get/set with prototype-pollution guards.
+ * Replaces object-path for config key access (e.g. "plugins", "structure.readme").
+ *
+ * Behavior is kept compatible with the previous object-path wrapper:
+ *  - get / set accept `string | string[]`
+ *  - lookups only descend through own properties (matches object-path)
+ *  - set throws when an intermediate value is a non-object scalar (string,
+ *    number, boolean, null) — null follows from native JS, the others match
+ *    object-path's check
+ *  - set returns undefined
+ *  - paths containing __proto__ / constructor / prototype are rejected as a
+ *    whole, so e.g. "__proto__.polluted" does not collapse to "polluted"
+ */
+export declare function getAtPath(obj: Record<string, unknown> | null | undefined, path: string | string[], defaultValue?: unknown): unknown;
+export declare function setAtPath(obj: Record<string, unknown> | null | undefined, path: string | string[], value: unknown): void;
+//# sourceMappingURL=safeObjectPath.d.ts.map

package/lib/utils/safeObjectPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeObjectPath.d.ts","sourceRoot":"","sources":["../../src/utils/safeObjectPath.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA+BH,wBAAgB,SAAS,CACrB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EAC/C,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,YAAY,CAAC,EAAE,OAAO,GACvB,OAAO,CAmBT;AAED,wBAAgB,SAAS,CACrB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EAC/C,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,KAAK,EAAE,OAAO,GACf,IAAI,CA6BN"}

package/lib/utils/safeObjectPath.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Minimal dot-path get/set with prototype-pollution guards.
+ * Replaces object-path for config key access (e.g. "plugins", "structure.readme").
+ *
+ * Behavior is kept compatible with the previous object-path wrapper:
+ *  - get / set accept `string | string[]`
+ *  - lookups only descend through own properties (matches object-path)
+ *  - set throws when an intermediate value is a non-object scalar (string,
+ *    number, boolean, null) — null follows from native JS, the others match
+ *    object-path's check
+ *  - set returns undefined
+ *  - paths containing __proto__ / constructor / prototype are rejected as a
+ *    whole, so e.g. "__proto__.polluted" does not collapse to "polluted"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAtPath = getAtPath;
+exports.setAtPath = setAtPath;
+const UNSAFE = new Set(["__proto__", "constructor", "prototype"]);
+function toSegments(path) {
+    let parts;
+    if (Array.isArray(path)) {
+        // Array paths are caller-supplied keys — empty string is a valid property name
+        parts = path.map((s) => String(s));
+    }
+    else {
+        // String paths are dot-delimited; trim whitespace and drop empty split artifacts
+        parts = String(path)
+            .split(".")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    for (const part of parts) {
+        if (UNSAFE.has(part)) {
+            return null;
+        }
+    }
+    return parts;
+}
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function getAtPath(obj, path, defaultValue) {
+    if (obj == null || path == null) {
+        return defaultValue;
+    }
+    const parts = toSegments(path);
+    if (parts === null) {
+        return defaultValue;
+    }
+    let cur = obj;
+    for (const key of parts) {
+        if (cur == null || typeof cur !== "object") {
+            return defaultValue;
+        }
+        if (!hasOwn(cur, key)) {
+            return defaultValue;
+        }
+        cur = cur[key];
+    }
+    return cur === undefined ? defaultValue : cur;
+}
+function setAtPath(obj, path, value) {
+    if (obj == null || path == null) {
+        return;
+    }
+    const parts = toSegments(path);
+    if (parts === null) {
+        return;
+    }
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (!hasOwn(cur, key) || cur[key] === undefined) {
+            const nextKey = parts[i + 1];
+            const created = /^\d+$/.test(nextKey) ? [] : {};
+            cur[key] = created;
+            cur = created;
+            continue;
+        }
+        const ownNext = cur[key];
+        if (ownNext === null || typeof ownNext !== "object") {
+            throw new Error(`safeObjectPath.setAtPath: cannot set "${parts.join(".")}" because intermediate "${parts
+                .slice(0, i + 1)
+                .join(".")}" is not an object`);
+        }
+        cur = ownNext;
+    }
+    cur[parts[parts.length - 1]] = value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honkit",
-  "version": "6.1.6",
+  "version": "6.1.8",
   "description": "HonKit is building beautiful books using Markdown.",
   "keywords": [
     "git",
@@ -37,6 +37,7 @@
     "cp": "^0.2.0",
     "cpr": "^3.0.1",
     "crc": "^3.8.0",
+    "dayjs": "^1.11.13",
     "destroy": "^1.2.0",
     "direction": "^0.1.5",
     "dom-serializer": "^0.1.1",
@@ -44,7 +45,7 @@
     "escape-html": "^1.0.3",
     "escape-string-regexp": "^4.0.0",
     "extend": "^3.0.2",
-    "flat-cache": "^2.0.1",
+    "flat-cache": "^4.0.1",
     "front-matter": "^2.3.0",
     "gitbook-plugin-livereload": "^0.0.1",
     "gitbook-plugin-lunr": "^1.2.0",
@@ -52,34 +53,30 @@
     "github-slugid": "^1.0.1",
     "i18n-t": "^1.0.1",
     "ignore": "^5.3.2",
-    "immutable": "^3.8.2",
+    "immutable": "^3.8.3",
     "is": "^3.3.0",
-    "js-yaml": "^3.14.1",
+    "js-yaml": "^4.1.0",
     "json-schema-defaults": "^0.1.1",
     "jsonschema": "1.1.0",
     "juice": "^8.1.0",
     "lru_map": "^0.4.1",
     "memoize-one": "^5.2.1",
     "mkdirp": "^1.0.4",
-    "moment": "^2.30.1",
     "nunjucks": "^3.2.4",
     "nunjucks-do": "^1.0.0",
-    "object-path": "^0.11.8",
     "omit-keys": "^0.1.0",
     "open": "^7.4.2",
-    "q": "^1.5.1",
     "resolve": "^1.22.8",
     "semver": "^7.6.3",
-    "send": "^0.17.2",
+    "send": "^0.19.2",
     "tiny-lr": "^1.1.1",
     "tmp": "0.2.4",
-    "urijs": "^1.19.11",
-    "@honkit/honkit-plugin-highlight": "6.1.6",
-    "@honkit/honkit-plugin-fontsettings": "6.1.6",
-    "@honkit/html": "6.1.6",
-    "@honkit/markdown-legacy": "6.1.6",
-    "@honkit/asciidoc": "6.1.6",
-    "@honkit/honkit-plugin-theme-default": "6.1.6"
+    "@honkit/asciidoc": "6.1.8",
+    "@honkit/honkit-plugin-theme-default": "6.1.8",
+    "@honkit/honkit-plugin-fontsettings": "6.1.8",
+    "@honkit/html": "6.1.8",
+    "@honkit/markdown-legacy": "6.1.8",
+    "@honkit/honkit-plugin-highlight": "6.1.8"
   },
   "devDependencies": {
     "@relmify/jest-serializer-strip-ansi": "^1.0.2",
@@ -88,14 +85,16 @@
     "@types/nunjucks": "^3.2.6",
     "jest": "^29.7.0",
     "jest-mock-process": "^2.0.0",
+    "object-path": "^0.11.8",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.2",
-    "@honkit/internal-test-utils": "6.1.6"
+    "@honkit/internal-test-utils": "6.1.8"
   },
   "scripts": {
     "build": "tsc -p .",
     "clean": "rimraf lib/",
     "test": "jest src",
+    "test:contract": "jest --config jest.contract.config.js --coverage src/utils/__tests__/promise.contract.test.ts src/utils/__tests__/objectPath.contract.test.ts",
     "updateSnapshot": "jest src -u"
   }
 }