@nshiab/setup-data-project 1.0.7

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/Listener.js

@@ -0,0 +1,92 @@
+"use strict";
+///<reference path="../stable/lib.deno.d.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Listener_listener;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+const close_js_1 = require("../stable/functions/close.js");
+const errors = __importStar(require("../stable/variables/errors.js"));
+class Listener {
+    constructor(rid, addr, listener) {
+        this.rid = rid;
+        this.addr = addr;
+        _Listener_listener.set(this, void 0);
+        __classPrivateFieldSet(this, _Listener_listener, listener, "f");
+    }
+    [(_Listener_listener = new WeakMap(), Symbol.dispose)]() {
+        this.close();
+    }
+    async accept() {
+        if (!__classPrivateFieldGet(this, _Listener_listener, "f")) {
+            throw new errors.BadResource("Listener not initialised");
+        }
+        const result = await __classPrivateFieldGet(this, _Listener_listener, "f").next();
+        if (result.done) {
+            throw new errors.BadResource("Server not listening");
+        }
+        return result.value;
+    }
+    async next() {
+        let conn;
+        try {
+            conn = await this.accept();
+        }
+        catch (error) {
+            if (error instanceof errors.BadResource) {
+                return { value: undefined, done: true };
+            }
+            throw error;
+        }
+        return { value: conn, done: false };
+    }
+    return(value) {
+        this.close();
+        return Promise.resolve({ value, done: true });
+    }
+    close() {
+        (0, close_js_1.close)(this.rid);
+    }
+    ref() {
+        throw new Error("Not implemented");
+    }
+    unref() {
+        throw new Error("Not implemented");
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+}
+exports.Listener = Listener;

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/consts.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BUFFER_SIZE = void 0;
+exports.DEFAULT_BUFFER_SIZE = 32 * 1024;

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/errorMap.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors = __importStar(require("../stable/variables/errors.js"));
+const mapper = (Ctor) => (err) => Object.assign(new Ctor(err.message), {
+    stack: err.stack,
+});
+const map = {
+    EEXIST: mapper(errors.AlreadyExists),
+    ENOENT: mapper(errors.NotFound),
+    EBADF: mapper(errors.BadResource),
+};
+const isNodeErr = (e) => {
+    return e instanceof Error && "code" in e;
+};
+function mapError(e) {
+    var _a;
+    if (!isNodeErr(e))
+        return e;
+    return ((_a = map[e.code]) === null || _a === void 0 ? void 0 : _a.call(map, e)) || e;
+}
+exports.default = mapError;

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/fs_flags.js

@@ -0,0 +1,91 @@
+"use strict";
+// getAccessFlag and getCreationFlag adapted from the original in Rust's std::fs
+// <source path="https://github.com/rust-lang/rust/blob/304441960e7058fe97f09ef00b20739b4dc56d11/library/std/src/sys/unix/fs.rs#L694-L728" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFsFlag = exports.getCreationFlag = exports.getAccessFlag = void 0;
+const errors = __importStar(require("../stable/variables/errors.js"));
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY } = fs_1.constants;
+function getAccessFlag(opts) {
+    if (opts.read && !opts.write && !opts.append)
+        return O_RDONLY;
+    if (!opts.read && opts.write && !opts.append)
+        return O_WRONLY;
+    if (opts.read && opts.write && !opts.append)
+        return O_RDWR;
+    if (!opts.read && opts.append)
+        return O_WRONLY | O_APPEND;
+    if (opts.read && opts.append)
+        return O_RDWR | O_APPEND;
+    if (!opts.read && !opts.write && !opts.append) {
+        throw new errors.BadResource("EINVAL: One of 'read', 'write', 'append' is required to open file.");
+    }
+    throw new errors.BadResource("EINVAL: Invalid fs flags.");
+}
+exports.getAccessFlag = getAccessFlag;
+function getCreationFlag(opts) {
+    if (!opts.write && !opts.append) {
+        if (opts.truncate || opts.create || opts.createNew) {
+            throw new errors.BadResource("EINVAL: One of 'write', 'append' is required to 'truncate', 'create' or 'createNew' file.");
+        }
+    }
+    if (opts.append) {
+        if (opts.truncate && !opts.createNew) {
+            throw new errors.BadResource("EINVAL: unexpected 'truncate': true and 'createNew': false when 'append' is true.");
+        }
+    }
+    if (!opts.create && !opts.truncate && !opts.createNew)
+        return 0;
+    if (opts.create && !opts.truncate && !opts.createNew)
+        return O_CREAT;
+    if (!opts.create && opts.truncate && !opts.createNew) {
+        if (os_1.default.platform() === "win32") {
+            // for some reason only providing O_TRUNC on windows will
+            // throw a "EINVAL: invalid argument", so to work around this
+            // we relax the restriction here to also create the file if it
+            // doesn't exist
+            return O_CREAT | O_TRUNC;
+        }
+        else {
+            return O_TRUNC;
+        }
+    }
+    if (opts.create && opts.truncate && !opts.createNew) {
+        return O_CREAT | O_TRUNC;
+    }
+    if (opts.createNew)
+        return O_CREAT | O_EXCL;
+    throw new errors.BadResource("EINVAL: Invalid fs flags.");
+}
+exports.getCreationFlag = getCreationFlag;
+function getFsFlag(flags) {
+    return getAccessFlag(flags) | getCreationFlag(flags);
+}
+exports.getFsFlag = getFsFlag;

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/iterutil.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = exports.filterAsync = exports.mapAsync = exports.map = void 0;
+function* map(iter, f) {
+    for (const i of iter) {
+        yield f(i);
+    }
+}
+exports.map = map;
+async function* mapAsync(iter, f) {
+    for await (const i of iter) {
+        yield f(i);
+    }
+}
+exports.mapAsync = mapAsync;
+async function* filterAsync(iter, filter) {
+    for await (const i of iter) {
+        if (filter(i)) {
+            yield i;
+        }
+    }
+}
+exports.filterAsync = filterAsync;
+async function* merge(iterables) {
+    const racers = new Map(map(map(iterables, (iter) => iter[Symbol.asyncIterator]()), (iter) => [iter, iter.next()]));
+    while (racers.size > 0) {
+        const winner = await Promise.race(map(racers.entries(), ([iter, prom]) => prom.then((result) => ({ result, iter }))));
+        if (winner.result.done) {
+            racers.delete(winner.iter);
+        }
+        else {
+            yield await winner.result.value;
+            racers.set(winner.iter, winner.iter.next());
+        }
+    }
+}
+exports.merge = merge;

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/random_id.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomId = void 0;
+const randomId = () => {
+    const n = (Math.random() * 0xfffff * 1000000).toString(16);
+    return "" + n.slice(0, 6);
+};
+exports.randomId = randomId;

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/streams.js

