build-raptor 0.131.0 → 0.133.0

package/dist/deps/misc/graph.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = void 0;
+const p_queue_1 = __importDefault(require("p-queue"));
+const arrays_1 = require("./arrays");
+const constructs_1 = require("./constructs");
+const executor_1 = require("./executor");
+const graph_executor_1 = require("./internal/graph-executor");
+const maps_1 = require("./maps");
+const object_map_1 = require("./object-map");
+class Vertex {
+    constructor(id, payload) {
+        this.id = id;
+        this.payload = payload;
+        this.neighbors_ = [];
+        this.backNeighbors_ = [];
+    }
+    addNeighbor(v) {
+        this.neighbors_.push(v);
+    }
+    addBackNeighbor(v) {
+        this.backNeighbors_.push(v);
+    }
+    remove(v) {
+        const index = this.neighbors_.indexOf(v);
+        if (index >= 0) {
+            this.neighbors_.splice(index, 1);
+        }
+        const index2 = this.backNeighbors_.indexOf(v);
+        if (index2 >= 0) {
+            this.backNeighbors_.splice(index2, 1);
+        }
+    }
+    get neighbors() {
+        return (0, arrays_1.sortBy)(this.neighbors_, v => v.id);
+    }
+    get backNeighbors() {
+        return (0, arrays_1.sortBy)(this.backNeighbors_, v => v.id);
+    }
+}
+class Graph {
+    constructor(vToId) {
+        this.vToId = vToId;
+        this.vertexMap = new object_map_1.ObjectMap(vToId);
+    }
+    // TODO(imaman): cover
+    copy() {
+        const ret = new Graph(this.vToId);
+        const vs = (0, arrays_1.sortBy)(this.vertexMap.values(), v => v.id);
+        for (const v of vs) {
+            ret.vertex(v.payload);
+            for (const u of v.neighbors) {
+                ret.edge(v.payload, u.payload);
+            }
+        }
+        return ret;
+    }
+    edge(from, to) {
+        this.vertex(from);
+        this.vertex(to);
+        const f = this.toVertex(from);
+        const t = this.toVertex(to);
+        f.addNeighbor(t);
+        t.addBackNeighbor(f);
+    }
+    toVertex(v) {
+        return (0, maps_1.hardGet)(this.vertexMap, v);
+    }
+    vertex(v) {
+        const existing = this.vertexMap.get(v);
+        if (!existing) {
+            const id = this.vToId(v);
+            this.vertexMap.set(v, new Vertex(id, v));
+        }
+    }
+    remove(v) {
+        const existing = this.vertexMap.get(v);
+        if (!existing) {
+            throw new Error(`Cannot remove non-existing vertex: <${v}>`);
+        }
+        this.vertexMap.delete(v);
+        for (const n of existing.backNeighbors) {
+            n.remove(existing);
+        }
+        for (const n of existing.neighbors) {
+            n.remove(existing);
+        }
+    }
+    vertices() {
+        return (0, arrays_1.sortBy)(this.vertexMap.values(), v => v.id).map(v => v.payload);
+    }
+    outDegree(v) {
+        return this.neighborsOf(v).length;
+    }
+    neighborsOf(v) {
+        return this.toVertex(v).neighbors.map(v => v.payload);
+    }
+    backNeighborsOf(v) {
+        return this.toVertex(v).backNeighbors.map(v => v.payload);
+    }
+    roots() {
+        return this.vertices().filter(v => this.toVertex(v).backNeighbors.length === 0);
+    }
+    traverseFrom(arg, options) {
+        const direction = options?.direction ?? 'forward';
+        const seen = new Set();
+        const visited = [];
+        const traverse = (v) => {
+            if (seen.has(v.id)) {
+                return;
+            }
+            seen.add(v.id);
+            const ns = direction === 'forward'
+                ? v.neighbors
+                : direction === 'backwards'
+                    ? v.backNeighbors
+                    : (0, constructs_1.shouldNeverHappen)(direction);
+            for (let i = ns.length - 1; i >= 0; --i) {
+                traverse(ns[i]);
+            }
+            visited.push(v);
+        };
+        const arr = Array.isArray(arg) ? arg : [arg];
+        const startingPoints = (0, arrays_1.sortBy)(arr.map(v => this.toVertex(v)), v => v.id);
+        for (const at of startingPoints) {
+            traverse(at);
+        }
+        return visited.map(v => v.payload);
+    }
+    toJSON() {
+        const vs = (0, arrays_1.sortBy)(this.vertexMap.values(), v => v.id);
+        const ret = {};
+        for (const v of vs) {
+            ret[v.id] = v.neighbors.map(n => n.id);
+        }
+        return ret;
+    }
+    toString() {
+        const vs = (0, arrays_1.sortBy)(this.vertexMap.values(), v => v.id);
+        if (vs.length === 0) {
+            return '<EMPTY>';
+        }
+        return vs.map(v => `${v.id} -> ${v.neighbors.map(n => n.id).join(', ')}`.trim()).join('\n');
+    }
+    static fromJSON(json) {
+        const ret = new Graph(x => x);
+        for (const [v, neighbors] of Object.entries(json)) {
+            ret.vertex(v);
+            for (const n of neighbors) {
+                ret.edge(v, n);
+            }
+        }
+        return ret;
+    }
+    isCyclic() {
+        const vs = this.vertices().map(v => this.toVertex(v));
+        // TODO(imaman): use a proper impl. of LIFO (and also introduce a FIFO arrays.ts)
+        const lifo = [];
+        const map = new Map();
+        for (const v of vs) {
+            const deg = v.neighbors.length;
+            map.set(v.id, deg);
+            if (deg === 0) {
+                lifo.push(v);
+            }
+        }
+        const seen = new Set();
+        while (true) {
+            const v = lifo.pop();
+            if (!v) {
+                break;
+            }
+            if (seen.has(v.id)) {
+                continue;
+            }
+            seen.add(v.id);
+            for (const n of v.backNeighbors) {
+                const deg = (0, maps_1.mapIncrement)(map, n.id, -1);
+                if (deg === 0) {
+                    lifo.push(n);
+                }
+            }
+        }
+        return seen.size !== vs.length;
+    }
+    async execute(concurrency, workToDo, batchScheduler) {
+        const queue = new p_queue_1.default({ concurrency });
+        const executor = new executor_1.Executor(queue, workToDo);
+        const ge = new graph_executor_1.GraphExecutor(this, executor, batchScheduler ?? (() => undefined));
+        await ge.execute();
+    }
+    makeVertexMap() {
+        return new object_map_1.ObjectMap(this.vToId);
+    }
+}
+exports.Graph = Graph;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/graph.ts"],"names":[],"mappings":"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"}

