xhs-mp-pack 1.1.0-beta.0

package/dist/base/fs.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="node" />
+/// <reference types="node" />
+interface IStats {
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+    isBlockDevice: () => boolean;
+    isCharacterDevice: () => boolean;
+    isSymbolicLink: () => boolean;
+    isFIFO: () => boolean;
+    isSocket: () => boolean;
+    dev: number | bigint;
+    ino: number | bigint;
+    mode: number | bigint;
+    nlink: number | bigint;
+    uid: number | bigint;
+    gid: number | bigint;
+    rdev: number | bigint;
+    size: number | bigint;
+    blksize: number | bigint;
+    blocks: number | bigint;
+    atimeMs: number | bigint;
+    mtimeMs: number | bigint;
+    ctimeMs: number | bigint;
+    birthtimeMs: number | bigint;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+}
+interface IDirent {
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+    isBlockDevice: () => boolean;
+    isCharacterDevice: () => boolean;
+    isSymbolicLink: () => boolean;
+    isFIFO: () => boolean;
+    isSocket: () => boolean;
+    name: string | Buffer;
+}
+type Callback = (err: NodeJS.ErrnoException | null) => void;
+type BufferOrStringCallback = (err: NodeJS.ErrnoException | null, data: Buffer | string) => void;
+type DirentArrayCallback = (err: NodeJS.ErrnoException | null, entries: (string | Buffer)[] | IDirent[]) => void;
+type NumberCallback = (err: NodeJS.ErrnoException | null, value: number) => void;
+type StatsCallback = (err: NodeJS.ErrnoException | null, stats: IStats) => void;
+type ReadJsonCallback = (err: NodeJS.ErrnoException | Error | null, data: any) => void;
+interface OutputFileSystem {
+    writeFile: (filename: string, data: Buffer | string, callback: Callback) => void;
+    mkdir: (dirname: string, callback: Callback) => void;
+    readdir?: (dirname: string, callback: DirentArrayCallback) => void;
+    rmdir?: (dirname: string, callback: Callback) => void;
+    unlink?: (filename: string, callback: Callback) => void;
+    stat: (path: string, callback: StatsCallback) => void;
+    lstat?: (path: string, callback: StatsCallback) => void;
+    readFile: (filename: string, callback: BufferOrStringCallback) => void;
+    join?: (path1: string, path2: string) => string;
+    relative?: (from: string, to: string) => string;
+    dirname?: (path: string) => string;
+}
+interface InputFileSystem {
+    readFile: (filename: string, callback: BufferOrStringCallback) => void;
+    readJson?: (filename: string, callback: ReadJsonCallback) => void;
+    readlink: (filename: string, callback: DirentArrayCallback) => void;
+    readdir: (dirname: string, callback: StatsCallback) => void;
+    stat: (path: string, callback: StatsCallback) => void;
+    lstat?: (path: string, callback: StatsCallback) => void;
+    realpath?: (path: string, callback: BufferOrStringCallback) => void;
+    purge?: (filename?: string) => void;
+    join?: (path1: string, path2: string) => string;
+    relative?: (from: string, to: string) => string;
+    dirname?: (path: string) => string;
+}
+interface IntermediateFileSystemExtras {
+    mkdirSync: (path: string) => void;
+    createWriteStream: (path: string) => NodeJS.WritableStream;
+    open: (path: string, flags: string, mode: number, callback: NumberCallback) => void;
+    read: (fd: number, buffer: Buffer, offset: number, length: number, position: number, callback: NumberCallback) => void;
+    close: (fd: number, callback: Callback) => void;
+    rename: (oldPath: string, newPath: string, callback: Callback) => void;
+}
+type IntermediateFileSystem = InputFileSystem & OutputFileSystem & IntermediateFileSystemExtras;
+declare const relative: (fs: InputFileSystem | OutputFileSystem | undefined, rootPath: string, targetPath: string) => string;
+declare const join: (fs: InputFileSystem | OutputFileSystem | undefined, rootPath: string, filename: string) => string;
+declare const dirname: (fs: InputFileSystem | OutputFileSystem | undefined, absPath: string) => string;
+declare const mkdirp: (fs: OutputFileSystem, p: string, callback: any) => void;
+declare const mkdirpSync: (fs: IntermediateFileSystem, p: string) => void;
+declare const readJson: (fs: any, p: string, callback: any) => any;
+declare const lstatReadlinkAbsolute: (fs: any, p: string, callback: any) => any;
+declare function stat(fs: any, path: any): Promise<unknown>;
+declare function readFile(fs: any, path: string): Promise<unknown>;
+/**
+ * Run tasks with limited concurrency.
+ */
+declare function throttleAll(limit: number, tasks: any): Promise<unknown>;
+export { join, relative, dirname, mkdirp, mkdirpSync, readJson, lstatReadlinkAbsolute, stat, readFile, throttleAll, };

