@poe-platform/safe-js 0.1.799 → 0.1.801

package/dist/safe-js/portable/chunks/chunk-XCTU25SU.js

@@ -0,0 +1,111 @@
+import {
+  fsConstants,
+  hostFs,
+  paths_default
+} from "./chunk-H5X3T5VP.js";
+
+// packages/safe-js/src/modules/source-files.ts
+import { resolvePath } from "@poe-platform/safe-fs/core";
+async function createRootedSourceResolver(root, adapter) {
+  const realpath = (filename) => adapter ? adapter.realpath(filename) : hostFs.realpath(filename);
+  const stat = async (filename) => adapter ? sourceStat(await adapter.stat(filename)) : await hostFs.stat(filename);
+  const granted = adapter ? resolvePath("/", root) : paths_default.resolve(root);
+  const directory = await realpath(granted);
+  if (!(await stat(directory)).isDirectory()) throw new TypeError("Source module root must be a directory.");
+  const contains = (filename) => {
+    const relative = paths_default.relative(directory, filename);
+    return relative !== ".." && !relative.startsWith(`..${paths_default.sep}`) && !paths_default.isAbsolute(relative);
+  };
+  const resolver = async (specifier, referrer, { signal }) => {
+    signal?.throwIfAborted();
+    if (!specifier.startsWith("./") && !specifier.startsWith("../") || !paths_default.isAbsolute(referrer)) return void 0;
+    const relative = paths_default.relative(granted, referrer);
+    const canonicalReferrer = relative !== ".." && !relative.startsWith(`..${paths_default.sep}`) && !paths_default.isAbsolute(relative) ? paths_default.resolve(directory, relative) : referrer;
+    if (!contains(canonicalReferrer)) return void 0;
+    const candidate = paths_default.resolve(paths_default.dirname(canonicalReferrer), specifier);
+    if (!contains(candidate)) return void 0;
+    try {
+      const id = await realpath(candidate);
+      signal?.throwIfAborted();
+      if (!contains(id)) return void 0;
+      const expected = await stat(id);
+      signal?.throwIfAborted();
+      if (!expected.isFile()) return void 0;
+      const handle = adapter ? await openSourceFile(adapter, id, signal) : await hostFs.open(id, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW | fsConstants.O_NONBLOCK);
+      try {
+        signal?.throwIfAborted();
+        const actual = await handle.stat();
+        signal?.throwIfAborted();
+        if (!actual.isFile() || ("identity" in actual && "identity" in expected ? !sameSourceIdentity(actual.identity, expected.identity) : actual.dev !== expected.dev || actual.ino !== expected.ino)) return void 0;
+        const currentId = await realpath(id);
+        signal?.throwIfAborted();
+        if (currentId !== id) return void 0;
+        const source = await handle.readFile({ encoding: "utf8", signal });
+        signal?.throwIfAborted();
+        return { id, source };
+      } finally {
+        await handle.close();
+      }
+    } catch (error) {
+      signal?.throwIfAborted();
+      if (error !== null && typeof error === "object" && "code" in error && ["ENOENT", "ENOTDIR", "ELOOP"].includes(String(error.code))) return void 0;
+      throw error;
+    }
+  };
+  return Object.assign(resolver, { async entryId(filename) {
+    if (filename === void 0) return paths_default.join(directory, "<entry>");
+    const supplied = paths_default.resolve(granted, filename);
+    const relative = paths_default.relative(granted, supplied);
+    const candidate = relative !== ".." && !relative.startsWith(`..${paths_default.sep}`) && !paths_default.isAbsolute(relative) ? paths_default.resolve(directory, relative) : supplied;
+    if (!contains(candidate)) throw new TypeError("Source entry must be inside its granted root.");
+    try {
+      const id = await realpath(candidate);
+      if (!contains(id)) throw new TypeError("Source entry must be inside its granted root.");
+      return id;
+    } catch (error) {
+      if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT") return candidate;
+      throw error;
+    }
+  } });
+}
+function sourceStat(value) {
+  return {
+    identity: value,
+    dev: value.dev,
+    ino: value.ino,
+    isFile: () => value.type === "file",
+    isDirectory: () => value.type === "directory"
+  };
+}
+function sameSourceIdentity(actual, expected) {
+  if (expected.identityScope !== void 0 && expected.opaqueIdentity !== void 0) {
+    return actual.identityScope === expected.identityScope && actual.opaqueIdentity === expected.opaqueIdentity && (expected.opaqueVersion === void 0 || actual.opaqueVersion === expected.opaqueVersion);
+  }
+  return expected.dev !== void 0 && expected.ino !== void 0 && actual.dev === expected.dev && actual.ino === expected.ino;
+}
+async function openSourceFile(adapter, id, signal) {
+  if (!adapter.openReadFile) throw new TypeError("Source filesystem must support retained reads.");
+  const handle = await adapter.openReadFile(id, signal ? { signal } : {});
+  return {
+    stat: async () => sourceStat(await handle.stat(signal ? { signal } : {})),
+    close: handle.close.bind(handle),
+    async readFile(_options) {
+      const decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+      const chunks = [];
+      let position = 0;
+      for (; ; ) {
+        signal?.throwIfAborted();
+        const chunk = await handle.read(position, 64 * 1024, signal ? { signal } : {});
+        if (chunk.byteLength === 0) break;
+        chunks.push(decoder.decode(chunk, { stream: true }));
+        position += chunk.byteLength;
+      }
+      chunks.push(decoder.decode());
+      return chunks.join("");
+    }
+  };
+}
+
+export {
+  createRootedSourceResolver
+};

package/dist/safe-js/portable/chunks/source-files-CVU252FB.js

@@ -0,0 +1,7 @@
+import {
+  createRootedSourceResolver
+} from "./chunk-XCTU25SU.js";
+import "./chunk-H5X3T5VP.js";
+export {
+  createRootedSourceResolver
+};