@tybys/wasm-util 0.1.0

package/lib/mjs/memory.mjs

@@ -0,0 +1,25 @@
+/** @public */
+export class Memory extends WebAssembly.Memory {
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(descriptor) {
+        super(descriptor);
+    }
+    get HEAP8() { return new Int8Array(super.buffer); }
+    get HEAPU8() { return new Uint8Array(super.buffer); }
+    get HEAP16() { return new Int16Array(super.buffer); }
+    get HEAPU16() { return new Uint16Array(super.buffer); }
+    get HEAP32() { return new Int32Array(super.buffer); }
+    get HEAPU32() { return new Uint32Array(super.buffer); }
+    get HEAP64() { return new BigInt64Array(super.buffer); }
+    get HEAPU64() { return new BigUint64Array(super.buffer); }
+    get HEAPF32() { return new Float32Array(super.buffer); }
+    get HEAPF64() { return new Float64Array(super.buffer); }
+    get view() { return new DataView(super.buffer); }
+}
+/** @public */
+export function extendMemory(memory) {
+    if (Object.getPrototypeOf(memory) === WebAssembly.Memory.prototype) {
+        Object.setPrototypeOf(memory, Memory.prototype);
+    }
+    return memory;
+}

package/lib/mjs/wasi/error.mjs