package/dist/base/fs.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttleAll = exports.readFile = exports.stat = exports.lstatReadlinkAbsolute = exports.readJson = exports.mkdirpSync = exports.mkdirp = exports.dirname = exports.relative = exports.join = void 0;
+const path_1 = __importDefault(require("path"));
+const notSettled = Symbol(`not-settled`);
+const relative = (fs, rootPath, targetPath) => {
+    if (fs === null || fs === void 0 ? void 0 : fs.relative) {
+        return fs.relative(rootPath, targetPath);
+    }
+    if (path_1.default.posix.isAbsolute(rootPath)) {
+        return path_1.default.posix.relative(rootPath, targetPath);
+    }
+    if (path_1.default.win32.isAbsolute(rootPath)) {
+        return path_1.default.win32.relative(rootPath, targetPath);
+    }
+    throw new Error(`${rootPath} is neither a posix nor a windows path, and there is no 'relative' method defined in the file system`);
+};
+exports.relative = relative;
+const join = (fs, rootPath, filename) => {
+    if (fs === null || fs === void 0 ? void 0 : fs.join) {
+        return fs.join(rootPath, filename);
+    }
+    if (path_1.default.posix.isAbsolute(rootPath)) {
+        return path_1.default.posix.join(rootPath, filename);
+    }
+    if (path_1.default.win32.isAbsolute(rootPath)) {
+        return path_1.default.win32.join(rootPath, filename);
+    }
+    throw new Error(`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`);
+};
+exports.join = join;
+const dirname = (fs, absPath) => {
+    if (fs === null || fs === void 0 ? void 0 : fs.dirname) {
+        return fs.dirname(absPath);
+    }
+    if (path_1.default.posix.isAbsolute(absPath)) {
+        return path_1.default.posix.dirname(absPath);
+    }
+    if (path_1.default.win32.isAbsolute(absPath)) {
+        return path_1.default.win32.dirname(absPath);
+    }
+    throw new Error(`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`);
+};
+exports.dirname = dirname;
+const mkdirp = (fs, p, callback) => {
+    fs.mkdir(p, err => {
+        if (err) {
+            if (err.code === 'ENOENT') {
+                const dir = dirname(fs, p);
+                if (dir === p) {
+                    callback(err);
+                    return;
+                }
+                mkdirp(fs, dir, err => {
+                    if (err) {
+                        callback(err);
+                        return;
+                    }
+                    fs.mkdir(p, err => {
+                        if (err) {
+                            if (err.code === 'EEXIST') {
+                                callback();
+                                return;
+                            }
+                            callback(err);
+                            return;
+                        }
+                        callback();
+                    });
+                });
+                return;
+            }
+            if (err.code === 'EEXIST') {
+                callback();
+                return;
+            }
+            callback(err);
+            return;
+        }
+        callback();
+    });
+};
+exports.mkdirp = mkdirp;
+const mkdirpSync = (fs, p) => {
+    try {
+        fs.mkdirSync(p);
+    }
+    catch (err) {
+        if (err) {
+            if (err.code === 'ENOENT') {
+                const dir = dirname(fs, p);
+                if (dir === p) {
+                    throw err;
+                }
+                mkdirpSync(fs, dir);
+                fs.mkdirSync(p);
+                return;
+            }
+            if (err.code === 'EEXIST') {
+                return;
+            }
+            throw err;
+        }
+    }
+};
+exports.mkdirpSync = mkdirpSync;
+const readJson = (fs, p, callback) => {
+    if ('readJson' in fs)
+        return fs.readJson(p, callback);
+    fs.readFile(p, (err, buf) => {
+        if (err)
+            return callback(err);
+        let data;
+        try {
+            data = JSON.parse(buf.toString('utf-8'));
+        }
+        catch (e) {
+            return callback(e);
+        }
+        return callback(null, data);
+    });
+};
+exports.readJson = readJson;
+const lstatReadlinkAbsolute = (fs, p, callback) => {
+    let i = 3;
+    const doReadLink = () => {
+        fs.readlink(p, (err, target) => {
+            if (err && --i > 0) {
+                // It might was just changed from symlink to file
+                // we retry 2 times to catch this case before throwing the error
+                return doStat();
+            }
+            if (err || !target)
+                return doStat();
+            const value = target.toString();
+            callback(null, join(fs, dirname(fs, p), value));
+        });
+    };
+    const doStat = () => {
+        if ('lstat' in fs) {
+            return fs.lstat(p, (err, stats) => {
+                if (err)
+                    return callback(err);
+                if (stats.isSymbolicLink()) {
+                    return doReadLink();
+                }
+                callback(null, stats);
+            });
+        }
+        return fs.stat(p, callback);
+    };
+    if ('lstat' in fs)
+        return doStat();
+    doReadLink();
+};
+exports.lstatReadlinkAbsolute = lstatReadlinkAbsolute;
+function stat(fs, path) {
+    return new Promise((resolve, reject) => {
+        fs.stat(path, 
+        // @ts-ignore
+        (err, stats) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(stats);
+        });
+    });
+}
+exports.stat = stat;
+function readFile(fs, path) {
+    return new Promise((resolve, reject) => {
+        fs.readFile(path, (err, data) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(data);
+        });
+    });
+}
+exports.readFile = readFile;
+/**
+ * Run tasks with limited concurrency.
+ */
+function throttleAll(limit, tasks) {
+    if (!Number.isInteger(limit) || limit < 1) {
+        throw new TypeError(`Expected \`limit\` to be a finite number > 0, got \`${limit}\` (${typeof limit})`);
+    }
+    if (!Array.isArray(tasks) || !tasks.every(task => typeof task === `function`)) {
+        throw new TypeError(`Expected \`tasks\` to be a list of functions returning a promise`);
+    }
+    return new Promise((resolve, reject) => {
+        const result = Array(tasks.length).fill(notSettled);
+        const entries = tasks.entries();
+        const next = () => {
+            const { done, value } = entries.next();
+            if (done) {
+                const isLast = !result.includes(notSettled);
+                if (isLast) {
+                    resolve(result);
+                }
+                return;
+            }
+            const [index, task] = value;
+            const onFulfilled = x => {
+                result[index] = x;
+                next();
+            };
+            task().then(onFulfilled, reject);
+        };
+        Array(limit).fill(0).forEach(next);
+    });
+}
+exports.throttleAll = throttleAll;

