first commit

app_vue/node_modules/memfs/lib/Dirent.d.ts

@@ -0,0 +1,19 @@
+import { Link } from './node';
+import { TEncodingExtended, TDataOut } from './encoding';
+/**
+ * A directory entry, like `fs.Dirent`.
+ */
+export declare class Dirent {
+    static build(link: Link, encoding: TEncodingExtended | undefined): Dirent;
+    name: TDataOut;
+    private mode;
+    private _checkModeProperty;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export default Dirent;

app_vue/node_modules/memfs/lib/Dirent.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dirent = void 0;
+var constants_1 = require("./constants");
+var encoding_1 = require("./encoding");
+var S_IFMT = constants_1.constants.S_IFMT, S_IFDIR = constants_1.constants.S_IFDIR, S_IFREG = constants_1.constants.S_IFREG, S_IFBLK = constants_1.constants.S_IFBLK, S_IFCHR = constants_1.constants.S_IFCHR, S_IFLNK = constants_1.constants.S_IFLNK, S_IFIFO = constants_1.constants.S_IFIFO, S_IFSOCK = constants_1.constants.S_IFSOCK;
+/**
+ * A directory entry, like `fs.Dirent`.
+ */
+var Dirent = /** @class */ (function () {
+    function Dirent() {
+        this.name = '';
+        this.mode = 0;
+    }
+    Dirent.build = function (link, encoding) {
+        var dirent = new Dirent();
+        var mode = link.getNode().mode;
+        dirent.name = (0, encoding_1.strToEncoding)(link.getName(), encoding);
+        dirent.mode = mode;
+        return dirent;
+    };
+    Dirent.prototype._checkModeProperty = function (property) {
+        return (this.mode & S_IFMT) === property;
+    };
+    Dirent.prototype.isDirectory = function () {
+        return this._checkModeProperty(S_IFDIR);
+    };
+    Dirent.prototype.isFile = function () {
+        return this._checkModeProperty(S_IFREG);
+    };
+    Dirent.prototype.isBlockDevice = function () {
+        return this._checkModeProperty(S_IFBLK);
+    };
+    Dirent.prototype.isCharacterDevice = function () {
+        return this._checkModeProperty(S_IFCHR);
+    };
+    Dirent.prototype.isSymbolicLink = function () {
+        return this._checkModeProperty(S_IFLNK);
+    };
+    Dirent.prototype.isFIFO = function () {
+        return this._checkModeProperty(S_IFIFO);
+    };
+    Dirent.prototype.isSocket = function () {
+        return this._checkModeProperty(S_IFSOCK);
+    };
+    return Dirent;
+}());
+exports.Dirent = Dirent;
+exports.default = Dirent;

app_vue/node_modules/memfs/lib/Stats.d.ts

@@ -0,0 +1,37 @@
+import { Node } from './node';
+export type TStatNumber = number | bigint;
+/**
+ * Statistics about a file/directory, like `fs.Stats`.
+ */
+export declare class Stats<T = TStatNumber> {
+    static build(node: Node, bigint: false): Stats<number>;
+    static build(node: Node, bigint: true): Stats<bigint>;
+    static build(node: Node, bigint?: boolean): Stats<TStatNumber>;
+    uid: T;
+    gid: T;
+    rdev: T;
+    blksize: T;
+    ino: T;
+    size: T;
+    blocks: T;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    atimeMs: T;
+    mtimeMs: T;
+    ctimeMs: T;
+    birthtimeMs: T;
+    dev: T;
+    mode: T;
+    nlink: T;
+    private _checkModeProperty;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export default Stats;

app_vue/node_modules/memfs/lib/Stats.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stats = void 0;
+var constants_1 = require("./constants");
+var getBigInt_1 = require("./getBigInt");
+var S_IFMT = constants_1.constants.S_IFMT, S_IFDIR = constants_1.constants.S_IFDIR, S_IFREG = constants_1.constants.S_IFREG, S_IFBLK = constants_1.constants.S_IFBLK, S_IFCHR = constants_1.constants.S_IFCHR, S_IFLNK = constants_1.constants.S_IFLNK, S_IFIFO = constants_1.constants.S_IFIFO, S_IFSOCK = constants_1.constants.S_IFSOCK;
+/**
+ * Statistics about a file/directory, like `fs.Stats`.
+ */
+var Stats = /** @class */ (function () {
+    function Stats() {
+    }
+    Stats.build = function (node, bigint) {
+        if (bigint === void 0) { bigint = false; }
+        var stats = new Stats();
+        var uid = node.uid, gid = node.gid, atime = node.atime, mtime = node.mtime, ctime = node.ctime;
+        var getStatNumber = !bigint ? function (number) { return number; } : getBigInt_1.default;
+        // Copy all values on Stats from Node, so that if Node values
+        // change, values on Stats would still be the old ones,
+        // just like in Node fs.
+        stats.uid = getStatNumber(uid);
+        stats.gid = getStatNumber(gid);
+        stats.rdev = getStatNumber(0);
+        stats.blksize = getStatNumber(4096);
+        stats.ino = getStatNumber(node.ino);
+        stats.size = getStatNumber(node.getSize());
+        stats.blocks = getStatNumber(1);
+        stats.atime = atime;
+        stats.mtime = mtime;
+        stats.ctime = ctime;
+        stats.birthtime = ctime;
+        stats.atimeMs = getStatNumber(atime.getTime());
+        stats.mtimeMs = getStatNumber(mtime.getTime());
+        var ctimeMs = getStatNumber(ctime.getTime());
+        stats.ctimeMs = ctimeMs;
+        stats.birthtimeMs = ctimeMs;
+        stats.dev = getStatNumber(0);
+        stats.mode = getStatNumber(node.mode);
+        stats.nlink = getStatNumber(node.nlink);
+        return stats;
+    };
+    Stats.prototype._checkModeProperty = function (property) {
+        return (Number(this.mode) & S_IFMT) === property;
+    };
+    Stats.prototype.isDirectory = function () {
+        return this._checkModeProperty(S_IFDIR);
+    };
+    Stats.prototype.isFile = function () {
+        return this._checkModeProperty(S_IFREG);
+    };
+    Stats.prototype.isBlockDevice = function () {
+        return this._checkModeProperty(S_IFBLK);
+    };
+    Stats.prototype.isCharacterDevice = function () {
+        return this._checkModeProperty(S_IFCHR);
+    };
+    Stats.prototype.isSymbolicLink = function () {
+        return this._checkModeProperty(S_IFLNK);
+    };
+    Stats.prototype.isFIFO = function () {
+        return this._checkModeProperty(S_IFIFO);
+    };
+    Stats.prototype.isSocket = function () {
+        return this._checkModeProperty(S_IFSOCK);
+    };
+    return Stats;
+}());
+exports.Stats = Stats;
+exports.default = Stats;

app_vue/node_modules/memfs/lib/constants.d.ts

@@ -0,0 +1,62 @@
+export declare const constants: {
+    O_RDONLY: number;
+    O_WRONLY: number;
+    O_RDWR: number;
+    S_IFMT: number;
+    S_IFREG: number;
+    S_IFDIR: number;
+    S_IFCHR: number;
+    S_IFBLK: number;
+    S_IFIFO: number;
+    S_IFLNK: number;
+    S_IFSOCK: number;
+    O_CREAT: number;
+    O_EXCL: number;
+    O_NOCTTY: number;
+    O_TRUNC: number;
+    O_APPEND: number;
+    O_DIRECTORY: number;
+    O_NOATIME: number;
+    O_NOFOLLOW: number;
+    O_SYNC: number;
+    O_DIRECT: number;
+    O_NONBLOCK: number;
+    S_IRWXU: number;
+    S_IRUSR: number;
+    S_IWUSR: number;
+    S_IXUSR: number;
+    S_IRWXG: number;
+    S_IRGRP: number;
+    S_IWGRP: number;
+    S_IXGRP: number;
+    S_IRWXO: number;
+    S_IROTH: number;
+    S_IWOTH: number;
+    S_IXOTH: number;
+    F_OK: number;
+    R_OK: number;
+    W_OK: number;
+    X_OK: number;
+    UV_FS_SYMLINK_DIR: number;
+    UV_FS_SYMLINK_JUNCTION: number;
+    UV_FS_COPYFILE_EXCL: number;
+    UV_FS_COPYFILE_FICLONE: number;
+    UV_FS_COPYFILE_FICLONE_FORCE: number;
+    COPYFILE_EXCL: number;
+    COPYFILE_FICLONE: number;
+    COPYFILE_FICLONE_FORCE: number;
+};
+export declare const enum S {
+    ISUID = 2048,
+    ISGID = 1024,
+    ISVTX = 512,
+    IRUSR = 256,
+    IWUSR = 128,
+    IXUSR = 64,
+    IRGRP = 32,
+    IWGRP = 16,
+    IXGRP = 8,
+    IROTH = 4,
+    IWOTH = 2,
+    IXOTH = 1
+}

app_vue/node_modules/memfs/lib/constants.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = void 0;
+exports.constants = {
+    O_RDONLY: 0,
+    O_WRONLY: 1,
+    O_RDWR: 2,
+    S_IFMT: 61440,
+    S_IFREG: 32768,
+    S_IFDIR: 16384,
+    S_IFCHR: 8192,
+    S_IFBLK: 24576,
+    S_IFIFO: 4096,
+    S_IFLNK: 40960,
+    S_IFSOCK: 49152,
+    O_CREAT: 64,
+    O_EXCL: 128,
+    O_NOCTTY: 256,
+    O_TRUNC: 512,
+    O_APPEND: 1024,
+    O_DIRECTORY: 65536,
+    O_NOATIME: 262144,
+    O_NOFOLLOW: 131072,
+    O_SYNC: 1052672,
+    O_DIRECT: 16384,
+    O_NONBLOCK: 2048,
+    S_IRWXU: 448,
+    S_IRUSR: 256,
+    S_IWUSR: 128,
+    S_IXUSR: 64,
+    S_IRWXG: 56,
+    S_IRGRP: 32,
+    S_IWGRP: 16,
+    S_IXGRP: 8,
+    S_IRWXO: 7,
+    S_IROTH: 4,
+    S_IWOTH: 2,
+    S_IXOTH: 1,
+    F_OK: 0,
+    R_OK: 4,
+    W_OK: 2,
+    X_OK: 1,
+    UV_FS_SYMLINK_DIR: 1,
+    UV_FS_SYMLINK_JUNCTION: 2,
+    UV_FS_COPYFILE_EXCL: 1,
+    UV_FS_COPYFILE_FICLONE: 2,
+    UV_FS_COPYFILE_FICLONE_FORCE: 4,
+    COPYFILE_EXCL: 1,
+    COPYFILE_FICLONE: 2,
+    COPYFILE_FICLONE_FORCE: 4,
+};

app_vue/node_modules/memfs/lib/encoding.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export type TDataOut = string | Buffer;
+export type TEncodingExtended = BufferEncoding | 'buffer';
+export declare const ENCODING_UTF8: BufferEncoding;
+export declare function assertEncoding(encoding: string | undefined): void;
+export declare function strToEncoding(str: string, encoding?: TEncodingExtended): TDataOut;

app_vue/node_modules/memfs/lib/encoding.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strToEncoding = exports.assertEncoding = exports.ENCODING_UTF8 = void 0;
+var buffer_1 = require("./internal/buffer");
+var errors = require("./internal/errors");
+exports.ENCODING_UTF8 = 'utf8';
+function assertEncoding(encoding) {
+    if (encoding && !buffer_1.Buffer.isEncoding(encoding))
+        throw new errors.TypeError('ERR_INVALID_OPT_VALUE_ENCODING', encoding);
+}
+exports.assertEncoding = assertEncoding;
+function strToEncoding(str, encoding) {
+    if (!encoding || encoding === exports.ENCODING_UTF8)
+        return str; // UTF-8
+    if (encoding === 'buffer')
+        return new buffer_1.Buffer(str); // `buffer` encoding
+    return new buffer_1.Buffer(str).toString(encoding); // Custom encoding
+}
+exports.strToEncoding = strToEncoding;

app_vue/node_modules/memfs/lib/getBigInt.js

@@ -0,0 +1,5 @@
+if (typeof BigInt === 'function') exports.default = BigInt;
+else
+  exports.default = function BigIntNotSupported() {
+    throw new Error('BigInt is not supported in this environment.');
+  };

app_vue/node_modules/memfs/lib/index.d.ts

@@ -0,0 +1,21 @@
+import Stats from './Stats';
+import Dirent from './Dirent';
+import { Volume as _Volume, StatWatcher, FSWatcher, IReadStream, IWriteStream, DirectoryJSON } from './volume';
+import { IPromisesAPI } from './promises';
+import { constants } from './constants';
+export { DirectoryJSON };
+export declare const Volume: typeof _Volume;
+export declare const vol: _Volume;
+export interface IFs extends _Volume {
+    constants: typeof constants;
+    Stats: new (...args: any[]) => Stats;
+    Dirent: new (...args: any[]) => Dirent;
+    StatWatcher: new () => StatWatcher;
+    FSWatcher: new () => FSWatcher;
+    ReadStream: new (...args: any[]) => IReadStream;
+    WriteStream: new (...args: any[]) => IWriteStream;
+    promises: IPromisesAPI;
+    _toUnixTimestamp: any;
+}
+export declare function createFsFromVolume(vol: _Volume): IFs;
+export declare const fs: IFs;

app_vue/node_modules/memfs/lib/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fs = exports.createFsFromVolume = exports.vol = exports.Volume = void 0;
+var Stats_1 = require("./Stats");
+var Dirent_1 = require("./Dirent");
+var volume_1 = require("./volume");
+var _a = require('fs-monkey/lib/util/lists'), fsSyncMethods = _a.fsSyncMethods, fsAsyncMethods = _a.fsAsyncMethods;
+var constants_1 = require("./constants");
+var F_OK = constants_1.constants.F_OK, R_OK = constants_1.constants.R_OK, W_OK = constants_1.constants.W_OK, X_OK = constants_1.constants.X_OK;
+exports.Volume = volume_1.Volume;
+// Default volume.
+exports.vol = new volume_1.Volume();
+function createFsFromVolume(vol) {
+    var fs = { F_OK: F_OK, R_OK: R_OK, W_OK: W_OK, X_OK: X_OK, constants: constants_1.constants, Stats: Stats_1.default, Dirent: Dirent_1.default };
+    // Bind FS methods.
+    for (var _i = 0, fsSyncMethods_1 = fsSyncMethods; _i < fsSyncMethods_1.length; _i++) {
+        var method = fsSyncMethods_1[_i];
+        if (typeof vol[method] === 'function')
+            fs[method] = vol[method].bind(vol);
+    }
+    for (var _a = 0, fsAsyncMethods_1 = fsAsyncMethods; _a < fsAsyncMethods_1.length; _a++) {
+        var method = fsAsyncMethods_1[_a];
+        if (typeof vol[method] === 'function')
+            fs[method] = vol[method].bind(vol);
+    }
+    fs.StatWatcher = vol.StatWatcher;
+    fs.FSWatcher = vol.FSWatcher;
+    fs.WriteStream = vol.WriteStream;
+    fs.ReadStream = vol.ReadStream;
+    fs.promises = vol.promises;
+    fs._toUnixTimestamp = volume_1.toUnixTimestamp;
+    return fs;
+}
+exports.createFsFromVolume = createFsFromVolume;
+exports.fs = createFsFromVolume(exports.vol);
+module.exports = __assign(__assign({}, module.exports), exports.fs);
+module.exports.semantic = true;

app_vue/node_modules/memfs/lib/internal/buffer.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+declare const bufferAllocUnsafe: (size: number) => Buffer;
+declare const bufferFrom: {
+    (arrayBuffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number | undefined, length?: number | undefined): Buffer;
+    (data: readonly any[]): Buffer;
+    (data: Uint8Array): Buffer;
+    (obj: {
+        valueOf(): string | object;
+    } | {
+        [Symbol.toPrimitive](hint: "string"): string;
+    }, byteOffset?: number | undefined, length?: number | undefined): Buffer;
+    (str: string, encoding?: string | undefined): Buffer;
+};
+export { Buffer, bufferAllocUnsafe, bufferFrom };

app_vue/node_modules/memfs/lib/internal/buffer.js

@@ -0,0 +1,25 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferFrom = exports.bufferAllocUnsafe = exports.Buffer = void 0;
+var buffer_1 = require("buffer");
+Object.defineProperty(exports, "Buffer", { enumerable: true, get: function () { return buffer_1.Buffer; } });
+function bufferV0P12Ponyfill(arg0) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return new (buffer_1.Buffer.bind.apply(buffer_1.Buffer, __spreadArray([void 0, arg0], args, false)))();
+}
+var bufferAllocUnsafe = buffer_1.Buffer.allocUnsafe || bufferV0P12Ponyfill;
+exports.bufferAllocUnsafe = bufferAllocUnsafe;
+var bufferFrom = buffer_1.Buffer.from || bufferV0P12Ponyfill;
+exports.bufferFrom = bufferFrom;

app_vue/node_modules/memfs/lib/internal/errors.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+declare const g: typeof globalThis | NodeJS.Global;
+declare class AssertionError extends g.Error {
+    generatedMessage: any;
+    name: any;
+    code: any;
+    actual: any;
+    expected: any;
+    operator: any;
+    constructor(options: any);
+}
+declare function message(key: any, args: any): any;
+declare function E(sym: any, val: any): void;
+export declare const Error: {
+    new (key: any, ...args: any[]): {
+        [x: string]: any;
+    };
+    [x: string]: any;
+};
+export declare const TypeError: {
+    new (key: any, ...args: any[]): {
+        [x: string]: any;
+    };
+    [x: string]: any;
+};
+export declare const RangeError: {
+    new (key: any, ...args: any[]): {
+        [x: string]: any;
+    };
+    [x: string]: any;
+};
+export { message, AssertionError, E, };

app_vue/node_modules/memfs/lib/internal/errors.js

@@ -0,0 +1,265 @@
+"use strict";
+// The whole point behind this internal module is to allow Node.js to no
+// longer be forced to treat every error message change as a semver-major
+// change. The NodeError classes here all expose a `code` property whose
+// value statically and permanently identifies the error. While the error
+// message may change, the code should not.
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E = exports.AssertionError = exports.message = exports.RangeError = exports.TypeError = exports.Error = void 0;
+var assert = require("assert");
+var util = require("util");
+var kCode = typeof Symbol === 'undefined' ? '_kCode' : Symbol('code');
+var messages = {}; // new Map();
+function makeNodeError(Base) {
+    return /** @class */ (function (_super) {
+        __extends(NodeError, _super);
+        function NodeError(key) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            var _this = _super.call(this, message(key, args)) || this;
+            _this.code = key;
+            _this[kCode] = key;
+            _this.name = "".concat(_super.prototype.name, " [").concat(_this[kCode], "]");
+            return _this;
+        }
+        return NodeError;
+    }(Base));
+}
+var g = typeof globalThis !== 'undefined' ? globalThis : global;
+var AssertionError = /** @class */ (function (_super) {
+    __extends(AssertionError, _super);
+    function AssertionError(options) {
+        var _this = this;
+        if (typeof options !== 'object' || options === null) {
+            throw new exports.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'object');
+        }
+        if (options.message) {
+            _this = _super.call(this, options.message) || this;
+        }
+        else {
+            _this = _super.call(this, "".concat(util.inspect(options.actual).slice(0, 128), " ") +
+                "".concat(options.operator, " ").concat(util.inspect(options.expected).slice(0, 128))) || this;
+        }
+        _this.generatedMessage = !options.message;
+        _this.name = 'AssertionError [ERR_ASSERTION]';
+        _this.code = 'ERR_ASSERTION';
+        _this.actual = options.actual;
+        _this.expected = options.expected;
+        _this.operator = options.operator;
+        exports.Error.captureStackTrace(_this, options.stackStartFunction);
+        return _this;
+    }
+    return AssertionError;
+}(g.Error));
+exports.AssertionError = AssertionError;
+function message(key, args) {
+    assert.strictEqual(typeof key, 'string');
+    // const msg = messages.get(key);
+    var msg = messages[key];
+    assert(msg, "An invalid error message key was used: ".concat(key, "."));
+    var fmt;
+    if (typeof msg === 'function') {
+        fmt = msg;
+    }
+    else {
+        fmt = util.format;
+        if (args === undefined || args.length === 0)
+            return msg;
+        args.unshift(msg);
+    }
+    return String(fmt.apply(null, args));
+}
+exports.message = message;
+// Utility function for registering the error codes. Only used here. Exported
+// *only* to allow for testing.
+function E(sym, val) {
+    messages[sym] = typeof val === 'function' ? val : String(val);
+}
+exports.E = E;
+exports.Error = makeNodeError(g.Error);
+exports.TypeError = makeNodeError(g.TypeError);
+exports.RangeError = makeNodeError(g.RangeError);
+// To declare an error message, use the E(sym, val) function above. The sym
+// must be an upper case string. The val can be either a function or a string.
+// The return value of the function must be a string.
+// Examples:
+// E('EXAMPLE_KEY1', 'This is the error value');
+// E('EXAMPLE_KEY2', (a, b) => return `${a} ${b}`);
+//
+// Once an error code has been assigned, the code itself MUST NOT change and
+// any given error code must never be reused to identify a different error.
+//
+// Any error code added here should also be added to the documentation
+//
+// Note: Please try to keep these in alphabetical order
+E('ERR_ARG_NOT_ITERABLE', '%s must be iterable');
+E('ERR_ASSERTION', '%s');
+E('ERR_BUFFER_OUT_OF_BOUNDS', bufferOutOfBounds);
+E('ERR_CHILD_CLOSED_BEFORE_REPLY', 'Child closed before reply received');
+E('ERR_CONSOLE_WRITABLE_STREAM', 'Console expects a writable stream instance for %s');
+E('ERR_CPU_USAGE', 'Unable to obtain cpu usage %s');
+E('ERR_DNS_SET_SERVERS_FAILED', function (err, servers) { return "c-ares failed to set servers: \"".concat(err, "\" [").concat(servers, "]"); });
+E('ERR_FALSY_VALUE_REJECTION', 'Promise was rejected with falsy value');
+E('ERR_ENCODING_NOT_SUPPORTED', function (enc) { return "The \"".concat(enc, "\" encoding is not supported"); });
+E('ERR_ENCODING_INVALID_ENCODED_DATA', function (enc) { return "The encoded data was not valid for encoding ".concat(enc); });
+E('ERR_HTTP_HEADERS_SENT', 'Cannot render headers after they are sent to the client');
+E('ERR_HTTP_INVALID_STATUS_CODE', 'Invalid status code: %s');
+E('ERR_HTTP_TRAILER_INVALID', 'Trailers are invalid with this transfer encoding');
+E('ERR_INDEX_OUT_OF_RANGE', 'Index out of range');
+E('ERR_INVALID_ARG_TYPE', invalidArgType);
+E('ERR_INVALID_ARRAY_LENGTH', function (name, len, actual) {
+    assert.strictEqual(typeof actual, 'number');
+    return "The array \"".concat(name, "\" (length ").concat(actual, ") must be of length ").concat(len, ".");
+});
+E('ERR_INVALID_BUFFER_SIZE', 'Buffer size must be a multiple of %s');
+E('ERR_INVALID_CALLBACK', 'Callback must be a function');
+E('ERR_INVALID_CHAR', 'Invalid character in %s');
+E('ERR_INVALID_CURSOR_POS', 'Cannot set cursor row without setting its column');
+E('ERR_INVALID_FD', '"fd" must be a positive integer: %s');
+E('ERR_INVALID_FILE_URL_HOST', 'File URL host must be "localhost" or empty on %s');
+E('ERR_INVALID_FILE_URL_PATH', 'File URL path %s');
+E('ERR_INVALID_HANDLE_TYPE', 'This handle type cannot be sent');
+E('ERR_INVALID_IP_ADDRESS', 'Invalid IP address: %s');
+E('ERR_INVALID_OPT_VALUE', function (name, value) {
+    return "The value \"".concat(String(value), "\" is invalid for option \"").concat(name, "\"");
+});
+E('ERR_INVALID_OPT_VALUE_ENCODING', function (value) { return "The value \"".concat(String(value), "\" is invalid for option \"encoding\""); });
+E('ERR_INVALID_REPL_EVAL_CONFIG', 'Cannot specify both "breakEvalOnSigint" and "eval" for REPL');
+E('ERR_INVALID_SYNC_FORK_INPUT', 'Asynchronous forks do not support Buffer, Uint8Array or string input: %s');
+E('ERR_INVALID_THIS', 'Value of "this" must be of type %s');
+E('ERR_INVALID_TUPLE', '%s must be an iterable %s tuple');
+E('ERR_INVALID_URL', 'Invalid URL: %s');
+E('ERR_INVALID_URL_SCHEME', function (expected) { return "The URL must be ".concat(oneOf(expected, 'scheme')); });
+E('ERR_IPC_CHANNEL_CLOSED', 'Channel closed');
+E('ERR_IPC_DISCONNECTED', 'IPC channel is already disconnected');
+E('ERR_IPC_ONE_PIPE', 'Child process can have only one IPC pipe');
+E('ERR_IPC_SYNC_FORK', 'IPC cannot be used with synchronous forks');
+E('ERR_MISSING_ARGS', missingArgs);
+E('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
+E('ERR_NAPI_CONS_FUNCTION', 'Constructor must be a function');
+E('ERR_NAPI_CONS_PROTOTYPE_OBJECT', 'Constructor.prototype must be an object');
+E('ERR_NO_CRYPTO', 'Node.js is not compiled with OpenSSL crypto support');
+E('ERR_NO_LONGER_SUPPORTED', '%s is no longer supported');
+E('ERR_PARSE_HISTORY_DATA', 'Could not parse history data in %s');
+E('ERR_SOCKET_ALREADY_BOUND', 'Socket is already bound');
+E('ERR_SOCKET_BAD_PORT', 'Port should be > 0 and < 65536');
+E('ERR_SOCKET_BAD_TYPE', 'Bad socket type specified. Valid types are: udp4, udp6');
+E('ERR_SOCKET_CANNOT_SEND', 'Unable to send data');
+E('ERR_SOCKET_CLOSED', 'Socket is closed');
+E('ERR_SOCKET_DGRAM_NOT_RUNNING', 'Not running');
+E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed');
+E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed');
+E('ERR_STREAM_WRAP', 'Stream has StringDecoder set or is in objectMode');
+E('ERR_TLS_CERT_ALTNAME_INVALID', "Hostname/IP does not match certificate's altnames: %s");
+E('ERR_TLS_DH_PARAM_SIZE', function (size) { return "DH parameter size ".concat(size, " is less than 2048"); });
+E('ERR_TLS_HANDSHAKE_TIMEOUT', 'TLS handshake timeout');
+E('ERR_TLS_RENEGOTIATION_FAILED', 'Failed to renegotiate');
+E('ERR_TLS_REQUIRED_SERVER_NAME', '"servername" is required parameter for Server.addContext');
+E('ERR_TLS_SESSION_ATTACK', 'TSL session renegotiation attack detected');
+E('ERR_TRANSFORM_ALREADY_TRANSFORMING', 'Calling transform done when still transforming');
+E('ERR_TRANSFORM_WITH_LENGTH_0', 'Calling transform done when writableState.length != 0');
+E('ERR_UNKNOWN_ENCODING', 'Unknown encoding: %s');
+E('ERR_UNKNOWN_SIGNAL', 'Unknown signal: %s');
+E('ERR_UNKNOWN_STDIN_TYPE', 'Unknown stdin file type');
+E('ERR_UNKNOWN_STREAM_TYPE', 'Unknown stream file type');
+E('ERR_V8BREAKITERATOR', 'Full ICU data not installed. ' + 'See https://github.com/nodejs/node/wiki/Intl');
+function invalidArgType(name, expected, actual) {
+    assert(name, 'name is required');
+    // determiner: 'must be' or 'must not be'
+    var determiner;
+    if (expected.includes('not ')) {
+        determiner = 'must not be';
+        expected = expected.split('not ')[1];
+    }
+    else {
+        determiner = 'must be';
+    }
+    var msg;
+    if (Array.isArray(name)) {
+        var names = name.map(function (val) { return "\"".concat(val, "\""); }).join(', ');
+        msg = "The ".concat(names, " arguments ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+    }
+    else if (name.includes(' argument')) {
+        // for the case like 'first argument'
+        msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+    }
+    else {
+        var type = name.includes('.') ? 'property' : 'argument';
+        msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+    }
+    // if actual value received, output it
+    if (arguments.length >= 3) {
+        msg += ". Received type ".concat(actual !== null ? typeof actual : 'null');
+    }
+    return msg;
+}
+function missingArgs() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    assert(args.length > 0, 'At least one arg needs to be specified');
+    var msg = 'The ';
+    var len = args.length;
+    args = args.map(function (a) { return "\"".concat(a, "\""); });
+    switch (len) {
+        case 1:
+            msg += "".concat(args[0], " argument");
+            break;
+        case 2:
+            msg += "".concat(args[0], " and ").concat(args[1], " arguments");
+            break;
+        default:
+            msg += args.slice(0, len - 1).join(', ');
+            msg += ", and ".concat(args[len - 1], " arguments");
+            break;
+    }
+    return "".concat(msg, " must be specified");
+}
+function oneOf(expected, thing) {
+    assert(expected, 'expected is required');
+    assert(typeof thing === 'string', 'thing is required');
+    if (Array.isArray(expected)) {
+        var len = expected.length;
+        assert(len > 0, 'At least one expected value needs to be specified');
+        // tslint:disable-next-line
+        expected = expected.map(function (i) { return String(i); });
+        if (len > 2) {
+            return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
+        }
+        else if (len === 2) {
+            return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+        }
+        else {
+            return "of ".concat(thing, " ").concat(expected[0]);
+        }
+    }
+    else {
+        return "of ".concat(thing, " ").concat(String(expected));
+    }
+}
+function bufferOutOfBounds(name, isWriting) {
+    if (isWriting) {
+        return 'Attempt to write outside buffer bounds';
+    }
+    else {
+        return "\"".concat(name, "\" is outside of buffer bounds");
+    }
+}

app_vue/node_modules/memfs/lib/node.d.ts

@@ -0,0 +1,156 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Volume } from './volume';
+import { EventEmitter } from 'events';
+import Stats from './Stats';
+export declare const SEP = "/";
+/**
+ * Node in a file system (like i-node, v-node).
+ */
+export declare class Node extends EventEmitter {
+    ino: number;
+    private _uid;
+    private _gid;
+    private _atime;
+    private _mtime;
+    private _ctime;
+    buf: Buffer;
+    private _perm;
+    mode: number;
+    private _nlink;
+    symlink: string[];
+    constructor(ino: number, perm?: number);
+    set ctime(ctime: Date);
+    get ctime(): Date;
+    set uid(uid: number);
+    get uid(): number;
+    set gid(gid: number);
+    get gid(): number;
+    set atime(atime: Date);
+    get atime(): Date;
+    set mtime(mtime: Date);
+    get mtime(): Date;
+    set perm(perm: number);
+    get perm(): number;
+    set nlink(nlink: number);
+    get nlink(): number;
+    getString(encoding?: string): string;
+    setString(str: string): void;
+    getBuffer(): Buffer;
+    setBuffer(buf: Buffer): void;
+    getSize(): number;
+    setModeProperty(property: number): void;
+    setIsFile(): void;
+    setIsDirectory(): void;
+    setIsSymlink(): void;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymlink(): boolean;
+    makeSymlink(steps: string[]): void;
+    write(buf: Buffer, off?: number, len?: number, pos?: number): number;
+    read(buf: Buffer | Uint8Array, off?: number, len?: number, pos?: number): number;
+    truncate(len?: number): void;
+    chmod(perm: number): void;
+    chown(uid: number, gid: number): void;
+    touch(): void;
+    canRead(uid?: number, gid?: number): boolean;
+    canWrite(uid?: number, gid?: number): boolean;
+    del(): void;
+    toJSON(): {
+        ino: number;
+        uid: number;
+        gid: number;
+        atime: number;
+        mtime: number;
+        ctime: number;
+        perm: number;
+        mode: number;
+        nlink: number;
+        symlink: string[];
+        data: string;
+    };
+}
+/**
+ * Represents a hard link that points to an i-node `node`.
+ */
+export declare class Link extends EventEmitter {
+    vol: Volume;
+    parent: Link;
+    children: {
+        [child: string]: Link | undefined;
+    };
+    private _steps;
+    node: Node;
+    ino: number;
+    length: number;
+    name: string;
+    get steps(): string[];
+    set steps(val: string[]);
+    constructor(vol: Volume, parent: Link, name: string);
+    setNode(node: Node): void;
+    getNode(): Node;
+    createChild(name: string, node?: Node): Link;
+    setChild(name: string, link?: Link): Link;
+    deleteChild(link: Link): void;
+    getChild(name: string): Link | undefined;
+    getPath(): string;
+    getName(): string;
+    /**
+     * Walk the tree path and return the `Link` at that location, if any.
+     * @param steps {string[]} Desired location.
+     * @param stop {number} Max steps to go into.
+     * @param i {number} Current step in the `steps` array.
+     *
+     * @return {Link|null}
+     */
+    walk(steps: string[], stop?: number, i?: number): Link | null;
+    toJSON(): {
+        steps: string[];
+        ino: number;
+        children: string[];
+    };
+    syncSteps(): void;
+}
+/**
+ * Represents an open file (file descriptor) that points to a `Link` (Hard-link) and a `Node`.
+ */
+export declare class File {
+    fd: number;
+    /**
+     * Hard link that this file opened.
+     * @type {any}
+     */
+    link: Link;
+    /**
+     * Reference to a `Node`.
+     * @type {Node}
+     */
+    node: Node;
+    /**
+     * A cursor/offset position in a file, where data will be written on write.
+     * User can "seek" this position.
+     */
+    position: number;
+    flags: number;
+    /**
+     * Open a Link-Node pair. `node` is provided separately as that might be a different node
+     * rather the one `link` points to, because it might be a symlink.
+     * @param link
+     * @param node
+     * @param flags
+     * @param fd
+     */
+    constructor(link: Link, node: Node, flags: number, fd: number);
+    getString(encoding?: string): string;
+    setString(str: string): void;
+    getBuffer(): Buffer;
+    setBuffer(buf: Buffer): void;
+    getSize(): number;
+    truncate(len?: number): void;
+    seekTo(position: number): void;
+    stats(): Stats<number>;
+    write(buf: Buffer, offset?: number, length?: number, position?: number): number;
+    read(buf: Buffer | Uint8Array, offset?: number, length?: number, position?: number): number;
+    chmod(perm: number): void;
+    chown(uid: number, gid: number): void;
+}

app_vue/node_modules/memfs/lib/node.js

@@ -0,0 +1,510 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = exports.Link = exports.Node = exports.SEP = void 0;
+var process_1 = require("./process");
+var buffer_1 = require("./internal/buffer");
+var constants_1 = require("./constants");
+var events_1 = require("events");
+var Stats_1 = require("./Stats");
+var S_IFMT = constants_1.constants.S_IFMT, S_IFDIR = constants_1.constants.S_IFDIR, S_IFREG = constants_1.constants.S_IFREG, S_IFLNK = constants_1.constants.S_IFLNK, O_APPEND = constants_1.constants.O_APPEND;
+var getuid = function () { var _a, _b; return (_b = (_a = process_1.default.getuid) === null || _a === void 0 ? void 0 : _a.call(process_1.default)) !== null && _b !== void 0 ? _b : 0; };
+var getgid = function () { var _a, _b; return (_b = (_a = process_1.default.getgid) === null || _a === void 0 ? void 0 : _a.call(process_1.default)) !== null && _b !== void 0 ? _b : 0; };
+exports.SEP = '/';
+/**
+ * Node in a file system (like i-node, v-node).
+ */
+var Node = /** @class */ (function (_super) {
+    __extends(Node, _super);
+    function Node(ino, perm) {
+        if (perm === void 0) { perm = 438; }
+        var _this = _super.call(this) || this;
+        // User ID and group ID.
+        _this._uid = getuid();
+        _this._gid = getgid();
+        _this._atime = new Date();
+        _this._mtime = new Date();
+        _this._ctime = new Date();
+        _this._perm = 438; // Permissions `chmod`, `fchmod`
+        _this.mode = S_IFREG; // S_IFDIR, S_IFREG, etc.. (file by default?)
+        // Number of hard links pointing at this Node.
+        _this._nlink = 1;
+        _this._perm = perm;
+        _this.mode |= perm;
+        _this.ino = ino;
+        return _this;
+    }
+    Object.defineProperty(Node.prototype, "ctime", {
+        get: function () {
+            return this._ctime;
+        },
+        set: function (ctime) {
+            this._ctime = ctime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "uid", {
+        get: function () {
+            return this._uid;
+        },
+        set: function (uid) {
+            this._uid = uid;
+            this.ctime = new Date();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "gid", {
+        get: function () {
+            return this._gid;
+        },
+        set: function (gid) {
+            this._gid = gid;
+            this.ctime = new Date();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "atime", {
+        get: function () {
+            return this._atime;
+        },
+        set: function (atime) {
+            this._atime = atime;
+            this.ctime = new Date();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "mtime", {
+        get: function () {
+            return this._mtime;
+        },
+        set: function (mtime) {
+            this._mtime = mtime;
+            this.ctime = new Date();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "perm", {
+        get: function () {
+            return this._perm;
+        },
+        set: function (perm) {
+            this._perm = perm;
+            this.ctime = new Date();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "nlink", {
+        get: function () {
+            return this._nlink;
+        },
+        set: function (nlink) {
+            this._nlink = nlink;
+            this.ctime = new Date();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Node.prototype.getString = function (encoding) {
+        if (encoding === void 0) { encoding = 'utf8'; }
+        this.atime = new Date();
+        return this.getBuffer().toString(encoding);
+    };
+    Node.prototype.setString = function (str) {
+        // this.setBuffer(bufferFrom(str, 'utf8'));
+        this.buf = (0, buffer_1.bufferFrom)(str, 'utf8');
+        this.touch();
+    };
+    Node.prototype.getBuffer = function () {
+        this.atime = new Date();
+        if (!this.buf)
+            this.setBuffer((0, buffer_1.bufferAllocUnsafe)(0));
+        return (0, buffer_1.bufferFrom)(this.buf); // Return a copy.
+    };
+    Node.prototype.setBuffer = function (buf) {
+        this.buf = (0, buffer_1.bufferFrom)(buf); // Creates a copy of data.
+        this.touch();
+    };
+    Node.prototype.getSize = function () {
+        return this.buf ? this.buf.length : 0;
+    };
+    Node.prototype.setModeProperty = function (property) {
+        this.mode = (this.mode & ~S_IFMT) | property;
+    };
+    Node.prototype.setIsFile = function () {
+        this.setModeProperty(S_IFREG);
+    };
+    Node.prototype.setIsDirectory = function () {
+        this.setModeProperty(S_IFDIR);
+    };
+    Node.prototype.setIsSymlink = function () {
+        this.setModeProperty(S_IFLNK);
+    };
+    Node.prototype.isFile = function () {
+        return (this.mode & S_IFMT) === S_IFREG;
+    };
+    Node.prototype.isDirectory = function () {
+        return (this.mode & S_IFMT) === S_IFDIR;
+    };
+    Node.prototype.isSymlink = function () {
+        // return !!this.symlink;
+        return (this.mode & S_IFMT) === S_IFLNK;
+    };
+    Node.prototype.makeSymlink = function (steps) {
+        this.symlink = steps;
+        this.setIsSymlink();
+    };
+    Node.prototype.write = function (buf, off, len, pos) {
+        if (off === void 0) { off = 0; }
+        if (len === void 0) { len = buf.length; }
+        if (pos === void 0) { pos = 0; }
+        if (!this.buf)
+            this.buf = (0, buffer_1.bufferAllocUnsafe)(0);
+        if (pos + len > this.buf.length) {
+            var newBuf = (0, buffer_1.bufferAllocUnsafe)(pos + len);
+            this.buf.copy(newBuf, 0, 0, this.buf.length);
+            this.buf = newBuf;
+        }
+        buf.copy(this.buf, pos, off, off + len);
+        this.touch();
+        return len;
+    };
+    // Returns the number of bytes read.
+    Node.prototype.read = function (buf, off, len, pos) {
+        if (off === void 0) { off = 0; }
+        if (len === void 0) { len = buf.byteLength; }
+        if (pos === void 0) { pos = 0; }
+        this.atime = new Date();
+        if (!this.buf)
+            this.buf = (0, buffer_1.bufferAllocUnsafe)(0);
+        var actualLen = len;
+        if (actualLen > buf.byteLength) {
+            actualLen = buf.byteLength;
+        }
+        if (actualLen + pos > this.buf.length) {
+            actualLen = this.buf.length - pos;
+        }
+        this.buf.copy(buf, off, pos, pos + actualLen);
+        return actualLen;
+    };
+    Node.prototype.truncate = function (len) {
+        if (len === void 0) { len = 0; }
+        if (!len)
+            this.buf = (0, buffer_1.bufferAllocUnsafe)(0);
+        else {
+            if (!this.buf)
+                this.buf = (0, buffer_1.bufferAllocUnsafe)(0);
+            if (len <= this.buf.length) {
+                this.buf = this.buf.slice(0, len);
+            }
+            else {
+                var buf = (0, buffer_1.bufferAllocUnsafe)(len);
+                this.buf.copy(buf);
+                buf.fill(0, this.buf.length);
+                this.buf = buf;
+            }
+        }
+        this.touch();
+    };
+    Node.prototype.chmod = function (perm) {
+        this.perm = perm;
+        this.mode = (this.mode & ~511) | perm;
+        this.touch();
+    };
+    Node.prototype.chown = function (uid, gid) {
+        this.uid = uid;
+        this.gid = gid;
+        this.touch();
+    };
+    Node.prototype.touch = function () {
+        this.mtime = new Date();
+        this.emit('change', this);
+    };
+    Node.prototype.canRead = function (uid, gid) {
+        if (uid === void 0) { uid = getuid(); }
+        if (gid === void 0) { gid = getgid(); }
+        if (this.perm & 4 /* S.IROTH */) {
+            return true;
+        }
+        if (gid === this.gid) {
+            if (this.perm & 32 /* S.IRGRP */) {
+                return true;
+            }
+        }
+        if (uid === this.uid) {
+            if (this.perm & 256 /* S.IRUSR */) {
+                return true;
+            }
+        }
+        return false;
+    };
+    Node.prototype.canWrite = function (uid, gid) {
+        if (uid === void 0) { uid = getuid(); }
+        if (gid === void 0) { gid = getgid(); }
+        if (this.perm & 2 /* S.IWOTH */) {
+            return true;
+        }
+        if (gid === this.gid) {
+            if (this.perm & 16 /* S.IWGRP */) {
+                return true;
+            }
+        }
+        if (uid === this.uid) {
+            if (this.perm & 128 /* S.IWUSR */) {
+                return true;
+            }
+        }
+        return false;
+    };
+    Node.prototype.del = function () {
+        this.emit('delete', this);
+    };
+    Node.prototype.toJSON = function () {
+        return {
+            ino: this.ino,
+            uid: this.uid,
+            gid: this.gid,
+            atime: this.atime.getTime(),
+            mtime: this.mtime.getTime(),
+            ctime: this.ctime.getTime(),
+            perm: this.perm,
+            mode: this.mode,
+            nlink: this.nlink,
+            symlink: this.symlink,
+            data: this.getString(),
+        };
+    };
+    return Node;
+}(events_1.EventEmitter));
+exports.Node = Node;
+/**
+ * Represents a hard link that points to an i-node `node`.
+ */
+var Link = /** @class */ (function (_super) {
+    __extends(Link, _super);
+    function Link(vol, parent, name) {
+        var _this = _super.call(this) || this;
+        _this.children = {};
+        // Path to this node as Array: ['usr', 'bin', 'node'].
+        _this._steps = [];
+        // "i-node" number of the node.
+        _this.ino = 0;
+        // Number of children.
+        _this.length = 0;
+        _this.vol = vol;
+        _this.parent = parent;
+        _this.name = name;
+        _this.syncSteps();
+        return _this;
+    }
+    Object.defineProperty(Link.prototype, "steps", {
+        get: function () {
+            return this._steps;
+        },
+        // Recursively sync children steps, e.g. in case of dir rename
+        set: function (val) {
+            this._steps = val;
+            for (var _i = 0, _a = Object.entries(this.children); _i < _a.length; _i++) {
+                var _b = _a[_i], child = _b[0], link = _b[1];
+                if (child === '.' || child === '..') {
+                    continue;
+                }
+                link === null || link === void 0 ? void 0 : link.syncSteps();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Link.prototype.setNode = function (node) {
+        this.node = node;
+        this.ino = node.ino;
+    };
+    Link.prototype.getNode = function () {
+        return this.node;
+    };
+    Link.prototype.createChild = function (name, node) {
+        if (node === void 0) { node = this.vol.createNode(); }
+        var link = new Link(this.vol, this, name);
+        link.setNode(node);
+        if (node.isDirectory()) {
+            link.children['.'] = link;
+            link.getNode().nlink++;
+        }
+        this.setChild(name, link);
+        return link;
+    };
+    Link.prototype.setChild = function (name, link) {
+        if (link === void 0) { link = new Link(this.vol, this, name); }
+        this.children[name] = link;
+        link.parent = this;
+        this.length++;
+        var node = link.getNode();
+        if (node.isDirectory()) {
+            link.children['..'] = this;
+            this.getNode().nlink++;
+        }
+        this.getNode().mtime = new Date();
+        this.emit('child:add', link, this);
+        return link;
+    };
+    Link.prototype.deleteChild = function (link) {
+        var node = link.getNode();
+        if (node.isDirectory()) {
+            delete link.children['..'];
+            this.getNode().nlink--;
+        }
+        delete this.children[link.getName()];
+        this.length--;
+        this.getNode().mtime = new Date();
+        this.emit('child:delete', link, this);
+    };
+    Link.prototype.getChild = function (name) {
+        this.getNode().mtime = new Date();
+        if (Object.hasOwnProperty.call(this.children, name)) {
+            return this.children[name];
+        }
+    };
+    Link.prototype.getPath = function () {
+        return this.steps.join(exports.SEP);
+    };
+    Link.prototype.getName = function () {
+        return this.steps[this.steps.length - 1];
+    };
+    // del() {
+    //     const parent = this.parent;
+    //     if(parent) {
+    //         parent.deleteChild(link);
+    //     }
+    //     this.parent = null;
+    //     this.vol = null;
+    // }
+    /**
+     * Walk the tree path and return the `Link` at that location, if any.
+     * @param steps {string[]} Desired location.
+     * @param stop {number} Max steps to go into.
+     * @param i {number} Current step in the `steps` array.
+     *
+     * @return {Link|null}
+     */
+    Link.prototype.walk = function (steps, stop, i) {
+        if (stop === void 0) { stop = steps.length; }
+        if (i === void 0) { i = 0; }
+        if (i >= steps.length)
+            return this;
+        if (i >= stop)
+            return this;
+        var step = steps[i];
+        var link = this.getChild(step);
+        if (!link)
+            return null;
+        return link.walk(steps, stop, i + 1);
+    };
+    Link.prototype.toJSON = function () {
+        return {
+            steps: this.steps,
+            ino: this.ino,
+            children: Object.keys(this.children),
+        };
+    };
+    Link.prototype.syncSteps = function () {
+        this.steps = this.parent ? this.parent.steps.concat([this.name]) : [this.name];
+    };
+    return Link;
+}(events_1.EventEmitter));
+exports.Link = Link;
+/**
+ * Represents an open file (file descriptor) that points to a `Link` (Hard-link) and a `Node`.
+ */
+var File = /** @class */ (function () {
+    /**
+     * Open a Link-Node pair. `node` is provided separately as that might be a different node
+     * rather the one `link` points to, because it might be a symlink.
+     * @param link
+     * @param node
+     * @param flags
+     * @param fd
+     */
+    function File(link, node, flags, fd) {
+        /**
+         * A cursor/offset position in a file, where data will be written on write.
+         * User can "seek" this position.
+         */
+        this.position = 0;
+        this.link = link;
+        this.node = node;
+        this.flags = flags;
+        this.fd = fd;
+    }
+    File.prototype.getString = function (encoding) {
+        if (encoding === void 0) { encoding = 'utf8'; }
+        return this.node.getString();
+    };
+    File.prototype.setString = function (str) {
+        this.node.setString(str);
+    };
+    File.prototype.getBuffer = function () {
+        return this.node.getBuffer();
+    };
+    File.prototype.setBuffer = function (buf) {
+        this.node.setBuffer(buf);
+    };
+    File.prototype.getSize = function () {
+        return this.node.getSize();
+    };
+    File.prototype.truncate = function (len) {
+        this.node.truncate(len);
+    };
+    File.prototype.seekTo = function (position) {
+        this.position = position;
+    };
+    File.prototype.stats = function () {
+        return Stats_1.default.build(this.node);
+    };
+    File.prototype.write = function (buf, offset, length, position) {
+        if (offset === void 0) { offset = 0; }
+        if (length === void 0) { length = buf.length; }
+        if (typeof position !== 'number')
+            position = this.position;
+        if (this.flags & O_APPEND)
+            position = this.getSize();
+        var bytes = this.node.write(buf, offset, length, position);
+        this.position = position + bytes;
+        return bytes;
+    };
+    File.prototype.read = function (buf, offset, length, position) {
+        if (offset === void 0) { offset = 0; }
+        if (length === void 0) { length = buf.byteLength; }
+        if (typeof position !== 'number')
+            position = this.position;
+        var bytes = this.node.read(buf, offset, length, position);
+        this.position = position + bytes;
+        return bytes;
+    };
+    File.prototype.chmod = function (perm) {
+        this.node.chmod(perm);
+    };
+    File.prototype.chown = function (uid, gid) {
+        this.node.chown(uid, gid);
+    };
+    return File;
+}());
+exports.File = File;

app_vue/node_modules/memfs/lib/process.d.ts

@@ -0,0 +1,12 @@
+export interface IProcess {
+    getuid?(): number;
+    getgid?(): number;
+    cwd(): string;
+    platform: string;
+    nextTick: (callback: (...args: any[]) => void, ...args: any[]) => void;
+    emitWarning: (message: string, type: string) => void;
+    env: {};
+}
+export declare function createProcess(): IProcess;
+declare const _default: IProcess;
+export default _default;

app_vue/node_modules/memfs/lib/process.js

@@ -0,0 +1,42 @@
+"use strict";
+// Here we mock the global `process` variable in case we are not in Node's environment.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProcess = void 0;
+/**
+ * Looks to return a `process` object, if one is available.
+ *
+ * The global `process` is returned if defined;
+ * otherwise `require('process')` is attempted.
+ *
+ * If that fails, `undefined` is returned.
+ *
+ * @return {IProcess | undefined}
+ */
+var maybeReturnProcess = function () {
+    if (typeof process !== 'undefined') {
+        return process;
+    }
+    try {
+        return require('process');
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+function createProcess() {
+    var p = maybeReturnProcess() || {};
+    if (!p.cwd)
+        p.cwd = function () { return '/'; };
+    if (!p.nextTick)
+        p.nextTick = require('./setImmediate').default;
+    if (!p.emitWarning)
+        p.emitWarning = function (message, type) {
+            // tslint:disable-next-line:no-console
+            console.warn("".concat(type).concat(type ? ': ' : '').concat(message));
+        };
+    if (!p.env)
+        p.env = {};
+    return p;
+}
+exports.createProcess = createProcess;
+exports.default = createProcess();

app_vue/node_modules/memfs/lib/promises.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Volume, TData, TMode, TFlags, TFlagsCopy, TTime, IOptions, IAppendFileOptions, IMkdirOptions, IReaddirOptions, IReadFileOptions, IRealpathOptions, IWriteFileOptions, IStatOptions, IRmOptions, IFStatOptions } from './volume';
+import Stats from './Stats';
+import Dirent from './Dirent';
+import { TDataOut } from './encoding';
+import { PathLike, symlink } from 'fs';
+export interface TFileHandleReadResult {
+    bytesRead: number;
+    buffer: Buffer | Uint8Array;
+}
+export interface TFileHandleWriteResult {
+    bytesWritten: number;
+    buffer: Buffer | Uint8Array;
+}
+export interface IFileHandle {
+    fd: number;
+    appendFile(data: TData, options?: IAppendFileOptions | string): Promise<void>;
+    chmod(mode: TMode): Promise<void>;
+    chown(uid: number, gid: number): Promise<void>;
+    close(): Promise<void>;
+    datasync(): Promise<void>;
+    read(buffer: Buffer | Uint8Array, offset: number, length: number, position: number): Promise<TFileHandleReadResult>;
+    readFile(options?: IReadFileOptions | string): Promise<TDataOut>;
+    stat(options?: IStatOptions): Promise<Stats>;
+    truncate(len?: number): Promise<void>;
+    utimes(atime: TTime, mtime: TTime): Promise<void>;
+    write(buffer: Buffer | Uint8Array, offset?: number, length?: number, position?: number): Promise<TFileHandleWriteResult>;
+    writeFile(data: TData, options?: IWriteFileOptions): Promise<void>;
+}
+export type TFileHandle = PathLike | IFileHandle;
+export interface IPromisesAPI {
+    FileHandle: any;
+    access(path: PathLike, mode?: number): Promise<void>;
+    appendFile(path: TFileHandle, data: TData, options?: IAppendFileOptions | string): Promise<void>;
+    chmod(path: PathLike, mode: TMode): Promise<void>;
+    chown(path: PathLike, uid: number, gid: number): Promise<void>;
+    copyFile(src: PathLike, dest: PathLike, flags?: TFlagsCopy): Promise<void>;
+    lchmod(path: PathLike, mode: TMode): Promise<void>;
+    lchown(path: PathLike, uid: number, gid: number): Promise<void>;
+    link(existingPath: PathLike, newPath: PathLike): Promise<void>;
+    lstat(path: PathLike, options?: IStatOptions): Promise<Stats>;
+    mkdir(path: PathLike, options?: TMode | IMkdirOptions): Promise<void>;
+    mkdtemp(prefix: string, options?: IOptions): Promise<TDataOut>;
+    open(path: PathLike, flags: TFlags, mode?: TMode): Promise<FileHandle>;
+    readdir(path: PathLike, options?: IReaddirOptions | string): Promise<TDataOut[] | Dirent[]>;
+    readFile(id: TFileHandle, options?: IReadFileOptions | string): Promise<TDataOut>;
+    readlink(path: PathLike, options?: IOptions): Promise<TDataOut>;
+    realpath(path: PathLike, options?: IRealpathOptions | string): Promise<TDataOut>;
+    rename(oldPath: PathLike, newPath: PathLike): Promise<void>;
+    rmdir(path: PathLike): Promise<void>;
+    rm(path: PathLike, options?: IRmOptions): Promise<void>;
+    stat(path: PathLike, options?: IStatOptions): Promise<Stats>;
+    symlink(target: PathLike, path: PathLike, type?: symlink.Type): Promise<void>;
+    truncate(path: PathLike, len?: number): Promise<void>;
+    unlink(path: PathLike): Promise<void>;
+    utimes(path: PathLike, atime: TTime, mtime: TTime): Promise<void>;
+    writeFile(id: TFileHandle, data: TData, options?: IWriteFileOptions): Promise<void>;
+}
+export declare class FileHandle implements IFileHandle {
+    private vol;
+    fd: number;
+    constructor(vol: Volume, fd: number);
+    appendFile(data: TData, options?: IAppendFileOptions | string): Promise<void>;
+    chmod(mode: TMode): Promise<void>;
+    chown(uid: number, gid: number): Promise<void>;
+    close(): Promise<void>;
+    datasync(): Promise<void>;
+    read(buffer: Buffer | Uint8Array, offset: number, length: number, position: number): Promise<TFileHandleReadResult>;
+    readFile(options?: IReadFileOptions | string): Promise<TDataOut>;
+    stat(options?: IFStatOptions): Promise<Stats>;
+    sync(): Promise<void>;
+    truncate(len?: number): Promise<void>;
+    utimes(atime: TTime, mtime: TTime): Promise<void>;
+    write(buffer: Buffer | Uint8Array, offset?: number, length?: number, position?: number): Promise<TFileHandleWriteResult>;
+    writeFile(data: TData, options?: IWriteFileOptions): Promise<void>;
+}
+export default function createPromisesApi(vol: Volume): null | IPromisesAPI;

app_vue/node_modules/memfs/lib/promises.js

@@ -0,0 +1,158 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHandle = void 0;
+function promisify(vol, fn, getResult) {
+    if (getResult === void 0) { getResult = function (input) { return input; }; }
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return new Promise(function (resolve, reject) {
+            vol[fn].bind(vol).apply(void 0, __spreadArray(__spreadArray([], args, false), [function (error, result) {
+                    if (error)
+                        return reject(error);
+                    return resolve(getResult(result));
+                }], false));
+        });
+    };
+}
+var FileHandle = /** @class */ (function () {
+    function FileHandle(vol, fd) {
+        this.vol = vol;
+        this.fd = fd;
+    }
+    FileHandle.prototype.appendFile = function (data, options) {
+        return promisify(this.vol, 'appendFile')(this.fd, data, options);
+    };
+    FileHandle.prototype.chmod = function (mode) {
+        return promisify(this.vol, 'fchmod')(this.fd, mode);
+    };
+    FileHandle.prototype.chown = function (uid, gid) {
+        return promisify(this.vol, 'fchown')(this.fd, uid, gid);
+    };
+    FileHandle.prototype.close = function () {
+        return promisify(this.vol, 'close')(this.fd);
+    };
+    FileHandle.prototype.datasync = function () {
+        return promisify(this.vol, 'fdatasync')(this.fd);
+    };
+    FileHandle.prototype.read = function (buffer, offset, length, position) {
+        return promisify(this.vol, 'read', function (bytesRead) { return ({ bytesRead: bytesRead, buffer: buffer }); })(this.fd, buffer, offset, length, position);
+    };
+    FileHandle.prototype.readFile = function (options) {
+        return promisify(this.vol, 'readFile')(this.fd, options);
+    };
+    FileHandle.prototype.stat = function (options) {
+        return promisify(this.vol, 'fstat')(this.fd, options);
+    };
+    FileHandle.prototype.sync = function () {
+        return promisify(this.vol, 'fsync')(this.fd);
+    };
+    FileHandle.prototype.truncate = function (len) {
+        return promisify(this.vol, 'ftruncate')(this.fd, len);
+    };
+    FileHandle.prototype.utimes = function (atime, mtime) {
+        return promisify(this.vol, 'futimes')(this.fd, atime, mtime);
+    };
+    FileHandle.prototype.write = function (buffer, offset, length, position) {
+        return promisify(this.vol, 'write', function (bytesWritten) { return ({ bytesWritten: bytesWritten, buffer: buffer }); })(this.fd, buffer, offset, length, position);
+    };
+    FileHandle.prototype.writeFile = function (data, options) {
+        return promisify(this.vol, 'writeFile')(this.fd, data, options);
+    };
+    return FileHandle;
+}());
+exports.FileHandle = FileHandle;
+function createPromisesApi(vol) {
+    if (typeof Promise === 'undefined')
+        return null;
+    return {
+        FileHandle: FileHandle,
+        access: function (path, mode) {
+            return promisify(vol, 'access')(path, mode);
+        },
+        appendFile: function (path, data, options) {
+            return promisify(vol, 'appendFile')(path instanceof FileHandle ? path.fd : path, data, options);
+        },
+        chmod: function (path, mode) {
+            return promisify(vol, 'chmod')(path, mode);
+        },
+        chown: function (path, uid, gid) {
+            return promisify(vol, 'chown')(path, uid, gid);
+        },
+        copyFile: function (src, dest, flags) {
+            return promisify(vol, 'copyFile')(src, dest, flags);
+        },
+        lchmod: function (path, mode) {
+            return promisify(vol, 'lchmod')(path, mode);
+        },
+        lchown: function (path, uid, gid) {
+            return promisify(vol, 'lchown')(path, uid, gid);
+        },
+        link: function (existingPath, newPath) {
+            return promisify(vol, 'link')(existingPath, newPath);
+        },
+        lstat: function (path, options) {
+            return promisify(vol, 'lstat')(path, options);
+        },
+        mkdir: function (path, options) {
+            return promisify(vol, 'mkdir')(path, options);
+        },
+        mkdtemp: function (prefix, options) {
+            return promisify(vol, 'mkdtemp')(prefix, options);
+        },
+        open: function (path, flags, mode) {
+            return promisify(vol, 'open', function (fd) { return new FileHandle(vol, fd); })(path, flags, mode);
+        },
+        readdir: function (path, options) {
+            return promisify(vol, 'readdir')(path, options);
+        },
+        readFile: function (id, options) {
+            return promisify(vol, 'readFile')(id instanceof FileHandle ? id.fd : id, options);
+        },
+        readlink: function (path, options) {
+            return promisify(vol, 'readlink')(path, options);
+        },
+        realpath: function (path, options) {
+            return promisify(vol, 'realpath')(path, options);
+        },
+        rename: function (oldPath, newPath) {
+            return promisify(vol, 'rename')(oldPath, newPath);
+        },
+        rmdir: function (path) {
+            return promisify(vol, 'rmdir')(path);
+        },
+        rm: function (path, options) {
+            return promisify(vol, 'rm')(path, options);
+        },
+        stat: function (path, options) {
+            return promisify(vol, 'stat')(path, options);
+        },
+        symlink: function (target, path, type) {
+            return promisify(vol, 'symlink')(target, path, type);
+        },
+        truncate: function (path, len) {
+            return promisify(vol, 'truncate')(path, len);
+        },
+        unlink: function (path) {
+            return promisify(vol, 'unlink')(path);
+        },
+        utimes: function (path, atime, mtime) {
+            return promisify(vol, 'utimes')(path, atime, mtime);
+        },
+        writeFile: function (id, data, options) {
+            return promisify(vol, 'writeFile')(id instanceof FileHandle ? id.fd : id, data, options);
+        },
+    };
+}
+exports.default = createPromisesApi;

app_vue/node_modules/memfs/lib/setImmediate.d.ts

@@ -0,0 +1,3 @@
+type TSetImmediate = (callback: (...args: any[]) => void, args?: any) => void;
+declare const _default: TSetImmediate;
+export default _default;

app_vue/node_modules/memfs/lib/setImmediate.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var _setImmediate;
+if (typeof setImmediate === 'function')
+    _setImmediate = setImmediate.bind(typeof globalThis !== 'undefined' ? globalThis : global);
+else
+    _setImmediate = setTimeout.bind(typeof globalThis !== 'undefined' ? globalThis : global);
+exports.default = _setImmediate;

app_vue/node_modules/memfs/lib/setTimeoutUnref.d.ts

@@ -0,0 +1,7 @@
+export type TSetTimeout = (callback: (...args: any[]) => void, time?: number, args?: any[]) => any;
+/**
+ * `setTimeoutUnref` is just like `setTimeout`,
+ * only in Node's environment it will "unref" its macro task.
+ */
+declare function setTimeoutUnref(callback: any, time?: any, args?: any): object;
+export default setTimeoutUnref;

app_vue/node_modules/memfs/lib/setTimeoutUnref.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `setTimeoutUnref` is just like `setTimeout`,
+ * only in Node's environment it will "unref" its macro task.
+ */
+function setTimeoutUnref(callback, time, args) {
+    var ref = setTimeout.apply(typeof globalThis !== 'undefined' ? globalThis : global, arguments);
+    if (ref && typeof ref === 'object' && typeof ref.unref === 'function')
+        ref.unref();
+    return ref;
+}
+exports.default = setTimeoutUnref;

app_vue/node_modules/memfs/lib/volume-localstorage.d.ts

@@ -0,0 +1,14 @@
+import { Volume } from './volume';
+export interface IStore {
+    setItem(key: string, json: any): any;
+    getItem(key: string): any;
+    removeItem(key: string): any;
+}
+export declare class ObjectStore {
+    obj: object;
+    constructor(obj: any);
+    setItem(key: string, json: any): void;
+    getItem(key: string): any;
+    removeItem(key: string): void;
+}
+export declare function createVolume(namespace: string, LS?: IStore | object): new (...args: any[]) => Volume;

app_vue/node_modules/memfs/lib/volume-localstorage.js

@@ -0,0 +1,110 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVolume = exports.ObjectStore = void 0;
+var volume_1 = require("./volume");
+var node_1 = require("./node");
+var ObjectStore = /** @class */ (function () {
+    function ObjectStore(obj) {
+        this.obj = obj;
+    }
+    ObjectStore.prototype.setItem = function (key, json) {
+        this.obj[key] = JSON.stringify(json);
+    };
+    ObjectStore.prototype.getItem = function (key) {
+        var data = this.obj[key];
+        if (typeof data === void 0)
+            return void 0;
+        return JSON.parse(data);
+    };
+    ObjectStore.prototype.removeItem = function (key) {
+        delete this.obj[key];
+    };
+    return ObjectStore;
+}());
+exports.ObjectStore = ObjectStore;
+function createVolume(namespace, LS) {
+    if (LS === void 0) { LS = localStorage; }
+    var store = new ObjectStore(LS);
+    var key = function (type, id) { return "memfs.".concat(namespace, ".").concat(type, ".").concat(id); };
+    var NodeLocalStorage = /** @class */ (function (_super) {
+        __extends(NodeLocalStorage, _super);
+        function NodeLocalStorage() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(NodeLocalStorage.prototype, "Key", {
+            get: function () {
+                if (!this._key)
+                    this._key = key('ino', this.ino);
+                return this._key;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        NodeLocalStorage.prototype.sync = function () {
+            store.setItem(this.Key, this.toJSON());
+        };
+        NodeLocalStorage.prototype.touch = function () {
+            _super.prototype.touch.call(this);
+            this.sync();
+        };
+        NodeLocalStorage.prototype.del = function () {
+            _super.prototype.del.call(this);
+            store.removeItem(this.Key);
+        };
+        return NodeLocalStorage;
+    }(node_1.Node));
+    var LinkLocalStorage = /** @class */ (function (_super) {
+        __extends(LinkLocalStorage, _super);
+        function LinkLocalStorage() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(LinkLocalStorage.prototype, "Key", {
+            get: function () {
+                if (!this._key)
+                    this._key = key('link', this.getPath());
+                return this._key;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        LinkLocalStorage.prototype.sync = function () {
+            store.setItem(this.Key, this.toJSON());
+        };
+        return LinkLocalStorage;
+    }(node_1.Link));
+    return /** @class */ (function (_super) {
+        __extends(VolumeLocalStorage, _super);
+        function VolumeLocalStorage() {
+            return _super.call(this, {
+                Node: NodeLocalStorage,
+                Link: LinkLocalStorage,
+            }) || this;
+        }
+        VolumeLocalStorage.prototype.createLink = function (parent, name, isDirectory, perm) {
+            var link = _super.prototype.createLink.call(this, parent, name, isDirectory, perm);
+            store.setItem(key('link', link.getPath()), link.toJSON());
+            return link;
+        };
+        VolumeLocalStorage.prototype.deleteLink = function (link) {
+            store.removeItem(key('link', link.getPath()));
+            return _super.prototype.deleteLink.call(this, link);
+        };
+        return VolumeLocalStorage;
+    }(volume_1.Volume));
+}
+exports.createVolume = createVolume;

app_vue/node_modules/memfs/lib/volume.d.ts

@@ -0,0 +1,452 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { PathLike, symlink } from 'fs';
+import { Node, Link, File } from './node';
+import Stats from './Stats';
+import Dirent from './Dirent';
+import { TSetTimeout } from './setTimeoutUnref';
+import { Readable, Writable } from 'stream';
+import { constants } from './constants';
+import { EventEmitter } from 'events';
+import { TEncodingExtended, TDataOut } from './encoding';
+export interface IError extends Error {
+    code?: string;
+}
+export type TFileId = PathLike | number;
+export type TData = TDataOut | Uint8Array;
+export type TFlags = string | number;
+export type TMode = string | number;
+export type TTime = number | string | Date;
+export type TCallback<TData> = (error?: IError | null, data?: TData) => void;
+export declare enum FLAGS {
+    r,
+    'r+',
+    rs,
+    sr,
+    'rs+',
+    'sr+',
+    w,
+    wx,
+    xw,
+    'w+',
+    'wx+',
+    'xw+',
+    a,
+    ax,
+    xa,
+    'a+',
+    'ax+',
+    'xa+'
+}
+export type TFlagsCopy = typeof constants.COPYFILE_EXCL | typeof constants.COPYFILE_FICLONE | typeof constants.COPYFILE_FICLONE_FORCE;
+export declare function flagsToNumber(flags: TFlags | undefined): number;
+export interface IOptions {
+    encoding?: BufferEncoding | TEncodingExtended;
+}
+export interface IFileOptions extends IOptions {
+    mode?: TMode;
+    flag?: TFlags;
+}
+export interface IReadFileOptions extends IOptions {
+    flag?: string;
+}
+export interface IWriteFileOptions extends IFileOptions {
+}
+export interface IAppendFileOptions extends IFileOptions {
+}
+export interface IRealpathOptions {
+    encoding?: TEncodingExtended;
+}
+export interface IWatchFileOptions {
+    persistent?: boolean;
+    interval?: number;
+}
+export interface IReadStreamOptions {
+    flags?: TFlags;
+    encoding?: BufferEncoding;
+    fd?: number;
+    mode?: TMode;
+    autoClose?: boolean;
+    start?: number;
+    end?: number;
+}
+export interface IWriteStreamOptions {
+    flags?: TFlags;
+    defaultEncoding?: BufferEncoding;
+    fd?: number;
+    mode?: TMode;
+    autoClose?: boolean;
+    start?: number;
+}
+export interface IWatchOptions extends IOptions {
+    persistent?: boolean;
+    recursive?: boolean;
+}
+export interface IMkdirOptions {
+    mode?: TMode;
+    recursive?: boolean;
+}
+export interface IRmdirOptions {
+    recursive?: boolean;
+}
+export interface IRmOptions {
+    force?: boolean;
+    maxRetries?: number;
+    recursive?: boolean;
+    retryDelay?: number;
+}
+export interface IReaddirOptions extends IOptions {
+    withFileTypes?: boolean;
+}
+export interface IStatOptions {
+    bigint?: boolean;
+    throwIfNoEntry?: boolean;
+}
+export interface IFStatOptions {
+    bigint?: boolean;
+}
+export declare function pathToFilename(path: PathLike): string;
+export declare function filenameToSteps(filename: string, base?: string): string[];
+export declare function pathToSteps(path: PathLike): string[];
+export declare function dataToStr(data: TData, encoding?: string): string;
+export declare function dataToBuffer(data: TData, encoding?: string): Buffer;
+export declare function bufferToEncoding(buffer: Buffer, encoding?: TEncodingExtended): TDataOut;
+export declare function toUnixTimestamp(time: any): any;
+type DirectoryContent = string | null;
+export interface DirectoryJSON {
+    [key: string]: DirectoryContent;
+}
+export interface NestedDirectoryJSON {
+    [key: string]: DirectoryContent | NestedDirectoryJSON;
+}
+/**
+ * `Volume` represents a file system.
+ */
+export declare class Volume {
+    static fromJSON(json: DirectoryJSON, cwd?: string): Volume;
+    static fromNestedJSON(json: NestedDirectoryJSON, cwd?: string): Volume;
+    /**
+     * Global file descriptor counter. UNIX file descriptors start from 0 and go sequentially
+     * up, so here, in order not to conflict with them, we choose some big number and descrease
+     * the file descriptor of every new opened file.
+     * @type {number}
+     * @todo This should not be static, right?
+     */
+    static fd: number;
+    root: Link;
+    ino: number;
+    inodes: {
+        [ino: number]: Node;
+    };
+    releasedInos: number[];
+    fds: {
+        [fd: number]: File;
+    };
+    releasedFds: number[];
+    maxFiles: number;
+    openFiles: number;
+    StatWatcher: new () => StatWatcher;
+    ReadStream: new (...args: any[]) => IReadStream;
+    WriteStream: new (...args: any[]) => IWriteStream;
+    FSWatcher: new () => FSWatcher;
+    props: {
+        Node: new (...args: any[]) => Node;
+        Link: new (...args: any[]) => Link;
+        File: new (...args: any[]) => File;
+    };
+    private promisesApi;
+    get promises(): import("./promises").IPromisesAPI;
+    constructor(props?: {});
+    createLink(): Link;
+    createLink(parent: Link, name: string, isDirectory?: boolean, perm?: number): Link;
+    deleteLink(link: Link): boolean;
+    private newInoNumber;
+    private newFdNumber;
+    createNode(isDirectory?: boolean, perm?: number): Node;
+    private getNode;
+    private deleteNode;
+    genRndStr(): any;
+    getLink(steps: string[]): Link | null;
+    getLinkOrThrow(filename: string, funcName?: string): Link;
+    getResolvedLink(filenameOrSteps: string | string[]): Link | null;
+    getResolvedLinkOrThrow(filename: string, funcName?: string): Link;
+    resolveSymlinks(link: Link): Link | null;
+    private getLinkAsDirOrThrow;
+    private getLinkParent;
+    private getLinkParentAsDirOrThrow;
+    private getFileByFd;
+    private getFileByFdOrThrow;
+    /**
+     * @todo This is not used anymore. Remove.
+     */
+    private wrapAsync;
+    private _toJSON;
+    toJSON(paths?: PathLike | PathLike[], json?: {}, isRelative?: boolean): DirectoryJSON;
+    fromJSON(json: DirectoryJSON, cwd?: string): void;
+    fromNestedJSON(json: NestedDirectoryJSON, cwd?: string): void;
+    reset(): void;
+    mountSync(mountpoint: string, json: DirectoryJSON): void;
+    private openLink;
+    private openFile;
+    private openBase;
+    openSync(path: PathLike, flags: TFlags, mode?: TMode): number;
+    open(path: PathLike, flags: TFlags, /* ... */ callback: TCallback<number>): any;
+    open(path: PathLike, flags: TFlags, mode: TMode, callback: TCallback<number>): any;
+    private closeFile;
+    closeSync(fd: number): void;
+    close(fd: number, callback: TCallback<void>): void;
+    private openFileOrGetById;
+    private readBase;
+    readSync(fd: number, buffer: Buffer | Uint8Array, offset: number, length: number, position: number): number;
+    read(fd: number, buffer: Buffer | Uint8Array, offset: number, length: number, position: number, callback: (err?: Error | null, bytesRead?: number, buffer?: Buffer | Uint8Array) => void): void;
+    private readFileBase;
+    readFileSync(file: TFileId, options?: IReadFileOptions | string): TDataOut;
+    readFile(id: TFileId, callback: TCallback<TDataOut>): any;
+    readFile(id: TFileId, options: IReadFileOptions | string, callback: TCallback<TDataOut>): any;
+    private writeBase;
+    writeSync(fd: number, buffer: Buffer | Uint8Array, offset?: number, length?: number, position?: number): number;
+    writeSync(fd: number, str: string, position?: number, encoding?: BufferEncoding): number;
+    write(fd: number, buffer: Buffer | Uint8Array, callback: (...args: any[]) => void): any;
+    write(fd: number, buffer: Buffer | Uint8Array, offset: number, callback: (...args: any[]) => void): any;
+    write(fd: number, buffer: Buffer | Uint8Array, offset: number, length: number, callback: (...args: any[]) => void): any;
+    write(fd: number, buffer: Buffer | Uint8Array, offset: number, length: number, position: number, callback: (...args: any[]) => void): any;
+    write(fd: number, str: string, callback: (...args: any[]) => void): any;
+    write(fd: number, str: string, position: number, callback: (...args: any[]) => void): any;
+    write(fd: number, str: string, position: number, encoding: BufferEncoding, callback: (...args: any[]) => void): any;
+    private writeFileBase;
+    writeFileSync(id: TFileId, data: TData, options?: IWriteFileOptions): void;
+    writeFile(id: TFileId, data: TData, callback: TCallback<void>): any;
+    writeFile(id: TFileId, data: TData, options: IWriteFileOptions | string, callback: TCallback<void>): any;
+    private linkBase;
+    private copyFileBase;
+    copyFileSync(src: PathLike, dest: PathLike, flags?: TFlagsCopy): void;
+    copyFile(src: PathLike, dest: PathLike, callback: TCallback<void>): any;
+    copyFile(src: PathLike, dest: PathLike, flags: TFlagsCopy, callback: TCallback<void>): any;
+    linkSync(existingPath: PathLike, newPath: PathLike): void;
+    link(existingPath: PathLike, newPath: PathLike, callback: TCallback<void>): void;
+    private unlinkBase;
+    unlinkSync(path: PathLike): void;
+    unlink(path: PathLike, callback: TCallback<void>): void;
+    private symlinkBase;
+    symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type): void;
+    symlink(target: PathLike, path: PathLike, callback: TCallback<void>): any;
+    symlink(target: PathLike, path: PathLike, type: symlink.Type, callback: TCallback<void>): any;
+    private realpathBase;
+    realpathSync(path: PathLike, options?: IRealpathOptions | string): TDataOut;
+    realpath(path: PathLike, callback: TCallback<TDataOut>): any;
+    realpath(path: PathLike, options: IRealpathOptions | string, callback: TCallback<TDataOut>): any;
+    private lstatBase;
+    lstatSync(path: PathLike): Stats<number>;
+    lstatSync(path: PathLike, options: {
+        throwIfNoEntry?: true | undefined;
+    }): Stats<number>;
+    lstatSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry?: true | undefined;
+    }): Stats<number>;
+    lstatSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry?: true | undefined;
+    }): Stats<bigint>;
+    lstatSync(path: PathLike, options: {
+        throwIfNoEntry: false;
+    }): Stats<number> | undefined;
+    lstatSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry: false;
+    }): Stats<number> | undefined;
+    lstatSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): Stats<bigint> | undefined;
+    lstat(path: PathLike, callback: TCallback<Stats>): void;
+    lstat(path: PathLike, options: IStatOptions, callback: TCallback<Stats>): void;
+    private statBase;
+    statSync(path: PathLike): Stats<number>;
+    statSync(path: PathLike, options: {
+        throwIfNoEntry?: true;
+    }): Stats<number>;
+    statSync(path: PathLike, options: {
+        throwIfNoEntry: false;
+    }): Stats<number> | undefined;
+    statSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry?: true;
+    }): Stats<number>;
+    statSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry?: true;
+    }): Stats<bigint>;
+    statSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry: false;
+    }): Stats<number> | undefined;
+    statSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): Stats<bigint> | undefined;
+    stat(path: PathLike, callback: TCallback<Stats>): void;
+    stat(path: PathLike, options: IStatOptions, callback: TCallback<Stats>): void;
+    private fstatBase;
+    fstatSync(fd: number): Stats<number>;
+    fstatSync(fd: number, options: {
+        bigint: false;
+    }): Stats<number>;
+    fstatSync(fd: number, options: {
+        bigint: true;
+    }): Stats<bigint>;
+    fstat(fd: number, callback: TCallback<Stats>): void;
+    fstat(fd: number, options: IFStatOptions, callback: TCallback<Stats>): void;
+    private renameBase;
+    renameSync(oldPath: PathLike, newPath: PathLike): void;
+    rename(oldPath: PathLike, newPath: PathLike, callback: TCallback<void>): void;
+    private existsBase;
+    existsSync(path: PathLike): boolean;
+    exists(path: PathLike, callback: (exists: boolean) => void): void;
+    private accessBase;
+    accessSync(path: PathLike, mode?: number): void;
+    access(path: PathLike, callback: TCallback<void>): any;
+    access(path: PathLike, mode: number, callback: TCallback<void>): any;
+    appendFileSync(id: TFileId, data: TData, options?: IAppendFileOptions | string): void;
+    appendFile(id: TFileId, data: TData, callback: TCallback<void>): any;
+    appendFile(id: TFileId, data: TData, options: IAppendFileOptions | string, callback: TCallback<void>): any;
+    private readdirBase;
+    readdirSync(path: PathLike, options?: IReaddirOptions | string): TDataOut[] | Dirent[];
+    readdir(path: PathLike, callback: TCallback<TDataOut[] | Dirent[]>): any;
+    readdir(path: PathLike, options: IReaddirOptions | string, callback: TCallback<TDataOut[] | Dirent[]>): any;
+    private readlinkBase;
+    readlinkSync(path: PathLike, options?: IOptions): TDataOut;
+    readlink(path: PathLike, callback: TCallback<TDataOut>): any;
+    readlink(path: PathLike, options: IOptions, callback: TCallback<TDataOut>): any;
+    private fsyncBase;
+    fsyncSync(fd: number): void;
+    fsync(fd: number, callback: TCallback<void>): void;
+    private fdatasyncBase;
+    fdatasyncSync(fd: number): void;
+    fdatasync(fd: number, callback: TCallback<void>): void;
+    private ftruncateBase;
+    ftruncateSync(fd: number, len?: number): void;
+    ftruncate(fd: number, callback: TCallback<void>): any;
+    ftruncate(fd: number, len: number, callback: TCallback<void>): any;
+    private truncateBase;
+    truncateSync(id: TFileId, len?: number): void;
+    truncate(id: TFileId, callback: TCallback<void>): any;
+    truncate(id: TFileId, len: number, callback: TCallback<void>): any;
+    private futimesBase;
+    futimesSync(fd: number, atime: TTime, mtime: TTime): void;
+    futimes(fd: number, atime: TTime, mtime: TTime, callback: TCallback<void>): void;
+    private utimesBase;
+    utimesSync(path: PathLike, atime: TTime, mtime: TTime): void;
+    utimes(path: PathLike, atime: TTime, mtime: TTime, callback: TCallback<void>): void;
+    private mkdirBase;
+    /**
+     * Creates directory tree recursively.
+     * @param filename
+     * @param modeNum
+     */
+    private mkdirpBase;
+    mkdirSync(path: PathLike, options: IMkdirOptions & {
+        recursive: true;
+    }): string | undefined;
+    mkdirSync(path: PathLike, options?: TMode | (IMkdirOptions & {
+        recursive?: false;
+    })): void;
+    mkdirSync(path: PathLike, options?: TMode | IMkdirOptions): string | undefined;
+    mkdir(path: PathLike, callback: TCallback<void>): any;
+    mkdir(path: PathLike, mode: TMode | (IMkdirOptions & {
+        recursive?: false;
+    }), callback: TCallback<void>): any;
+    mkdir(path: PathLike, mode: IMkdirOptions & {
+        recursive: true;
+    }, callback: TCallback<string>): any;
+    mkdir(path: PathLike, mode: TMode | IMkdirOptions, callback: TCallback<string>): any;
+    mkdirpSync(path: PathLike, mode?: TMode): string | undefined;
+    mkdirp(path: PathLike, callback: TCallback<string>): any;
+    mkdirp(path: PathLike, mode: TMode, callback: TCallback<string>): any;
+    private mkdtempBase;
+    mkdtempSync(prefix: string, options?: IOptions): TDataOut;
+    mkdtemp(prefix: string, callback: TCallback<void>): any;
+    mkdtemp(prefix: string, options: IOptions, callback: TCallback<void>): any;
+    private rmdirBase;
+    rmdirSync(path: PathLike, options?: IRmdirOptions): void;
+    rmdir(path: PathLike, callback: TCallback<void>): any;
+    rmdir(path: PathLike, options: IRmdirOptions, callback: TCallback<void>): any;
+    private rmBase;
+    rmSync(path: PathLike, options?: IRmOptions): void;
+    rm(path: PathLike, callback: TCallback<void>): void;
+    rm(path: PathLike, options: IRmOptions, callback: TCallback<void>): void;
+    private fchmodBase;
+    fchmodSync(fd: number, mode: TMode): void;
+    fchmod(fd: number, mode: TMode, callback: TCallback<void>): void;
+    private chmodBase;
+    chmodSync(path: PathLike, mode: TMode): void;
+    chmod(path: PathLike, mode: TMode, callback: TCallback<void>): void;
+    private lchmodBase;
+    lchmodSync(path: PathLike, mode: TMode): void;
+    lchmod(path: PathLike, mode: TMode, callback: TCallback<void>): void;
+    private fchownBase;
+    fchownSync(fd: number, uid: number, gid: number): void;
+    fchown(fd: number, uid: number, gid: number, callback: TCallback<void>): void;
+    private chownBase;
+    chownSync(path: PathLike, uid: number, gid: number): void;
+    chown(path: PathLike, uid: number, gid: number, callback: TCallback<void>): void;
+    private lchownBase;
+    lchownSync(path: PathLike, uid: number, gid: number): void;
+    lchown(path: PathLike, uid: number, gid: number, callback: TCallback<void>): void;
+    private statWatchers;
+    watchFile(path: PathLike, listener: (curr: Stats, prev: Stats) => void): StatWatcher;
+    watchFile(path: PathLike, options: IWatchFileOptions, listener: (curr: Stats, prev: Stats) => void): StatWatcher;
+    unwatchFile(path: PathLike, listener?: (curr: Stats, prev: Stats) => void): void;
+    createReadStream(path: PathLike, options?: IReadStreamOptions | string): IReadStream;
+    createWriteStream(path: PathLike, options?: IWriteStreamOptions | string): IWriteStream;
+    watch(path: PathLike, options?: IWatchOptions | string, listener?: (eventType: string, filename: string) => void): FSWatcher;
+}
+export declare class StatWatcher extends EventEmitter {
+    vol: Volume;
+    filename: string;
+    interval: number;
+    timeoutRef?: any;
+    setTimeout: TSetTimeout;
+    prev: Stats;
+    constructor(vol: Volume);
+    private loop;
+    private hasChanged;
+    private onInterval;
+    start(path: string, persistent?: boolean, interval?: number): void;
+    stop(): void;
+}
+export interface IReadStream extends Readable {
+    new (path: PathLike, options: IReadStreamOptions): any;
+    open(): any;
+    close(callback: TCallback<void>): any;
+    bytesRead: number;
+    path: string;
+}
+export interface IWriteStream extends Writable {
+    bytesWritten: number;
+    path: string;
+    new (path: PathLike, options: IWriteStreamOptions): any;
+    open(): any;
+    close(): any;
+}
+export declare class FSWatcher extends EventEmitter {
+    _vol: Volume;
+    _filename: string;
+    _steps: string[];
+    _filenameEncoded: TDataOut;
+    _recursive: boolean;
+    _encoding: BufferEncoding;
+    _link: Link;
+    _timer: any;
+    private _listenerRemovers;
+    constructor(vol: Volume);
+    private _getName;
+    private _onParentChild;
+    private _emit;
+    private _persist;
+    start(path: PathLike, persistent?: boolean, recursive?: boolean, encoding?: BufferEncoding): void;
+    close(): void;
+}
+export {};