package/dist/deps/misc/in-memory-storage-client.d.ts

@@ -0,0 +1,21 @@
+import { Int } from '.';
+import { Key, StorageClient } from './storage-client';
+export declare class InMemoryStorageClient implements StorageClient {
+    private readonly sizeLimitInBytes;
+    private byteCount_;
+    constructor(sizeLimitInBytes?: Int);
+    private readonly store;
+    putObject(key: Key, content: string | Buffer): Promise<void>;
+    private putObjectImpl;
+    putContentAddressable(content: string | Buffer): Promise<string>;
+    getContentAddressable(hash: string): Promise<Buffer>;
+    get byteCount(): Int;
+    getObject(key: Key): Promise<string>;
+    getObject(key: Key, type: 'string'): Promise<string>;
+    getObject(key: Key, type: 'buffer'): Promise<Buffer>;
+    private getObjectImpl;
+    objectExists(key: Key): Promise<boolean>;
+    private keyToString;
+    toJSON(): [Key, string][];
+    load(u: unknown): void;
+}

package/dist/deps/misc/in-memory-storage-client.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStorageClient = void 0;
+const _1 = require(".");
+const constructs_1 = require("./constructs");
+const misc_1 = require("./misc");
+class InMemoryStorageClient {
+    constructor(sizeLimitInBytes = (0, _1.Int)(-1)) {
+        this.sizeLimitInBytes = sizeLimitInBytes;
+        this.byteCount_ = (0, _1.Int)(0);
+        this.store = new Map();
+    }
+    async putObject(key, content) {
+        this.putObjectImpl(this.keyToString(key), content);
+    }
+    putObjectImpl(s, content) {
+        const existing = Buffer.from(this.store.get(s) ?? '', 'base64');
+        const bufferToStore = Buffer.from(content).toString('base64');
+        const newCount = this.byteCount_ + bufferToStore.length - existing.length;
+        if (this.sizeLimitInBytes >= 0 && newCount > this.sizeLimitInBytes) {
+            throw new Error(`size limit (${this.sizeLimitInBytes} bytes) will be exceeded.`);
+        }
+        this.store.set(s, bufferToStore);
+        this.byteCount_ = (0, _1.Int)(newCount);
+    }
+    async putContentAddressable(content) {
+        const ret = (0, misc_1.computeHash)(content);
+        const p = `cas/${ret}`;
+        this.putObjectImpl(p, content);
+        return ret;
+    }
+    async getContentAddressable(hash) {
+        return await this.getObjectImpl(`cas/${hash}`);
+    }
+    get byteCount() {
+        return this.byteCount_;
+    }
+    async getObject(key, type = 'string') {
+        const buf = await this.getObjectImpl(this.keyToString(key));
+        return type === 'string' ? buf.toString('utf-8') : type === 'buffer' ? buf : (0, constructs_1.shouldNeverHappen)(type);
+    }
+    async getObjectImpl(p) {
+        const encoded = this.store.get(p);
+        if (encoded === undefined) {
+            throw new Error(`No object with key ${JSON.stringify(p)}`);
+        }
+        return Buffer.from(encoded, 'base64');
+    }
+    async objectExists(key) {
+        return this.store.has(this.keyToString(key));
+    }
+    keyToString(key) {
+        return `std/${(0, misc_1.computeObjectHash)({ key })}`;
+    }
+    toJSON() {
+        return [...this.store];
+    }
+    load(u) {
+        if (!Array.isArray(u)) {
+            throw new Error(`not an array`);
+        }
+        u.forEach((at, i) => {
+            if (!Array.isArray(at)) {
+                throw new Error(`entry ${i} is not a pair (got: ${typeof at})`);
+            }
+            if (at.length !== 2) {
+                throw new Error(`entry ${i} is not a pair (length: ${at.length})`);
+            }
+            const strings = at.map(x => typeof x === 'string' ? x : (0, constructs_1.failMe)(`expected a pair of strings but found a ${typeof x} at pair ${i}`));
+            this.putObjectImpl(strings[0], Buffer.from(strings[1], 'base64'));
+        });
+    }
+}
+exports.InMemoryStorageClient = InMemoryStorageClient;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/deps/misc/index.d.ts