package/dist/base/hash/BatchedHash.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import Hash from '../Hash';
+declare class BatchedHash extends Hash {
+    string: string | undefined;
+    encoding: string | undefined;
+    hash: any;
+    constructor(hash: any);
+    update(data: string | Buffer, inputEncoding?: string): this;
+    digest(encoding?: string): any;
+}
+export default BatchedHash;

package/dist/base/hash/BatchedHash.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Hash_1 = __importDefault(require("../Hash"));
+const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
+class BatchedHash extends Hash_1.default {
+    constructor(hash) {
+        super();
+        this.hash = hash;
+    }
+    update(data, inputEncoding) {
+        if (this.string !== undefined) {
+            if (typeof data === 'string' &&
+                inputEncoding === this.encoding &&
+                this.string.length + data.length < MAX_SHORT_STRING) {
+                this.string += data;
+                return this;
+            }
+            this.hash.update(this.string, this.encoding);
+            this.string = undefined;
+        }
+        if (typeof data === 'string') {
+            if (data.length < MAX_SHORT_STRING &&
+                // base64 encoding is not valid since it may contain padding chars
+                (!inputEncoding || !inputEncoding.startsWith('ba'))) {
+                this.string = data;
+                this.encoding = inputEncoding;
+            }
+            else {
+                this.hash.update(data, inputEncoding);
+            }
+        }
+        else {
+            this.hash.update(data);
+        }
+        return this;
+    }
+    digest(encoding) {
+        if (this.string !== undefined) {
+            this.hash.update(this.string, this.encoding);
+        }
+        return this.hash.digest(encoding);
+    }
+}
+exports.default = BatchedHash;