@@ -0,0 +1,122 @@
+"use strict";
+/// <reference path="../stable/lib.deno.d.ts" />
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BufferStreamReader_instances, _BufferStreamReader_stream, _BufferStreamReader_error, _BufferStreamReader_ended, _BufferStreamReader_pendingActions, _BufferStreamReader_runPendingActions, _StreamWriter_stream;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamWriter = exports.BufferStreamReader = void 0;
+class BufferStreamReader {
+    constructor(stream) {
+        _BufferStreamReader_instances.add(this);
+        _BufferStreamReader_stream.set(this, void 0);
+        _BufferStreamReader_error.set(this, void 0);
+        _BufferStreamReader_ended.set(this, false);
+        _BufferStreamReader_pendingActions.set(this, []);
+        __classPrivateFieldSet(this, _BufferStreamReader_stream, stream, "f");
+        __classPrivateFieldGet(this, _BufferStreamReader_stream, "f").pause();
+        __classPrivateFieldGet(this, _BufferStreamReader_stream, "f").on("error", (error) => {
+            __classPrivateFieldSet(this, _BufferStreamReader_error, error, "f");
+            __classPrivateFieldGet(this, _BufferStreamReader_instances, "m", _BufferStreamReader_runPendingActions).call(this);
+        });
+        __classPrivateFieldGet(this, _BufferStreamReader_stream, "f").on("readable", () => {
+            __classPrivateFieldGet(this, _BufferStreamReader_instances, "m", _BufferStreamReader_runPendingActions).call(this);
+        });
+        __classPrivateFieldGet(this, _BufferStreamReader_stream, "f").on("end", () => {
+            __classPrivateFieldSet(this, _BufferStreamReader_ended, true, "f");
+            __classPrivateFieldGet(this, _BufferStreamReader_instances, "m", _BufferStreamReader_runPendingActions).call(this);
+        });
+    }
+    readAll() {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            const action = () => {
+                if (__classPrivateFieldGet(this, _BufferStreamReader_error, "f")) {
+                    reject(__classPrivateFieldGet(this, _BufferStreamReader_error, "f"));
+                    return;
+                }
+                const buffer = __classPrivateFieldGet(this, _BufferStreamReader_stream, "f").read();
+                if (buffer != null) {
+                    chunks.push(buffer);
+                    __classPrivateFieldGet(this, _BufferStreamReader_pendingActions, "f").push(action);
+                }
+                else if (__classPrivateFieldGet(this, _BufferStreamReader_ended, "f")) {
+                    const result = Buffer.concat(chunks);
+                    resolve(result);
+                }
+                else {
+                    __classPrivateFieldGet(this, _BufferStreamReader_pendingActions, "f").push(action);
+                }
+            };
+            action();
+        });
+    }
+    read(p) {
+        return new Promise((resolve, reject) => {
+            const action = () => {
+                if (__classPrivateFieldGet(this, _BufferStreamReader_error, "f")) {
+                    reject(__classPrivateFieldGet(this, _BufferStreamReader_error, "f"));
+                    return;
+                }
+                const readBuffer = __classPrivateFieldGet(this, _BufferStreamReader_stream, "f").read(p.byteLength);
+                if (readBuffer && readBuffer.byteLength > 0) {
+                    readBuffer.copy(p, 0, 0, readBuffer.byteLength);
+                    resolve(readBuffer.byteLength);
+                    return;
+                }
+                if (__classPrivateFieldGet(this, _BufferStreamReader_ended, "f")) {
+                    resolve(null);
+                }
+                else {
+                    __classPrivateFieldGet(this, _BufferStreamReader_pendingActions, "f").push(action);
+                }
+            };
+            action();
+        });
+    }
+}
+exports.BufferStreamReader = BufferStreamReader;
+_BufferStreamReader_stream = new WeakMap(), _BufferStreamReader_error = new WeakMap(), _BufferStreamReader_ended = new WeakMap(), _BufferStreamReader_pendingActions = new WeakMap(), _BufferStreamReader_instances = new WeakSet(), _BufferStreamReader_runPendingActions = function _BufferStreamReader_runPendingActions() {
+    const errors = [];
+    for (const action of __classPrivateFieldGet(this, _BufferStreamReader_pendingActions, "f").splice(0)) {
+        try {
+            action();
+        }
+        catch (err) {
+            errors.push(err);
+        }
+    }
+    if (errors.length > 0) {
+        throw (errors.length > 1
+            ? new globalThis.AggregateError(errors)
+            : errors[0]);
+    }
+};
+class StreamWriter {
+    constructor(stream) {
+        _StreamWriter_stream.set(this, void 0);
+        __classPrivateFieldSet(this, _StreamWriter_stream, stream, "f");
+    }
+    write(p) {
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _StreamWriter_stream, "f").write(p, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(p.byteLength);
+                }
+            });
+        });
+    }
+}
+exports.StreamWriter = StreamWriter;
+_StreamWriter_stream = new WeakMap();

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/test.d.ts