@@ -0,0 +1,97 @@
+import { WasiErrno } from "./types.mjs";
+export function strerror(errno) {
+    switch (errno) {
+        case WasiErrno.ESUCCESS: return 'Success';
+        case WasiErrno.E2BIG: return 'Argument list too long';
+        case WasiErrno.EACCES: return 'Permission denied';
+        case WasiErrno.EADDRINUSE: return 'Address in use';
+        case WasiErrno.EADDRNOTAVAIL: return 'Address not available';
+        case WasiErrno.EAFNOSUPPORT: return 'Address family not supported by protocol';
+        case WasiErrno.EAGAIN: return 'Resource temporarily unavailable';
+        case WasiErrno.EALREADY: return 'Operation already in progress';
+        case WasiErrno.EBADF: return 'Bad file descriptor';
+        case WasiErrno.EBADMSG: return 'Bad message';
+        case WasiErrno.EBUSY: return 'Resource busy';
+        case WasiErrno.ECANCELED: return 'Operation canceled';
+        case WasiErrno.ECHILD: return 'No child process';
+        case WasiErrno.ECONNABORTED: return 'Connection aborted';
+        case WasiErrno.ECONNREFUSED: return 'Connection refused';
+        case WasiErrno.ECONNRESET: return 'Connection reset by peer';
+        case WasiErrno.EDEADLK: return 'Resource deadlock would occur';
+        case WasiErrno.EDESTADDRREQ: return 'Destination address required';
+        case WasiErrno.EDOM: return 'Domain error';
+        case WasiErrno.EDQUOT: return 'Quota exceeded';
+        case WasiErrno.EEXIST: return 'File exists';
+        case WasiErrno.EFAULT: return 'Bad address';
+        case WasiErrno.EFBIG: return 'File too large';
+        case WasiErrno.EHOSTUNREACH: return 'Host is unreachable';
+        case WasiErrno.EIDRM: return 'Identifier removed';
+        case WasiErrno.EILSEQ: return 'Illegal byte sequence';
+        case WasiErrno.EINPROGRESS: return 'Operation in progress';
+        case WasiErrno.EINTR: return 'Interrupted system call';
+        case WasiErrno.EINVAL: return 'Invalid argument';
+        case WasiErrno.EIO: return 'I/O error';
+        case WasiErrno.EISCONN: return 'Socket is connected';
+        case WasiErrno.EISDIR: return 'Is a directory';
+        case WasiErrno.ELOOP: return 'Symbolic link loop';
+        case WasiErrno.EMFILE: return 'No file descriptors available';
+        case WasiErrno.EMLINK: return 'Too many links';
+        case WasiErrno.EMSGSIZE: return 'Message too large';
+        case WasiErrno.EMULTIHOP: return 'Multihop attempted';
+        case WasiErrno.ENAMETOOLONG: return 'Filename too long';
+        case WasiErrno.ENETDOWN: return 'Network is down';
+        case WasiErrno.ENETRESET: return 'Connection reset by network';
+        case WasiErrno.ENETUNREACH: return 'Network unreachable';
+        case WasiErrno.ENFILE: return 'Too many files open in system';
+        case WasiErrno.ENOBUFS: return 'No buffer space available';
+        case WasiErrno.ENODEV: return 'No such device';
+        case WasiErrno.ENOENT: return 'No such file or directory';
+        case WasiErrno.ENOEXEC: return 'Exec format error';
+        case WasiErrno.ENOLCK: return 'No locks available';
+        case WasiErrno.ENOLINK: return 'Link has been severed';
+        case WasiErrno.ENOMEM: return 'Out of memory';
+        case WasiErrno.ENOMSG: return 'No message of the desired type';
+        case WasiErrno.ENOPROTOOPT: return 'Protocol not available';
+        case WasiErrno.ENOSPC: return 'No space left on device';
+        case WasiErrno.ENOSYS: return 'Function not implemented';
+        case WasiErrno.ENOTCONN: return 'Socket not connected';
+        case WasiErrno.ENOTDIR: return 'Not a directory';
+        case WasiErrno.ENOTEMPTY: return 'Directory not empty';
+        case WasiErrno.ENOTRECOVERABLE: return 'State not recoverable';
+        case WasiErrno.ENOTSOCK: return 'Not a socket';
+        case WasiErrno.ENOTSUP: return 'Not supported';
+        case WasiErrno.ENOTTY: return 'Not a tty';
+        case WasiErrno.ENXIO: return 'No such device or address';
+        case WasiErrno.EOVERFLOW: return 'Value too large for data type';
+        case WasiErrno.EOWNERDEAD: return 'Previous owner died';
+        case WasiErrno.EPERM: return 'Operation not permitted';
+        case WasiErrno.EPIPE: return 'Broken pipe';
+        case WasiErrno.EPROTO: return 'Protocol error';
+        case WasiErrno.EPROTONOSUPPORT: return 'Protocol not supported';
+        case WasiErrno.EPROTOTYPE: return 'Protocol wrong type for socket';
+        case WasiErrno.ERANGE: return 'Result not representable';
+        case WasiErrno.EROFS: return 'Read-only file system';
+        case WasiErrno.ESPIPE: return 'Invalid seek';
+        case WasiErrno.ESRCH: return 'No such process';
+        case WasiErrno.ESTALE: return 'Stale file handle';
+        case WasiErrno.ETIMEDOUT: return 'Operation timed out';
+        case WasiErrno.ETXTBSY: return 'Text file busy';
+        case WasiErrno.EXDEV: return 'Cross-device link';
+        case WasiErrno.ENOTCAPABLE: return 'Capabilities insufficient';
+        default: return 'Unknown error';
+    }
+}
+export class WasiError extends Error {
+    constructor(message, errno) {
+        super(message);
+        this.errno = errno;
+    }
+    getErrorMessage() {
+        return strerror(this.errno);
+    }
+}
+Object.defineProperty(WasiError.prototype, 'name', {
+    configurable: true,
+    writable: true,
+    value: 'WasiError'
+});

package/lib/mjs/wasi/fd.mjs