package/dist/base/hash/md4.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => any;
+export default _default;

package/dist/base/hash/md4.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wasm_hash_1 = require("./wasm-hash");
+// #region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
+// @ts-ignore
+const md4 = new WebAssembly.Module(Buffer.from(
+// 2154 bytes
+'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', 'base64'));
+// #endregion
+exports.default = wasm_hash_1.create.bind(null, md4, [], 64, 32);

package/dist/base/hash/wasm-hash.d.ts

@@ -0,0 +1,3 @@
+declare const MAX_SHORT_STRING: number;
+declare const create: (wasmModule: any, instancesPool: any, chunkSize: any, digestSize: any) => any;
+export { MAX_SHORT_STRING, create };

package/dist/base/hash/wasm-hash.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = exports.MAX_SHORT_STRING = void 0;
+// 65536 is the size of a wasm memory page
+// 64 is the maximum chunk size for every possible wasm hash implementation
+// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
+// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
+exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
+class WasmHash {
+    constructor(instance, instancesPool, chunkSize, digestSize) {
+        const exports = instance.exports;
+        exports.init();
+        this.exports = exports;
+        this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+        this.buffered = 0;
+        this.instancesPool = instancesPool;
+        this.chunkSize = chunkSize;
+        this.digestSize = digestSize;
+    }
+    reset() {
+        this.buffered = 0;
+        this.exports.init();
+    }
+    update(data, encoding) {
+        if (typeof data === 'string') {
+            while (data.length > MAX_SHORT_STRING) {
+                this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+                data = data.slice(MAX_SHORT_STRING);
+            }
+            this._updateWithShortString(data, encoding);
+            return this;
+        }
+        this._updateWithBuffer(data);
+        return this;
+    }
+    _updateWithShortString(data, encoding) {
+        const { exports, buffered, mem, chunkSize } = this;
+        let endPos;
+        if (data.length < 70) {
+            if (!encoding || encoding === 'utf-8' || encoding === 'utf8') {
+                endPos = buffered;
+                for (let i = 0; i < data.length; i++) {
+                    const cc = data.charCodeAt(i);
+                    if (cc < 0x80)
+                        mem[endPos++] = cc;
+                    else if (cc < 0x800) {
+                        mem[endPos] = (cc >> 6) | 0xc0;
+                        mem[endPos + 1] = (cc & 0x3f) | 0x80;
+                        endPos += 2;
+                    }
+                    else {
+                        // bail-out for weird chars
+                        endPos += mem.write(data.slice(i), endPos, encoding);
+                        break;
+                    }
+                }
+            }
+            else if (encoding === 'latin1') {
+                endPos = buffered;
+                for (let i = 0; i < data.length; i++) {
+                    const cc = data.charCodeAt(i);
+                    mem[endPos++] = cc;
+                }
+            }
+            else {
+                endPos = buffered + mem.write(data, buffered, encoding);
+            }
+        }
+        else {
+            endPos = buffered + mem.write(data, buffered, encoding);
+        }
+        if (endPos < chunkSize) {
+            this.buffered = endPos;
+        }
+        else {
+            const l = endPos & ~(this.chunkSize - 1);
+            exports.update(l);
+            const newBuffered = endPos - l;
+            this.buffered = newBuffered;
+            if (newBuffered > 0)
+                mem.copyWithin(0, l, endPos);
+        }
+    }
+    _updateWithBuffer(data) {
+        const { exports, buffered, mem } = this;
+        const length = data.length;
+        if (buffered + length < this.chunkSize) {
+            data.copy(mem, buffered, 0, length);
+            this.buffered += length;
+        }
+        else {
+            const l = (buffered + length) & ~(this.chunkSize - 1);
+            if (l > 65536) {
+                let i = 65536 - buffered;
+                data.copy(mem, buffered, 0, i);
+                exports.update(65536);
+                const stop = l - buffered - 65536;
+                while (i < stop) {
+                    data.copy(mem, 0, i, i + 65536);
+                    exports.update(65536);
+                    i += 65536;
+                }
+                data.copy(mem, 0, i, l - buffered);
+                exports.update(l - buffered - i);
+            }
+            else {
+                data.copy(mem, buffered, 0, l - buffered);
+                exports.update(l);
+            }
+            const newBuffered = length + buffered - l;
+            this.buffered = newBuffered;
+            if (newBuffered > 0)
+                data.copy(mem, 0, length - newBuffered, length);
+        }
+    }
+    digest(type) {
+        const { exports, buffered, mem, digestSize } = this;
+        exports.final(buffered);
+        this.instancesPool.push(this);
+        const hex = mem.toString('latin1', 0, digestSize);
+        if (type === 'hex')
+            return hex;
+        if (type === 'binary' || !type)
+            return Buffer.from(hex, 'hex');
+        return Buffer.from(hex, 'hex').toString(type);
+    }
+}
+const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
+    if (instancesPool.length > 0) {
+        const old = instancesPool.pop();
+        old.reset();
+        return old;
+    }
+    // @ts-ignore
+    return new WasmHash(new WebAssembly.Instance(wasmModule), instancesPool, chunkSize, digestSize);
+};
+exports.create = create;