@@ -0,0 +1 @@
+export { testDefinitions } from "@deno/shim-deno-test";

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/test.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testDefinitions = void 0;
+var shim_deno_test_1 = require("@deno/shim-deno-test");
+Object.defineProperty(exports, "testDefinitions", { enumerable: true, get: function () { return shim_deno_test_1.testDefinitions; } });

package/npm/node_modules/@deno/shim-deno/dist/deno/internal/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescript = exports.deno = void 0;
+exports.deno = "1.40.3";
+exports.typescript = "5.3.3";

package/npm/node_modules/@deno/shim-deno/dist/deno/stable/classes/FsFile.js

@@ -0,0 +1,143 @@
+"use strict";
+///<reference path="../lib.deno.d.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _a, _b;
+var _c, _d;
+var _FsFile_closed, _FsFile_readableStream, _FsFile_writableStream;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = exports.FsFile = void 0;
+const fs = __importStar(require("node:fs"));
+const stream = __importStar(require("node:stream"));
+const fstat_js_1 = require("../functions/fstat.js");
+const fstatSync_js_1 = require("../functions/fstatSync.js");
+const ftruncate_js_1 = require("../functions/ftruncate.js");
+const ftruncateSync_js_1 = require("../functions/ftruncateSync.js");
+const fdatasync_js_1 = require("../functions/fdatasync.js");
+const fdatasyncSync_js_1 = require("../functions/fdatasyncSync.js");
+const read_js_1 = require("../functions/read.js");
+const readSync_js_1 = require("../functions/readSync.js");
+const write_js_1 = require("../functions/write.js");
+const writeSync_js_1 = require("../functions/writeSync.js");
+(_a = (_c = Symbol).dispose) !== null && _a !== void 0 ? _a : (_c.dispose = Symbol("Symbol.dispose"));
+(_b = (_d = Symbol).asyncDispose) !== null && _b !== void 0 ? _b : (_d.asyncDispose = Symbol("Symbol.asyncDispose"));
+class FsFile {
+    constructor(rid) {
+        this.rid = rid;
+        _FsFile_closed.set(this, false);
+        _FsFile_readableStream.set(this, void 0);
+        _FsFile_writableStream.set(this, void 0);
+    }
+    [(_FsFile_closed = new WeakMap(), _FsFile_readableStream = new WeakMap(), _FsFile_writableStream = new WeakMap(), Symbol.dispose)]() {
+        if (!__classPrivateFieldGet(this, _FsFile_closed, "f")) {
+            this.close();
+        }
+    }
+    async write(p) {
+        return await (0, write_js_1.write)(this.rid, p);
+    }
+    writeSync(p) {
+        return (0, writeSync_js_1.writeSync)(this.rid, p);
+    }
+    async truncate(len) {
+        await (0, ftruncate_js_1.ftruncate)(this.rid, len);
+    }
+    truncateSync(len) {
+        return (0, ftruncateSync_js_1.ftruncateSync)(this.rid, len);
+    }
+    read(p) {
+        return (0, read_js_1.read)(this.rid, p);
+    }
+    readSync(p) {
+        return (0, readSync_js_1.readSync)(this.rid, p);
+    }
+    seek(_offset, _whence) {
+        throw new Error("Method not implemented.");
+    }
+    seekSync(_offset, _whence) {
+        throw new Error("Method not implemented.");
+    }
+    async stat() {
+        return await (0, fstat_js_1.fstat)(this.rid);
+    }
+    statSync() {
+        return (0, fstatSync_js_1.fstatSync)(this.rid);
+    }
+    sync() {
+        throw new Error("Method not implemented.");
+    }
+    syncSync() {
+        throw new Error("Method not implemented.");
+    }
+    syncData() {
+        return (0, fdatasync_js_1.fdatasync)(this.rid);
+    }
+    syncDataSync() {
+        return (0, fdatasyncSync_js_1.fdatasyncSync)(this.rid);
+    }
+    utime(_atime, _mtime) {
+        throw new Error("Method not implemented.");
+    }
+    utimeSync(_atime, _mtime) {
+        throw new Error("Method not implemented.");
+    }
+    close() {
+        __classPrivateFieldSet(this, _FsFile_closed, true, "f");
+        fs.closeSync(this.rid);
+    }
+    get readable() {
+        if (__classPrivateFieldGet(this, _FsFile_readableStream, "f") == null) {
+            const nodeStream = fs.createReadStream(null, {
+                fd: this.rid,
+                autoClose: false,
+            });
+            __classPrivateFieldSet(this, _FsFile_readableStream, stream.Readable.toWeb(nodeStream), "f");
+        }
+        return __classPrivateFieldGet(this, _FsFile_readableStream, "f");
+    }
+    get writable() {
+        if (__classPrivateFieldGet(this, _FsFile_writableStream, "f") == null) {
+            const nodeStream = fs.createWriteStream(null, {
+                fd: this.rid,
+                autoClose: false,
+            });
+            __classPrivateFieldSet(this, _FsFile_writableStream, stream.Writable.toWeb(nodeStream), "f");
+        }
+        return __classPrivateFieldGet(this, _FsFile_writableStream, "f");
+    }
+}
+exports.FsFile = FsFile;
+const File = FsFile;
+exports.File = File;