@@ -0,0 +1,20 @@
+export * from './arrays';
+export * from './camelize-record';
+export * from './constructs';
+export * from './directory-scanner';
+export * from './executor';
+export * from './file-system-storage-client';
+export * from './folderify';
+export * from './graph';
+export * from './in-memory-storage-client';
+export * from './int';
+export * from './maps';
+export * from './misc';
+export * from './object-map';
+export * from './promises';
+export * from './records';
+export * from './slurp-dir';
+export * from './storage-client';
+export * from './stream-to-buffer';
+export * from './strings';
+export * from './typed-publisher';

package/dist/deps/misc/index.js

@@ -0,0 +1,37 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./arrays"), exports);
+__exportStar(require("./camelize-record"), exports);
+__exportStar(require("./constructs"), exports);
+__exportStar(require("./directory-scanner"), exports);
+__exportStar(require("./executor"), exports);
+__exportStar(require("./file-system-storage-client"), exports);
+__exportStar(require("./folderify"), exports);
+__exportStar(require("./graph"), exports);
+__exportStar(require("./in-memory-storage-client"), exports);
+__exportStar(require("./int"), exports);
+__exportStar(require("./maps"), exports);
+__exportStar(require("./misc"), exports);
+__exportStar(require("./object-map"), exports);
+__exportStar(require("./promises"), exports);
+__exportStar(require("./records"), exports);
+__exportStar(require("./slurp-dir"), exports);
+__exportStar(require("./storage-client"), exports);
+__exportStar(require("./stream-to-buffer"), exports);
+__exportStar(require("./strings"), exports);
+__exportStar(require("./typed-publisher"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDJDQUF3QjtBQUN4QixvREFBaUM7QUFDakMsK0NBQTRCO0FBQzVCLHNEQUFtQztBQUNuQyw2Q0FBMEI7QUFDMUIsK0RBQTRDO0FBQzVDLDhDQUEyQjtBQUMzQiwwQ0FBdUI7QUFDdkIsNkRBQTBDO0FBQzFDLHdDQUFxQjtBQUNyQix5Q0FBc0I7QUFDdEIseUNBQXNCO0FBQ3RCLCtDQUE0QjtBQUM1Qiw2Q0FBMEI7QUFDMUIsNENBQXlCO0FBQ3pCLDhDQUEyQjtBQUMzQixtREFBZ0M7QUFDaEMscURBQWtDO0FBQ2xDLDRDQUF5QjtBQUN6QixvREFBaUMifQ==

package/dist/deps/misc/int.d.ts

@@ -0,0 +1,10 @@
+import { Brand } from 'brand';
+export type Int = Brand<number, 'Int'>;
+declare class IntUtils {
+    parse(s: string): Int;
+    product(lhs: Int, rhs: number): Int;
+    sum(lhs: Int, rhs: number): Int;
+}
+export declare function Int(): IntUtils;
+export declare function Int(value: number): Int;
+export {};

package/dist/deps/misc/int.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int = Int;
+class IntUtils {
+    parse(s) {
+        return intify(s);
+    }
+    product(lhs, rhs) {
+        return intify(lhs * Int(rhs));
+    }
+    sum(lhs, rhs) {
+        return intify(lhs + Int(rhs));
+    }
+}
+function Int(value) {
+    if (value === undefined) {
+        return new IntUtils();
+    }
+    return intify(value);
+}
+function intify(input) {
+    const ret = Number(input);
+    if (Number.isInteger(ret)) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return ret;
+    }
+    throw new Error(`<${input}> is not an integer`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQW1CQSxrQkFNQztBQXJCRCxNQUFNLFFBQVE7SUFDWixLQUFLLENBQUMsQ0FBUztRQUNiLE9BQU8sTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ2xCLENBQUM7SUFFRCxPQUFPLENBQUMsR0FBUSxFQUFFLEdBQVc7UUFDM0IsT0FBTyxNQUFNLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO0lBQy9CLENBQUM7SUFDRCxHQUFHLENBQUMsR0FBUSxFQUFFLEdBQVc7UUFDdkIsT0FBTyxNQUFNLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO0lBQy9CLENBQUM7Q0FDRjtBQUlELFNBQWdCLEdBQUcsQ0FBQyxLQUFjO0lBQ2hDLElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQ3hCLE9BQU8sSUFBSSxRQUFRLEVBQUUsQ0FBQTtJQUN2QixDQUFDO0lBRUQsT0FBTyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUE7QUFDdEIsQ0FBQztBQUVELFNBQVMsTUFBTSxDQUFDLEtBQXNCO0lBQ3BDLE1BQU0sR0FBRyxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUN6QixJQUFJLE1BQU0sQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUMxQix5RUFBeUU7UUFDekUsT0FBTyxHQUFVLENBQUE7SUFDbkIsQ0FBQztJQUVELE1BQU0sSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLHFCQUFxQixDQUFDLENBQUE7QUFDakQsQ0FBQyJ9

package/dist/deps/misc/internal/graph-executor.d.ts

@@ -0,0 +1,15 @@
+import { Executor } from '../executor';
+import { BatchScheduler, Graph } from '../graph';
+export declare class GraphExecutor<V> {
+    private readonly graph;
+    private readonly executor;
+    private readonly batchScheduler;
+    private readonly map;
+    private numLeft;
+    private started;
+    constructor(graph: Graph<V>, executor: Executor<V>, batchScheduler: BatchScheduler<V>);
+    private start;
+    private scheduleBatch;
+    private vertexExecuted;
+    execute(): Promise<void>;
+}

package/dist/deps/misc/internal/graph-executor.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphExecutor = void 0;
+const maps_1 = require("../maps");
+class GraphExecutor {
+    constructor(graph, executor, batchScheduler) {
+        this.graph = graph;
+        this.executor = executor;
+        this.batchScheduler = batchScheduler;
+        this.started = false;
+        if (graph.isCyclic()) {
+            throw new Error(`Cannot execute a cyclic graph`);
+        }
+        this.numLeft = graph.vertices().length;
+        this.map = graph.makeVertexMap();
+    }
+    start() {
+        if (this.started) {
+            throw new Error(`A GraphExecutor object can only be started once`);
+        }
+        this.started = true;
+        const initialBatch = [];
+        for (const v of this.graph.vertices()) {
+            const count = this.graph.neighborsOf(v).length;
+            this.map.set(v, count);
+            if (count === 0) {
+                initialBatch.push(v);
+            }
+        }
+        this.executor.subscribe(({ lastSettled }) => {
+            if (this.map.has(lastSettled)) {
+                this.vertexExecuted(lastSettled);
+            }
+        });
+        this.scheduleBatch(initialBatch);
+    }
+    scheduleBatch(batch) {
+        const subGraph = this.batchScheduler(batch);
+        if (!subGraph) {
+            for (const v of batch) {
+                this.executor.schedule(v);
+            }
+            return;
+        }
+        if (subGraph.isCyclic()) {
+            throw new Error(`batch scheduler returned a cyclic graph`);
+        }
+        const set = subGraph.makeVertexMap();
+        for (const v of batch) {
+            set.set(v, {});
+        }
+        const subVertices = subGraph.vertices();
+        const outOfBatch = subVertices.filter(v => !set.has(v));
+        if (outOfBatch.length > 0) {
+            throw new Error(`batch scheduler returned out-of-batch vertices: ${outOfBatch.join(', ')}`);
+        }
+        if (subVertices.length !== batch.length) {
+            throw new Error(`batch scheduler returned a bad grap: number of vertices is ${subVertices.length} (but it should be ${batch.length})`);
+        }
+        const subExecutor = new GraphExecutor(subGraph, this.executor, () => undefined);
+        subExecutor.start();
+    }
+    vertexExecuted(v) {
+        const nextBatch = [];
+        for (const n of this.graph.backNeighborsOf(v)) {
+            const count = (0, maps_1.mapIncrement)(this.map, n, -1);
+            if (count === 0) {
+                nextBatch.push(n);
+            }
+        }
+        this.scheduleBatch(nextBatch);
+    }
+    async execute() {
+        const ret = new Promise((resolve, reject) => {
+            this.executor.subscribe(({ error }) => {
+                --this.numLeft;
+                if (this.numLeft > 0) {
+                    return;
+                }
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+            this.start();
+        });
+        return ret;
+    }
+}
+exports.GraphExecutor = GraphExecutor;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/deps/misc/maps.d.ts

@@ -0,0 +1,29 @@
+interface MapLike<K, V> {
+    get(k: K): V | undefined;
+    set(k: K, v: V): void;
+}
+/**
+ * Returns a value from a map, or throws an error if not found.
+ * @param map the map to fetch from
+ * @param key a key to look up
+ * @returns the value assoicated with `key` in `map`.
+ */
+export declare function hardGet<K, V>(map: MapLike<K, V>, key: K): V;
+/**
+ * Increment the value associated with `key` in `map` by `inc`.
+ * @param map a map to increment one of its values
+ * @param key the key to increment
+ * @param inc the amount to increment by
+ * @returns the incremented value
+ */
+export declare function mapIncrement<K>(map: MapLike<K, number>, key: K, inc: number): number;
+/**
+ * Returns the value with `key` in `map`. If not found, set it to the value returned by the given supplier function
+ * and returns it.
+ * @param map a map to get a value from
+ * @param key the key to get
+ * @param supplier a zero-arguments callback to provide a value if `key` is not found in `map`
+ * @returns the value associated with `key` in `map`
+ */
+export declare function assigningGet<K, V>(map: MapLike<K, V>, key: K, supplier: () => V): V;
+export {};

package/dist/deps/misc/maps.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hardGet = hardGet;
+exports.mapIncrement = mapIncrement;
+exports.assigningGet = assigningGet;
+/**
+ * Returns a value from a map, or throws an error if not found.
+ * @param map the map to fetch from
+ * @param key a key to look up
+ * @returns the value assoicated with `key` in `map`.
+ */
+function hardGet(map, key) {
+    const ret = map.get(key);
+    if (ret === undefined) {
+        throw new Error(`Could not find <${key}> in the given map`);
+    }
+    return ret;
+}
+/**
+ * Increment the value associated with `key` in `map` by `inc`.
+ * @param map a map to increment one of its values
+ * @param key the key to increment
+ * @param inc the amount to increment by
+ * @returns the incremented value
+ */
+function mapIncrement(map, key, inc) {
+    const ret = assigningGet(map, key, () => 0) + inc;
+    map.set(key, ret);
+    return ret;
+}
+/**
+ * Returns the value with `key` in `map`. If not found, set it to the value returned by the given supplier function
+ * and returns it.
+ * @param map a map to get a value from
+ * @param key the key to get
+ * @param supplier a zero-arguments callback to provide a value if `key` is not found in `map`
+ * @returns the value associated with `key` in `map`
+ */
+function assigningGet(map, key, supplier) {
+    let v = map.get(key);
+    if (v === undefined) {
+        v = supplier();
+        map.set(key, v);
+    }
+    return v;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tYXBzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBV0EsMEJBTUM7QUFTRCxvQ0FJQztBQVVELG9DQU9DO0FBMUNEOzs7OztHQUtHO0FBQ0gsU0FBZ0IsT0FBTyxDQUFPLEdBQWtCLEVBQUUsR0FBTTtJQUN0RCxNQUFNLEdBQUcsR0FBRyxHQUFHLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQ3hCLElBQUksR0FBRyxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQ3RCLE1BQU0sSUFBSSxLQUFLLENBQUMsbUJBQW1CLEdBQUcsb0JBQW9CLENBQUMsQ0FBQTtJQUM3RCxDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUE7QUFDWixDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsU0FBZ0IsWUFBWSxDQUFJLEdBQXVCLEVBQUUsR0FBTSxFQUFFLEdBQVc7SUFDMUUsTUFBTSxHQUFHLEdBQUcsWUFBWSxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFBO0lBQ2pELEdBQUcsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUFBO0lBQ2pCLE9BQU8sR0FBRyxDQUFBO0FBQ1osQ0FBQztBQUVEOzs7Ozs7O0dBT0c7QUFDSCxTQUFnQixZQUFZLENBQU8sR0FBa0IsRUFBRSxHQUFNLEVBQUUsUUFBaUI7SUFDOUUsSUFBSSxDQUFDLEdBQUcsR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQTtJQUNwQixJQUFJLENBQUMsS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUNwQixDQUFDLEdBQUcsUUFBUSxFQUFFLENBQUE7UUFDZCxHQUFHLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQTtJQUNqQixDQUFDO0lBQ0QsT0FBTyxDQUFDLENBQUE7QUFDVixDQUFDIn0=

package/dist/deps/misc/misc.d.ts

@@ -0,0 +1,23 @@
+export type Jsonable = string | number | boolean | null | readonly Jsonable[] | {
+    readonly [key: string]: Jsonable;
+};
+export declare function computeObjectHash(input: Record<string, Jsonable>): string;
+/**
+ *
+ * @param input buffer or string to hash
+ * @returns a hash, in "hex" encoding.
+ */
+export declare function computeHash(input: Buffer | string, algo?: 'sha224' | 'sha256'): string;
+/**
+ * Represents an event that should happen at some point in the future.
+ */
+export declare class Timeout {
+    private readonly promise;
+    constructor(promise: Promise<void>);
+    /**
+     * Returns a promise that is resvoled when the timeout expires.
+     */
+    hasPassed(): Promise<void>;
+}
+export declare function aTimeoutOf(ms: number): Timeout;
+export declare function dumpFile(inputPath: string, output: NodeJS.WritableStream): Promise<void>;