package/dist/base/hash/xxhash64.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => any;
+export default _default;

package/dist/base/hash/xxhash64.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wasm_hash_1 = require("./wasm-hash");
+// #region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
+// @ts-ignore
+const xxhash64 = new WebAssembly.Module(Buffer.from(
+// 1170 bytes
+'AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrIIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAFBIGoiASAASQ0ACyACJAAgAyQBIAQkAiAFJAMLqAYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEAgAiABNQIAQoeVr6+Ytt6bnn9+hUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhAiABQQRqIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAkIdiCAChUL5893xmfaZqxZ+IgJCIIggAoUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL', 'base64'));
+// #endregion
+exports.default = wasm_hash_1.create.bind(null, xxhash64, [], 32, 16);

package/dist/base/identifier.d.ts

@@ -0,0 +1,30 @@
+declare const makePathsRelative: {
+    (context: string, identifier: string, associatedObjectForCache?: Object): any;
+    bindCache(associatedObjectForCache?: Object): (context: any, identifier: any) => any;
+    bindContextCache(context: string, associatedObjectForCache?: Object): (identifier: any) => any;
+};
+declare const makePathsAbsolute: {
+    (context: string, identifier: string, associatedObjectForCache?: Object): any;
+    bindCache(associatedObjectForCache?: Object): (context: any, identifier: any) => any;
+    bindContextCache(context: string, associatedObjectForCache?: Object): (identifier: any) => any;
+};
+declare const contextify: {
+    (context: string, identifier: string, associatedObjectForCache?: Object): any;
+    bindCache(associatedObjectForCache?: Object): (context: any, identifier: any) => any;
+    bindContextCache(context: string, associatedObjectForCache?: Object): (identifier: any) => any;
+};
+declare const absolutify: {
+    (context: string, identifier: string, associatedObjectForCache?: Object): any;
+    bindCache(associatedObjectForCache?: Object): (context: any, identifier: any) => any;
+    bindContextCache(context: string, associatedObjectForCache?: Object): (identifier: any) => any;
+};
+declare const parseResource: {
+    (str: string, associatedObjectForCache?: Object): any;
+    bindCache(associatedObjectForCache: any): (str: any) => any;
+};
+declare const parseResourceWithoutFragment: {
+    (str: string, associatedObjectForCache?: Object): any;
+    bindCache(associatedObjectForCache: any): (str: any) => any;
+};
+declare const getUndoPath: (filename: any, outputPath: string, enforceRelative: boolean) => string;
+export { makePathsRelative, makePathsAbsolute, contextify, absolutify, parseResource, parseResourceWithoutFragment, getUndoPath, };