package/npm/node_modules/@deno/shim-deno/dist/deno/stable/classes/PermissionStatus.js

@@ -0,0 +1,19 @@
+"use strict";
+///<reference path="../lib.deno.d.ts" />
+var _a, _b;
+var _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionStatus = void 0;
+// The listeners don't actually matter because the state of these permissions
+// is constant and mocked as Node.js has all doors open.
+(_a = (_c = globalThis).EventTarget) !== null && _a !== void 0 ? _a : (_c.EventTarget = (_b = require("events").EventTarget) !== null && _b !== void 0 ? _b : null);
+class PermissionStatus extends EventTarget {
+    /** @internal */
+    constructor(state) {
+        super();
+        this.state = state;
+        this.onchange = null;
+        this.partial = false;
+    }
+}
+exports.PermissionStatus = PermissionStatus;

package/npm/node_modules/@deno/shim-deno/dist/deno/stable/classes/Permissions.js

@@ -0,0 +1,26 @@
+"use strict";
+///<reference path="../lib.deno.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Permissions = void 0;
+const PermissionStatus_js_1 = require("../classes/PermissionStatus.js");
+class Permissions {
+    query(desc) {
+        return Promise.resolve(this.querySync(desc));
+    }
+    querySync(_desc) {
+        return new PermissionStatus_js_1.PermissionStatus("granted");
+    }
+    revoke(desc) {
+        return Promise.resolve(this.revokeSync(desc));
+    }
+    revokeSync(_desc) {
+        return new PermissionStatus_js_1.PermissionStatus("denied");
+    }
+    request(desc) {
+        return this.query(desc);
+    }
+    requestSync(desc) {
+        return this.querySync(desc);
+    }
+}
+exports.Permissions = Permissions;