@@ -0,0 +1,216 @@
+import { WasiErrno, FileControlFlag, WasiFileType, WasiWhence } from "./types.mjs";
+import { getRights } from "./rights.mjs";
+import { WasiError } from "./error.mjs";
+export function concatBuffer(buffers, size) {
+    let total = 0;
+    if (typeof size === 'number' && size >= 0) {
+        total = size;
+    }
+    else {
+        for (let i = 0; i < buffers.length; i++) {
+            const buffer = buffers[i];
+            total += buffer.length;
+        }
+    }
+    let pos = 0;
+    const ret = new Uint8Array(total);
+    for (let i = 0; i < buffers.length; i++) {
+        const buffer = buffers[i];
+        ret.set(buffer, pos);
+        pos += buffer.length;
+    }
+    return ret;
+}
+export class FileDescriptor {
+    constructor(id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen) {
+        this.id = id;
+        this.fd = fd;
+        this.path = path;
+        this.realPath = realPath;
+        this.type = type;
+        this.rightsBase = rightsBase;
+        this.rightsInheriting = rightsInheriting;
+        this.preopen = preopen;
+        this.pos = BigInt(0);
+        this.size = BigInt(0);
+    }
+    seek(offset, whence) {
+        if (whence === WasiWhence.SET) {
+            this.pos = BigInt(offset);
+        }
+        else if (whence === WasiWhence.CUR) {
+            this.pos += BigInt(offset);
+        }
+        else if (whence === WasiWhence.END) {
+            this.pos = BigInt(this.size) - BigInt(offset);
+        }
+        else {
+            throw new WasiError('Unknown whence', WasiErrno.EIO);
+        }
+        return this.pos;
+    }
+}
+export class StandardOutput extends FileDescriptor {
+    constructor(log, id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen) {
+        super(id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen);
+        this._log = log;
+        this._buf = null;
+    }
+    write(buffer) {
+        const originalBuffer = buffer;
+        if (this._buf) {
+            buffer = concatBuffer([this._buf, buffer]);
+            this._buf = null;
+        }
+        if (buffer.indexOf(10) === -1) {
+            this._buf = buffer;
+            return originalBuffer.byteLength;
+        }
+        let written = 0;
+        let lastBegin = 0;
+        let index;
+        while ((index = buffer.indexOf(10, written)) !== -1) {
+            const str = new TextDecoder().decode(buffer.subarray(lastBegin, index));
+            this._log(str);
+            written += index - lastBegin + 1;
+            lastBegin = index + 1;
+        }
+        if (written < buffer.length) {
+            this._buf = buffer.slice(written);
+        }
+        return originalBuffer.byteLength;
+    }
+}
+export function toFileType(stat) {
+    if (stat.isBlockDevice())
+        return WasiFileType.BLOCK_DEVICE;
+    if (stat.isCharacterDevice())
+        return WasiFileType.CHARACTER_DEVICE;
+    if (stat.isDirectory())
+        return WasiFileType.DIRECTORY;
+    if (stat.isSocket())
+        return WasiFileType.SOCKET_STREAM;
+    if (stat.isFile())
+        return WasiFileType.REGULAR_FILE;
+    if (stat.isSymbolicLink())
+        return WasiFileType.SYMBOLIC_LINK;
+    return WasiFileType.UNKNOWN;
+}
+export function toFileStat(view, buf, stat) {
+    view.setBigUint64(buf, stat.dev, true);
+    view.setBigUint64(buf + 8, stat.ino, true);
+    view.setBigUint64(buf + 16, BigInt(toFileType(stat)), true);
+    view.setBigUint64(buf + 24, stat.nlink, true);
+    view.setBigUint64(buf + 32, stat.size, true);
+    view.setBigUint64(buf + 40, stat.atimeMs * BigInt(1000000), true);
+    view.setBigUint64(buf + 48, stat.mtimeMs * BigInt(1000000), true);
+    view.setBigUint64(buf + 56, stat.ctimeMs * BigInt(1000000), true);
+}
+export class FileDescriptorTable {
+    constructor(options) {
+        this.used = 0;
+        this.size = options.size;
+        this.fds = Array(options.size);
+        this.stdio = [options.in, options.out, options.err];
+        this.fs = options.fs;
+        this.print = options.print;
+        this.printErr = options.printErr;
+        this.insertStdio(options.in, 0, '<stdin>');
+        this.insertStdio(options.out, 1, '<stdout>');
+        this.insertStdio(options.err, 2, '<stderr>');
+    }
+    insertStdio(fd, expected, name) {
+        const type = WasiFileType.CHARACTER_DEVICE;
+        const { base, inheriting } = getRights(this.stdio, fd, FileControlFlag.O_RDWR, type);
+        const wrap = this.insert(fd, name, name, type, base, inheriting, 0);
+        if (wrap.id !== expected) {
+            throw new WasiError(`id: ${wrap.id} !== expected: ${expected}`, WasiErrno.EBADF);
+        }
+        return wrap;
+    }
+    insert(fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen) {
+        var _a, _b;
+        let index = -1;
+        if (this.used >= this.size) {
+            const newSize = this.size * 2;
+            this.fds.length = newSize;
+            index = this.size;
+            this.size = newSize;
+        }
+        else {
+            for (let i = 0; i < this.size; ++i) {
+                if (this.fds[i] == null) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+        let entry;
+        if (mappedPath === '<stdout>') {
+            entry = new StandardOutput((_a = this.print) !== null && _a !== void 0 ? _a : console.log, index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);
+        }
+        else if (mappedPath === '<stderr>') {
+            entry = new StandardOutput((_b = this.printErr) !== null && _b !== void 0 ? _b : console.error, index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);
+        }
+        else {
+            entry = new FileDescriptor(index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);
+        }
+        this.fds[index] = entry;
+        this.used++;
+        return entry;
+    }
+    getFileTypeByFd(fd) {
+        const stat = this.fs.fstatSync(fd);
+        return toFileType(stat);
+    }
+    insertPreopen(fd, mappedPath, realPath) {
+        const type = this.getFileTypeByFd(fd);
+        if (type !== WasiFileType.DIRECTORY) {
+            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
+        }
+        const result = getRights(this.stdio, fd, 0, type);
+        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
+    }
+    get(id, base, inheriting) {
+        if (id >= this.size) {
+            throw new WasiError('Invalid fd', WasiErrno.EBADF);
+        }
+        const entry = this.fds[id];
+        if (!entry || entry.id !== id) {
+            throw new WasiError('Bad file descriptor', WasiErrno.EBADF);
+        }
+        /* Validate that the fd has the necessary rights. */
+        if ((~entry.rightsBase & base) !== BigInt(0) || (~entry.rightsInheriting & inheriting) !== BigInt(0)) {
+            throw new WasiError('Capabilities insufficient', WasiErrno.ENOTCAPABLE);
+        }
+        return entry;
+    }
+    remove(id) {
+        if (id >= this.size) {
+            throw new WasiError('Invalid fd', WasiErrno.EBADF);
+        }
+        const entry = this.fds[id];
+        if (!entry || entry.id !== id) {
+            throw new WasiError('Bad file descriptor', WasiErrno.EBADF);
+        }
+        this.fds[id] = undefined;
+        this.used--;
+    }
+    renumber(dst, src) {
+        if (dst === src)
+            return;
+        if (dst >= this.size || src >= this.size) {
+            throw new WasiError('Invalid fd', WasiErrno.EBADF);
+        }
+        const dstEntry = this.fds[dst];
+        const srcEntry = this.fds[src];
+        if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) {
+            throw new WasiError('Invalid fd', WasiErrno.EBADF);
+        }
+        this.fs.closeSync(dstEntry.fd);
+        this.fds[dst] = this.fds[src];
+        this.fds[dst].id = dst;
+        this.fds[src] = undefined;
+        this.used--;
+    }
+}

package/lib/mjs/wasi/index.mjs

@@ -0,0 +1,132 @@
+import { WASI as _WASI } from "./preview1.mjs";
+import { validateObject, validateArray, validateBoolean, validateFunction, validateUndefined, validateString } from "./util.mjs";
+const kEmptyObject = Object.freeze(Object.create(null));
+const kExitCode = Symbol('kExitCode');
+const kSetMemory = Symbol('kSetMemory');
+const kStarted = Symbol('kStarted');
+const kInstance = Symbol('kInstance');
+function setupInstance(self, instance) {
+    validateObject(instance, 'instance');
+    validateObject(instance.exports, 'instance.exports');
+    self[kInstance] = instance;
+    self[kSetMemory](instance.exports.memory);
+}
+// /** @public */
+// export type WasiSnapshotPreview1 = Omit<_WASI, '_setMemory'>
+/** @public */
+export class WASI {
+    constructor(options = kEmptyObject) {
+        var _a;
+        validateObject(options, 'options');
+        if (options.args !== undefined) {
+            validateArray(options.args, 'options.args');
+        }
+        const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);
+        const env = [];
+        if (options.env !== undefined) {
+            validateObject(options.env, 'options.env');
+            Object.entries(options.env).forEach(({ 0: key, 1: value }) => {
+                if (value !== undefined) {
+                    env.push(`${key}=${value}`);
+                }
+            });
+        }
+        const preopens = [];
+        if (options.preopens !== undefined) {
+            validateObject(options.preopens, 'options.preopens');
+            Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));
+        }
+        if (preopens.length > 0) {
+            if (options.filesystem === undefined) {
+                throw new Error('filesystem is disabled, can not preopen directory');
+            }
+        }
+        if (options.filesystem !== undefined) {
+            validateObject(options.filesystem, 'options.filesystem');
+            validateString(options.filesystem.type, 'options.filesystem.type');
+            if (options.filesystem.type !== 'memfs') {
+                throw new Error(`Filesystem type ${options.filesystem.type} is not supported, only "memfs" is supported currently`);
+            }
+            try {
+                validateObject(options.filesystem.fs, 'options.filesystem.fs');
+            }
+            catch (_) {
+                throw new Error('Node.js fs like implementation is not provided');
+            }
+        }
+        if (options.print !== undefined)
+            validateFunction(options.print, 'options.print');
+        if (options.printErr !== undefined)
+            validateFunction(options.printErr, 'options.printErr');
+        // const { stdin = 0, stdout = 1, stderr = 2 } = options
+        // validateInt32(stdin, 'options.stdin', 0)
+        // validateInt32(stdout, 'options.stdout', 0)
+        // validateInt32(stderr, 'options.stderr', 0)
+        // const stdio = [stdin, stdout, stderr] as const
+        const stdio = [0, 1, 2];
+        const wrap = new _WASI(args, env, preopens, stdio, options.filesystem, options.print, options.printErr);
+        for (const prop in wrap) {
+            wrap[prop] = wrap[prop].bind(wrap);
+        }
+        if (options.returnOnExit !== undefined) {
+            validateBoolean(options.returnOnExit, 'options.returnOnExit');
+            if (options.returnOnExit) {
+                wrap.proc_exit = wasiReturnOnProcExit.bind(this);
+            }
+        }
+        this[kSetMemory] = wrap._setMemory;
+        delete wrap._setMemory;
+        this.wasiImport = wrap;
+        this[kStarted] = false;
+        this[kExitCode] = 0;
+        this[kInstance] = undefined;
+    }
+    // Must not export _initialize, must export _start
+    start(instance) {
+        if (this[kStarted]) {
+            throw new Error('WASI instance has already started');
+        }
+        this[kStarted] = true;
+        setupInstance(this, instance);
+        const { _start, _initialize } = this[kInstance].exports;
+        validateFunction(_start, 'instance.exports._start');
+        validateUndefined(_initialize, 'instance.exports._initialize');
+        let ret;
+        try {
+            ret = _start();
+        }
+        catch (err) {
+            if (err !== kExitCode) {
+                throw err;
+            }
+        }
+        if (ret instanceof Promise) {
+            return ret.then(() => this[kExitCode], (err) => {
+                if (err !== kExitCode) {
+                    throw err;
+                }
+                return this[kExitCode];
+            });
+        }
+        return this[kExitCode];
+    }
+    // Must not export _start, may optionally export _initialize
+    initialize(instance) {
+        if (this[kStarted]) {
+            throw new Error('WASI instance has already started');
+        }
+        this[kStarted] = true;
+        setupInstance(this, instance);
+        const { _start, _initialize } = this[kInstance].exports;
+        validateUndefined(_start, 'instance.exports._start');
+        if (_initialize !== undefined) {
+            validateFunction(_initialize, 'instance.exports._initialize');
+            return _initialize();
+        }
+    }
+}
+function wasiReturnOnProcExit(rval) {
+    this[kExitCode] = rval;
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    throw kExitCode;
+}