package/npm/node_modules/@deno/shim-deno/dist/deno/stable/classes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionStatus = exports.Permissions = exports.FsFile = exports.File = void 0;
+var FsFile_js_1 = require("./classes/FsFile.js");
+Object.defineProperty(exports, "File", { enumerable: true, get: function () { return FsFile_js_1.File; } });
+Object.defineProperty(exports, "FsFile", { enumerable: true, get: function () { return FsFile_js_1.FsFile; } });
+var Permissions_js_1 = require("./classes/Permissions.js");
+Object.defineProperty(exports, "Permissions", { enumerable: true, get: function () { return Permissions_js_1.Permissions; } });
+var PermissionStatus_js_1 = require("./classes/PermissionStatus.js");
+Object.defineProperty(exports, "PermissionStatus", { enumerable: true, get: function () { return PermissionStatus_js_1.PermissionStatus; } });

package/npm/node_modules/@deno/shim-deno/dist/deno/stable/enums/SeekMode.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeekMode = void 0;
+var SeekMode;
+(function (SeekMode) {
+    SeekMode[SeekMode["Start"] = 0] = "Start";
+    SeekMode[SeekMode["Current"] = 1] = "Current";
+    SeekMode[SeekMode["End"] = 2] = "End";
+})(SeekMode || (exports.SeekMode = SeekMode = {}));

package/npm/node_modules/@deno/shim-deno/dist/deno/stable/enums.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeekMode = void 0;
+var SeekMode_js_1 = require("./enums/SeekMode.js");
+Object.defineProperty(exports, "SeekMode", { enumerable: true, get: function () { return SeekMode_js_1.SeekMode; } });

package/npm/node_modules/@deno/shim-deno/dist/deno/stable/functions/addSignalListener.js

@@ -0,0 +1,18 @@
+"use strict";
+/// <reference path="../lib.deno.d.ts" />
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSignalListener = void 0;
+const process_1 = __importDefault(require("process"));
+function denoSignalToNodeJs(signal) {
+    if (signal === "SIGEMT") {
+        throw new Error("SIGEMT is not supported");
+    }
+    return signal;
+}
+const addSignalListener = (signal, handler) => {
+    process_1.default.addListener(denoSignalToNodeJs(signal), handler);
+};
+exports.addSignalListener = addSignalListener;