package/lib/mjs/wasi/path.mjs

@@ -0,0 +1,168 @@
+import { validateString } from "./util.mjs";
+const CHAR_DOT = 46; /* . */
+const CHAR_FORWARD_SLASH = 47; /* / */
+function isPosixPathSeparator(code) {
+    return code === CHAR_FORWARD_SLASH;
+}
+function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
+    let res = '';
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code = 0;
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length) {
+            code = path.charCodeAt(i);
+        }
+        else if (isPathSeparator(code)) {
+            break;
+        }
+        else {
+            code = CHAR_FORWARD_SLASH;
+        }
+        if (isPathSeparator(code)) {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (dots === 2) {
+                if (res.length < 2 || lastSegmentLength !== 2 ||
+                    res.charCodeAt(res.length - 1) !== CHAR_DOT ||
+                    res.charCodeAt(res.length - 2) !== CHAR_DOT) {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.indexOf(separator);
+                        if (lastSlashIndex === -1) {
+                            res = '';
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength =
+                                res.length - 1 - res.indexOf(separator);
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length !== 0) {
+                        res = '';
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    res += res.length > 0 ? `${separator}..` : '..';
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0) {
+                    res += `${separator}${path.slice(lastSlash + 1, i)}`;
+                }
+                else {
+                    res = path.slice(lastSlash + 1, i);
+                }
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === CHAR_DOT && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+export function resolve(...args) {
+    let resolvedPath = '';
+    let resolvedAbsolute = false;
+    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        const path = i >= 0 ? args[i] : '/';
+        validateString(path, 'path');
+        // Skip empty entries
+        if (path.length === 0) {
+            continue;
+        }
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+    }
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+    // Normalize the path
+    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);
+    if (resolvedAbsolute) {
+        return `/${resolvedPath}`;
+    }
+    return resolvedPath.length > 0 ? resolvedPath : '.';
+}
+export function relative(from, to) {
+    validateString(from, 'from');
+    validateString(to, 'to');
+    if (from === to)
+        return '';
+    // Trim leading forward slashes.
+    from = resolve(from);
+    to = resolve(to);
+    if (from === to)
+        return '';
+    const fromStart = 1;
+    const fromEnd = from.length;
+    const fromLen = fromEnd - fromStart;
+    const toStart = 1;
+    const toLen = to.length - toStart;
+    // Compare paths to find the longest common path from root
+    const length = (fromLen < toLen ? fromLen : toLen);
+    let lastCommonSep = -1;
+    let i = 0;
+    for (; i < length; i++) {
+        const fromCode = from.charCodeAt(fromStart + i);
+        if (fromCode !== to.charCodeAt(toStart + i)) {
+            break;
+        }
+        else if (fromCode === CHAR_FORWARD_SLASH) {
+            lastCommonSep = i;
+        }
+    }
+    if (i === length) {
+        if (toLen > length) {
+            if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
+                // We get here if `from` is the exact base path for `to`.
+                // For example: from='/foo/bar'; to='/foo/bar/baz'
+                return to.slice(toStart + i + 1);
+            }
+            if (i === 0) {
+                // We get here if `from` is the root
+                // For example: from='/'; to='/foo'
+                return to.slice(toStart + i);
+            }
+        }
+        else if (fromLen > length) {
+            if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
+                // We get here if `to` is the exact base path for `from`.
+                // For example: from='/foo/bar/baz'; to='/foo/bar'
+                lastCommonSep = i;
+            }
+            else if (i === 0) {
+                // We get here if `to` is the root.
+                // For example: from='/foo/bar'; to='/'
+                lastCommonSep = 0;
+            }
+        }
+    }
+    let out = '';
+    // Generate the relative path based on the path difference between `to`
+    // and `from`.
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+        if (i === fromEnd ||
+            from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+            out += out.length === 0 ? '..' : '/..';
+        }
+    }
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts.
+    return `${out}${to.slice(toStart + lastCommonSep)}`;
+}