resourcexjs 2.1.1 → 2.2.0

package/dist/arp.js

@@ -514,20 +514,25 @@ class ARP {
 function createARP(config) {
   return new ARP(config);
 }
-var VERSION = "2.1.1";
+var VERSION = "2.2.0";
 
 // ../registry/dist/index.js
 import { createRequire } from "node:module";
 import { gzip, gunzip } from "node:zlib";
 import { promisify } from "node:util";
 import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3, resolve as resolvePath } from "node:path";
+import { symlink, lstat, readlink } from "node:fs/promises";
 import { gzip as gzip2, gunzip as gunzip2 } from "node:zlib";
 import { promisify as promisify2 } from "node:util";
 import { readFile as readFile2, writeFile as writeFile2, readdir as readdir2, mkdir as mkdir2, rm as rm2, access as access2, stat as stat2 } from "node:fs/promises";
-import { resolve as resolve2, dirname as dirname2, join as join3 } from "node:path";
+import { resolve as resolve2, dirname as dirname2, join as join2 } from "node:path";
+import { join as join22, relative } from "node:path";
+import { stat as stat22, readFile as readFile22, readdir as readdir22 } from "node:fs/promises";
+import { gzip as gzip3, gunzip as gunzip3 } from "node:zlib";
+import { promisify as promisify3 } from "node:util";
 import { homedir as homedir2 } from "node:os";
-import { join as join32 } from "node:path";
+import { join as join4 } from "node:path";
 import fs from "node:fs";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -4276,7 +4281,7 @@ var require_deflate2 = __commonJS((exports) => {
     options.raw = true;
     return deflate(input, options);
   }
-  function gzip3(input, options) {
+  function gzip4(input, options) {
     options = options || {};
     options.gzip = true;
     return deflate(input, options);
@@ -4284,7 +4289,7 @@ var require_deflate2 = __commonJS((exports) => {
   exports.Deflate = Deflate;
   exports.deflate = deflate;
   exports.deflateRaw = deflateRaw;
-  exports.gzip = gzip3;
+  exports.gzip = gzip4;
 });
 var require_inffast = __commonJS((exports, module) => {
   var BAD = 30;
@@ -6299,7 +6304,7 @@ var require_ignore = __commonJS((exports, module) => {
   function makeArray(subject) {
     return Array.isArray(subject) ? subject : [subject];
   }
-  var EMPTY3 = "";
+  var EMPTY4 = "";
   var SPACE = " ";
   var ESCAPE = "\\";
   var REGEX_TEST_BLANK_LINE = /^\s+$/;
@@ -6317,7 +6322,7 @@ var require_ignore = __commonJS((exports, module) => {
   var define2 = (object, key, value) => Object.defineProperty(object, key, { value });
   var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
   var RETURN_FALSE = () => false;
-  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY3);
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY4);
   var cleanRangeBackSlash = (slashes) => {
     const { length } = slashes;
     return slashes.slice(0, length - length % 2);
@@ -6325,11 +6330,11 @@ var require_ignore = __commonJS((exports, module) => {
   var REPLACERS = [
     [
       /^\uFEFF/,
-      () => EMPTY3
+      () => EMPTY4
     ],
     [
       /((?:\\\\)*?)(\\?\s+)$/,
-      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY3)
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY4)
     ],
     [
       /(\\+?)\s/g,
@@ -7320,17 +7325,17 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
       const length = Math.ceil((62 + bpath.length + 1) / 8) * 8;
       const written = Buffer.alloc(length);
       const writer = new BufferCursor(written);
-      const stat22 = normalizeStats(entry);
-      writer.writeUInt32BE(stat22.ctimeSeconds);
-      writer.writeUInt32BE(stat22.ctimeNanoseconds);
-      writer.writeUInt32BE(stat22.mtimeSeconds);
-      writer.writeUInt32BE(stat22.mtimeNanoseconds);
-      writer.writeUInt32BE(stat22.dev);
-      writer.writeUInt32BE(stat22.ino);
-      writer.writeUInt32BE(stat22.mode);
-      writer.writeUInt32BE(stat22.uid);
-      writer.writeUInt32BE(stat22.gid);
-      writer.writeUInt32BE(stat22.size);
+      const stat3 = normalizeStats(entry);
+      writer.writeUInt32BE(stat3.ctimeSeconds);
+      writer.writeUInt32BE(stat3.ctimeNanoseconds);
+      writer.writeUInt32BE(stat3.mtimeSeconds);
+      writer.writeUInt32BE(stat3.mtimeNanoseconds);
+      writer.writeUInt32BE(stat3.dev);
+      writer.writeUInt32BE(stat3.ino);
+      writer.writeUInt32BE(stat3.mode);
+      writer.writeUInt32BE(stat3.uid);
+      writer.writeUInt32BE(stat3.gid);
+      writer.writeUInt32BE(stat3.size);
       writer.write(entry.oid, 20, "hex");
       writer.writeUInt16BE(renderCacheEntryFlags(entry));
       writer.write(entry.path, bpath.length, "utf8");
@@ -7375,13 +7380,13 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
     };
   }
   async function updateCachedIndexFile(fs2, filepath, cache) {
-    const [stat22, rawIndexFile] = await Promise.all([
+    const [stat3, rawIndexFile] = await Promise.all([
       fs2.lstat(filepath),
       fs2.read(filepath)
     ]);
     const index2 = await GitIndex.from(rawIndexFile);
     cache.map.set(filepath, index2);
-    cache.stats.set(filepath, stat22);
+    cache.stats.set(filepath, stat3);
   }
   async function isIndexStale(fs2, filepath, cache) {
     const savedStats = cache.stats.get(filepath);
@@ -7848,7 +7853,7 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
       path += "/";
     return isAbsolute ? `/${path}` : path;
   }
-  function join33(...args) {
+  function join42(...args) {
     if (args.length === 0)
       return ".";
     let joined;
@@ -8203,7 +8208,7 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
         }
       }
       for (const [key, value] of actualRefsToWrite) {
-        await acquireLock(key, async () => fs2.write(join33(gitdir, key), `${value.trim()}
+        await acquireLock(key, async () => fs2.write(join42(gitdir, key), `${value.trim()}
 `, "utf8"));
       }
       return { pruned };
@@ -8212,18 +8217,18 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
       if (!value.match(/[0-9a-f]{40}/)) {
         throw new InvalidOidError(value);
       }
-      await acquireLock(ref, async () => fs2.write(join33(gitdir, ref), `${value.trim()}
+      await acquireLock(ref, async () => fs2.write(join42(gitdir, ref), `${value.trim()}
 `, "utf8"));
     }
     static async writeSymbolicRef({ fs: fs2, gitdir, ref, value }) {
-      await acquireLock(ref, async () => fs2.write(join33(gitdir, ref), "ref: " + `${value.trim()}
+      await acquireLock(ref, async () => fs2.write(join42(gitdir, ref), "ref: " + `${value.trim()}
 `, "utf8"));
     }
     static async deleteRef({ fs: fs2, gitdir, ref }) {
       return GitRefManager.deleteRefs({ fs: fs2, gitdir, refs: [ref] });
     }
     static async deleteRefs({ fs: fs2, gitdir, refs }) {
-      await Promise.all(refs.map((ref) => fs2.rm(join33(gitdir, ref))));
+      await Promise.all(refs.map((ref) => fs2.rm(join42(gitdir, ref))));
       let text = await acquireLock("packed-refs", async () => fs2.read(`${gitdir}/packed-refs`, { encoding: "utf8" }));
       const packed = GitPackedRefs.from(text);
       const beforeSize = packed.refs.size;
@@ -9143,7 +9148,7 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
     format = "content",
     getExternalRefDelta
   }) {
-    let list = await fs2.readdir(join33(gitdir, "objects/pack"));
+    let list = await fs2.readdir(join42(gitdir, "objects/pack"));
     list = list.filter((x) => x.endsWith(".idx"));
     for (const filename of list) {
       const indexFile = `${gitdir}/objects/pack/${filename}`;
@@ -9884,9 +9889,9 @@ gpgsig`));
       }
       const tree = GitTree.from(object);
       for (const entry2 of tree) {
-        map.set(join33(filepath, entry2.path), entry2);
+        map.set(join42(filepath, entry2.path), entry2);
       }
-      return tree.entries().map((entry2) => join33(filepath, entry2.path));
+      return tree.entries().map((entry2) => join42(filepath, entry2.path));
     }
     async type(entry) {
       if (entry._type === false) {
@@ -9977,10 +9982,10 @@ gpgsig`));
     async readdir(entry) {
       const filepath = entry._fullpath;
       const { fs: fs2, dir } = this;
-      const names = await fs2.readdir(join33(dir, filepath));
+      const names = await fs2.readdir(join42(dir, filepath));
       if (names === null)
         return null;
-      return names.map((name) => join33(filepath, name));
+      return names.map((name) => join42(filepath, name));
     }
     async type(entry) {
       if (entry._type === false) {
@@ -9997,21 +10002,21 @@ gpgsig`));
     async stat(entry) {
       if (entry._stat === false) {
         const { fs: fs2, dir } = this;
-        let stat22 = await fs2.lstat(`${dir}/${entry._fullpath}`);
-        if (!stat22) {
+        let stat3 = await fs2.lstat(`${dir}/${entry._fullpath}`);
+        if (!stat3) {
           throw new Error(`ENOENT: no such file or directory, lstat '${entry._fullpath}'`);
         }
-        let type = stat22.isDirectory() ? "tree" : "blob";
-        if (type === "blob" && !stat22.isFile() && !stat22.isSymbolicLink()) {
+        let type = stat3.isDirectory() ? "tree" : "blob";
+        if (type === "blob" && !stat3.isFile() && !stat3.isSymbolicLink()) {
           type = "special";
         }
         entry._type = type;
-        stat22 = normalizeStats(stat22);
-        entry._mode = stat22.mode;
-        if (stat22.size === -1 && entry._actualSize) {
-          stat22.size = entry._actualSize;
+        stat3 = normalizeStats(stat3);
+        entry._mode = stat3.mode;
+        if (stat3.size === -1 && entry._actualSize) {
+          stat3.size = entry._actualSize;
         }
-        entry._stat = stat22;
+        entry._stat = stat3;
       }
       return entry._stat;
     }
@@ -10193,11 +10198,11 @@ gpgsig`));
       await fs2.rm(filepath);
     } else if (entries.length) {
       await Promise.all(entries.map((entry) => {
-        const subpath = join33(filepath, entry);
-        return fs2.lstat(subpath).then((stat22) => {
-          if (!stat22)
+        const subpath = join42(filepath, entry);
+        return fs2.lstat(subpath).then((stat3) => {
+          if (!stat3)
             return;
-          return stat22.isDirectory() ? rmRecursive(fs2, subpath) : fs2.rm(subpath);
+          return stat3.isDirectory() ? rmRecursive(fs2, subpath) : fs2.rm(subpath);
         });
       })).then(() => fs2.rmdir(filepath));
     } else {
@@ -10415,7 +10420,7 @@ gpgsig`));
       return dotgit;
     } else if (dotgitStat.isFile()) {
       return fsp._readFile(dotgit, "utf8").then((contents) => contents.trimRight().substr(8)).then((submoduleGitdir) => {
-        const gitdir = join33(dirname22(dotgit), submoduleGitdir);
+        const gitdir = join42(dirname22(dotgit), submoduleGitdir);
         return gitdir;
       });
     } else {
@@ -10440,7 +10445,7 @@ gpgsig`));
   async function abortMerge({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     commit: commit2 = "HEAD",
     cache = {}
   }) {
@@ -10509,19 +10514,19 @@ gpgsig`));
   }
 
   class GitIgnoreManager {
-    static async isIgnored({ fs: fs2, dir, gitdir = join33(dir, ".git"), filepath }) {
+    static async isIgnored({ fs: fs2, dir, gitdir = join42(dir, ".git"), filepath }) {
       if (basename(filepath) === ".git")
         return true;
       if (filepath === ".")
         return false;
       let excludes = "";
-      const excludesFile = join33(gitdir, "info", "exclude");
+      const excludesFile = join42(gitdir, "info", "exclude");
       if (await fs2.exists(excludesFile)) {
         excludes = await fs2.read(excludesFile, "utf8");
       }
       const pairs = [
         {
-          gitignore: join33(dir, ".gitignore"),
+          gitignore: join42(dir, ".gitignore"),
           filepath
         }
       ];
@@ -10530,7 +10535,7 @@ gpgsig`));
         const folder = pieces.slice(0, i).join("/");
         const file = pieces.slice(i).join("/");
         pairs.push({
-          gitignore: join33(dir, folder, ".gitignore"),
+          gitignore: join42(dir, folder, ".gitignore"),
           filepath: file
         });
       }
@@ -10619,7 +10624,7 @@ gpgsig`));
   async function add({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     cache = {},
     force = false,
@@ -10673,17 +10678,17 @@ gpgsig`));
         if (ignored)
           return;
       }
-      const stats = await fs2.lstat(join33(dir, currentFilepath));
+      const stats = await fs2.lstat(join42(dir, currentFilepath));
       if (!stats)
         throw new NotFoundError(currentFilepath);
       if (stats.isDirectory()) {
-        const children = await fs2.readdir(join33(dir, currentFilepath));
+        const children = await fs2.readdir(join42(dir, currentFilepath));
         if (parallel) {
           const promises2 = children.map((child) => addToIndex({
             dir,
             gitdir,
             fs: fs2,
-            filepath: [join33(currentFilepath, child)],
+            filepath: [join42(currentFilepath, child)],
             index: index2,
             force,
             parallel,
@@ -10696,7 +10701,7 @@ gpgsig`));
               dir,
               gitdir,
               fs: fs2,
-              filepath: [join33(currentFilepath, child)],
+              filepath: [join42(currentFilepath, child)],
               index: index2,
               force,
               parallel,
@@ -10705,7 +10710,7 @@ gpgsig`));
           }
         }
       } else {
-        const object = stats.isSymbolicLink() ? await fs2.readlink(join33(dir, currentFilepath)).then(posixifyPathBuffer) : await fs2.read(join33(dir, currentFilepath), { autocrlf });
+        const object = stats.isSymbolicLink() ? await fs2.readlink(join42(dir, currentFilepath)).then(posixifyPathBuffer) : await fs2.read(join42(dir, currentFilepath), { autocrlf });
         if (object === null)
           throw new NotFoundError(currentFilepath);
         const oid = await _writeObject({ fs: fs2, gitdir, type: "blob", object });
@@ -11101,7 +11106,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "refs/notes/commits",
     oid,
     note,
@@ -11176,7 +11181,7 @@ gpgsig`));
   async function addRemote({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     remote,
     url,
     force = false
@@ -11246,7 +11251,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     tagger: _tagger,
     message = ref,
@@ -11327,7 +11332,7 @@ gpgsig`));
   async function branch({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     object,
     checkout: checkout2 = false,
@@ -11898,7 +11903,7 @@ gpgsig`));
     onProgress,
     onPostCheckout,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     remote = "origin",
     ref: _ref,
     filepaths,
@@ -12311,7 +12316,7 @@ gpgsig`));
     static async read({ fs: fs2, gitdir }) {
       if (lock$2 === null)
         lock$2 = new AsyncLock;
-      const filepath = join33(gitdir, "shallow");
+      const filepath = join42(gitdir, "shallow");
       const oids = new Set;
       await lock$2.acquire(filepath, async function() {
         const text = await fs2.read(filepath, { encoding: "utf8" });
@@ -12327,7 +12332,7 @@ gpgsig`));
     static async write({ fs: fs2, gitdir, oids }) {
       if (lock$2 === null)
         lock$2 = new AsyncLock;
-      const filepath = join33(gitdir, "shallow");
+      const filepath = join42(gitdir, "shallow");
       if (oids.size > 0) {
         const text = [...oids].join(`
 `) + `
@@ -12355,7 +12360,7 @@ gpgsig`));
     oid,
     getExternalRefDelta
   }) {
-    let list = await fs2.readdir(join33(gitdir, "objects/pack"));
+    let list = await fs2.readdir(join42(gitdir, "objects/pack"));
     list = list.filter((x) => x.endsWith(".idx"));
     for (const filename of list) {
       const indexFile = `${gitdir}/objects/pack/${filename}`;
@@ -12644,7 +12649,7 @@ gpgsig`));
     depth = null,
     since = null,
     exclude = [],
-    relative = false,
+    relative: relative2 = false,
     tags = false,
     singleBranch = false,
     headers = {},
@@ -12692,7 +12697,7 @@ gpgsig`));
     if (exclude.length > 0 && !remoteHTTP.capabilities.has("deepen-not")) {
       throw new RemoteCapabilityError("deepen-not", "exclude");
     }
-    if (relative === true && !remoteHTTP.capabilities.has("deepen-relative")) {
+    if (relative2 === true && !remoteHTTP.capabilities.has("deepen-relative")) {
       throw new RemoteCapabilityError("deepen-relative", "relative");
     }
     const { oid, fullref } = GitRefManager.resolveAgainstMap({
@@ -12712,7 +12717,7 @@ gpgsig`));
       "ofs-delta",
       `agent=${pkg.agent}`
     ]);
-    if (relative)
+    if (relative2)
       capabilities.push("deepen-relative");
     const wants = singleBranch ? [oid] : remoteRefs.values();
     const haveRefs = singleBranch ? [ref] : await GitRefManager.listRefs({
@@ -12871,7 +12876,7 @@ gpgsig`));
     }
     if (packfileSha !== "" && !emptyPackfile(packfile)) {
       res.packfile = `objects/pack/pack-${packfileSha}.pack`;
-      const fullpath = join33(gitdir, res.packfile);
+      const fullpath = join42(gitdir, res.packfile);
       await fs2.write(fullpath, packfile);
       const getExternalRefDelta = (oid2) => _readObject({ fs: fs2, cache, gitdir, oid: oid2 });
       const idx = await GitPackIndex.fromPack({
@@ -12887,7 +12892,7 @@ gpgsig`));
     fs: fs2,
     bare = false,
     dir,
-    gitdir = bare ? dir : join33(dir, ".git"),
+    gitdir = bare ? dir : join42(dir, ".git"),
     defaultBranch = "master"
   }) {
     if (await fs2.exists(gitdir + "/config"))
@@ -12934,7 +12939,7 @@ gpgsig`));
     depth,
     since,
     exclude,
-    relative,
+    relative: relative2,
     singleBranch,
     noCheckout,
     noTags,
@@ -12966,7 +12971,7 @@ gpgsig`));
         depth,
         since,
         exclude,
-        relative,
+        relative: relative2,
         singleBranch,
         headers,
         tags: !noTags
@@ -13005,7 +13010,7 @@ gpgsig`));
     onAuthFailure,
     onPostCheckout,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     url,
     corsProxy = undefined,
     ref = undefined,
@@ -13013,7 +13018,7 @@ gpgsig`));
     depth = undefined,
     since = undefined,
     exclude = [],
-    relative = false,
+    relative: relative2 = false,
     singleBranch = false,
     noCheckout = false,
     noTags = false,
@@ -13051,7 +13056,7 @@ gpgsig`));
         depth,
         since,
         exclude,
-        relative,
+        relative: relative2,
         singleBranch,
         noCheckout,
         noTags,
@@ -13068,7 +13073,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     message,
     author,
     committer,
@@ -13115,7 +13120,7 @@ gpgsig`));
   async function currentBranch({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     fullname = false,
     test = false
   }) {
@@ -13156,7 +13161,7 @@ gpgsig`));
   async function deleteBranch({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref
   }) {
     try {
@@ -13174,7 +13179,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function deleteRef({ fs: fs2, dir, gitdir = join33(dir, ".git"), ref }) {
+  async function deleteRef({ fs: fs2, dir, gitdir = join42(dir, ".git"), ref }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("ref", ref);
@@ -13194,7 +13199,7 @@ gpgsig`));
   async function deleteRemote({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     remote
   }) {
     try {
@@ -13216,7 +13221,7 @@ gpgsig`));
     ref = ref.startsWith("refs/tags/") ? ref : `refs/tags/${ref}`;
     await GitRefManager.deleteRef({ fs: fs2, gitdir, ref });
   }
-  async function deleteTag({ fs: fs2, dir, gitdir = join33(dir, ".git"), ref }) {
+  async function deleteTag({ fs: fs2, dir, gitdir = join42(dir, ".git"), ref }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("ref", ref);
@@ -13245,7 +13250,7 @@ gpgsig`));
     getExternalRefDelta
   }) {
     const results = [];
-    let list = await fs2.readdir(join33(gitdir, "objects/pack"));
+    let list = await fs2.readdir(join42(gitdir, "objects/pack"));
     list = list.filter((x) => x.endsWith(".idx"));
     for (const filename of list) {
       const indexFile = `${gitdir}/objects/pack/${filename}`;
@@ -13290,7 +13295,7 @@ gpgsig`));
   async function expandOid({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     cache = {}
   }) {
@@ -13311,7 +13316,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function expandRef({ fs: fs2, dir, gitdir = join33(dir, ".git"), ref }) {
+  async function expandRef({ fs: fs2, dir, gitdir = join42(dir, ".git"), ref }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -13398,7 +13403,7 @@ gpgsig`));
     fs: fs2,
     cache,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     index: index2,
     ourOid,
     baseOid,
@@ -13868,7 +13873,7 @@ gpgsig`));
     onAuthSuccess,
     onAuthFailure,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     url,
     remote,
@@ -13926,7 +13931,7 @@ gpgsig`));
     onAuthSuccess,
     onAuthFailure,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     remote,
     remoteRef,
@@ -13935,7 +13940,7 @@ gpgsig`));
     depth = null,
     since = null,
     exclude = [],
-    relative = false,
+    relative: relative2 = false,
     tags = false,
     singleBranch = false,
     headers = {},
@@ -13967,7 +13972,7 @@ gpgsig`));
         depth,
         since,
         exclude,
-        relative,
+        relative: relative2,
         tags,
         singleBranch,
         headers,
@@ -13982,7 +13987,7 @@ gpgsig`));
   async function findMergeBase({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oids,
     cache = {}
   }) {
@@ -14004,7 +14009,7 @@ gpgsig`));
     }
   }
   async function _findRoot({ fs: fs2, filepath }) {
-    if (await fs2.exists(join33(filepath, ".git"))) {
+    if (await fs2.exists(join42(filepath, ".git"))) {
       return filepath;
     } else {
       const parent = dirname22(filepath);
@@ -14024,7 +14029,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function getConfig({ fs: fs2, dir, gitdir = join33(dir, ".git"), path }) {
+  async function getConfig({ fs: fs2, dir, gitdir = join42(dir, ".git"), path }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -14048,7 +14053,7 @@ gpgsig`));
   async function getConfigAll({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     path
   }) {
     try {
@@ -14242,7 +14247,7 @@ gpgsig`));
     filepath
   }) {
     try {
-      filepath = join33(dir, filepath);
+      filepath = join42(dir, filepath);
       const pack = await fs2.read(filepath);
       const getExternalRefDelta = (oid) => _readObject({ fs: fs2, cache, gitdir, oid });
       const idx = await GitPackIndex.fromPack({
@@ -14263,7 +14268,7 @@ gpgsig`));
     fs: fs2,
     onProgress,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     cache = {}
   }) {
@@ -14291,7 +14296,7 @@ gpgsig`));
     fs: fs2,
     bare = false,
     dir,
-    gitdir = bare ? dir : join33(dir, ".git"),
+    gitdir = bare ? dir : join42(dir, ".git"),
     defaultBranch = "master"
   }) {
     try {
@@ -14367,7 +14372,7 @@ gpgsig`));
   async function isDescendent({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     ancestor,
     depth = -1,
@@ -14396,7 +14401,7 @@ gpgsig`));
   async function isIgnored({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath
   }) {
     try {
@@ -14420,7 +14425,7 @@ gpgsig`));
   async function listBranches({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     remote
   }) {
     try {
@@ -14474,17 +14479,17 @@ gpgsig`));
           gitdir,
           oid: entry.oid,
           filenames,
-          prefix: join33(prefix, entry.path)
+          prefix: join42(prefix, entry.path)
         });
       } else {
-        filenames.push(join33(prefix, entry.path));
+        filenames.push(join42(prefix, entry.path));
       }
     }
   }
   async function listFiles({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     cache = {}
   }) {
@@ -14528,7 +14533,7 @@ gpgsig`));
   async function listNotes({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "refs/notes/commits",
     cache = {}
   }) {
@@ -14552,7 +14557,7 @@ gpgsig`));
   async function listRefs({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath
   }) {
     try {
@@ -14575,7 +14580,7 @@ gpgsig`));
     }));
     return remotes;
   }
-  async function listRemotes({ fs: fs2, dir, gitdir = join33(dir, ".git") }) {
+  async function listRemotes({ fs: fs2, dir, gitdir = join42(dir, ".git") }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -14680,7 +14685,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function listTags({ fs: fs2, dir, gitdir = join33(dir, ".git") }) {
+  async function listTags({ fs: fs2, dir, gitdir = join42(dir, ".git") }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -14736,7 +14741,7 @@ gpgsig`));
     const walks = tree.entries().map(function(entry) {
       let result;
       if (entry.oid === fileId) {
-        result = join33(parentPath, entry.path);
+        result = join42(parentPath, entry.path);
         filepaths.push(result);
       } else if (entry.type === "tree") {
         result = _readObject({
@@ -14753,7 +14758,7 @@ gpgsig`));
             fileId,
             oid,
             filepaths,
-            parentPath: join33(parentPath, entry.path)
+            parentPath: join42(parentPath, entry.path)
           });
         });
       }
@@ -14888,7 +14893,7 @@ gpgsig`));
   async function log({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     ref = "HEAD",
     depth,
@@ -14923,7 +14928,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ours,
     theirs,
     fastForward: fastForward2 = true,
@@ -15000,7 +15005,7 @@ gpgsig`));
     fs: fs2,
     cache,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oids
   }) {
     const hash = new Hash;
@@ -15043,7 +15048,7 @@ gpgsig`));
     const packfileSha = packfile.slice(-20).toString("hex");
     const filename = `pack-${packfileSha}.pack`;
     if (write) {
-      await fs2.write(join33(gitdir, `objects/pack/${filename}`), packfile);
+      await fs2.write(join42(gitdir, `objects/pack/${filename}`), packfile);
       return { filename };
     }
     return {
@@ -15054,7 +15059,7 @@ gpgsig`));
   async function packObjects({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oids,
     write = false,
     cache = {}
@@ -15086,7 +15091,7 @@ gpgsig`));
     onAuthSuccess,
     onAuthFailure,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     url,
     remote,
@@ -15158,7 +15163,7 @@ gpgsig`));
     fs: fs2,
     cache,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     start,
     finish
   }) {
@@ -15205,7 +15210,7 @@ gpgsig`));
     fs: fs2,
     cache,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oids
   }) {
     const visited = new Set;
@@ -15498,7 +15503,7 @@ gpgsig`));
     onAuthFailure,
     onPrePush,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     remoteRef,
     remote = "origin",
@@ -15572,7 +15577,7 @@ gpgsig`));
   async function readBlob({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     filepath,
     cache = {}
@@ -15598,7 +15603,7 @@ gpgsig`));
   async function readCommit({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     cache = {}
   }) {
@@ -15639,7 +15644,7 @@ gpgsig`));
   async function readNote({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "refs/notes/commits",
     oid,
     cache = {}
@@ -15666,7 +15671,7 @@ gpgsig`));
   async function readObject({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     format = "parsed",
     filepath = undefined,
@@ -15751,7 +15756,7 @@ gpgsig`));
   async function readTag({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     cache = {}
   }) {
@@ -15775,7 +15780,7 @@ gpgsig`));
   async function readTree({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     filepath = undefined,
     cache = {}
@@ -15801,7 +15806,7 @@ gpgsig`));
   async function remove({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     cache = {}
   }) {
@@ -15871,7 +15876,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "refs/notes/commits",
     oid,
     author: _author,
@@ -15961,7 +15966,7 @@ gpgsig`));
   async function renameBranch({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     oldref,
     checkout: checkout2 = false
@@ -15991,7 +15996,7 @@ gpgsig`));
   async function resetIndex({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     ref,
     cache = {}
@@ -16038,7 +16043,7 @@ gpgsig`));
         gid: 0,
         size: 0
       };
-      const object = dir && await fs2.read(join33(dir, filepath));
+      const object = dir && await fs2.read(join42(dir, filepath));
       if (object) {
         workdirOid = await hashObject$1({
           gitdir: updatedGitdir,
@@ -16046,7 +16051,7 @@ gpgsig`));
           object
         });
         if (oid === workdirOid) {
-          stats = await fs2.lstat(join33(dir, filepath));
+          stats = await fs2.lstat(join42(dir, filepath));
         }
       }
       await GitIndexManager.acquire({ fs: fs2, gitdir: updatedGitdir, cache }, async function(index2) {
@@ -16063,7 +16068,7 @@ gpgsig`));
   async function resolveRef({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     depth
   }) {
@@ -16088,7 +16093,7 @@ gpgsig`));
   async function setConfig({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     path,
     value,
     append = false
@@ -16157,7 +16162,7 @@ gpgsig`));
     return lock$3.acquire(ref, callback);
   }
   async function checkAndWriteBlob(fs2, gitdir, dir, filepath, oid = null) {
-    const currentFilepath = join33(dir, filepath);
+    const currentFilepath = join42(dir, filepath);
     const stats = await fs2.lstat(currentFilepath);
     if (!stats)
       throw new NotFoundError(currentFilepath);
@@ -16320,7 +16325,7 @@ gpgsig`));
               stageUpdated.push({
                 filepath,
                 oid,
-                stats: await fs2.lstat(join33(dir, filepath))
+                stats: await fs2.lstat(join42(dir, filepath))
               });
             return {
               method: "write",
@@ -16333,7 +16338,7 @@ gpgsig`));
     });
     await acquireLock$1({ fs: fs2, gitdir, dirRemoved, ops }, async () => {
       for (const op of ops) {
-        const currentFilepath = join33(dir, op.filepath);
+        const currentFilepath = join42(dir, op.filepath);
         switch (op.method) {
           case "rmdir":
             await fs2.rmdir(currentFilepath);
@@ -16369,7 +16374,7 @@ gpgsig`));
   }
 
   class GitStashManager {
-    constructor({ fs: fs2, dir, gitdir = join33(dir, ".git") }) {
+    constructor({ fs: fs2, dir, gitdir = join42(dir, ".git") }) {
       Object.assign(this, {
         fs: fs2,
         dir,
@@ -16384,10 +16389,10 @@ gpgsig`));
       return "logs/refs/stash";
     }
     get refStashPath() {
-      return join33(this.gitdir, GitStashManager.refStash);
+      return join42(this.gitdir, GitStashManager.refStash);
     }
     get refLogsStashPath() {
-      return join33(this.gitdir, GitStashManager.refLogsStash);
+      return join42(this.gitdir, GitStashManager.refLogsStash);
     }
     async getAuthor() {
       if (!this._author) {
@@ -16632,7 +16637,7 @@ gpgsig`));
   async function stash({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     op = "push",
     message = "",
     refIdx = 0
@@ -16655,7 +16660,7 @@ gpgsig`));
       const _fs = new FileSystem(fs2);
       const updatedGitdir = await discoverGitdir({ fsp: _fs, dotgit: gitdir });
       const folders = ["refs", "logs", "logs/refs"];
-      folders.map((f) => join33(updatedGitdir, f)).forEach(async (folder) => {
+      folders.map((f) => join42(updatedGitdir, f)).forEach(async (folder) => {
         if (!await _fs.exists(folder)) {
           await _fs.mkdir(folder);
         }
@@ -16682,7 +16687,7 @@ gpgsig`));
   async function status({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     cache = {}
   }) {
@@ -16716,7 +16721,7 @@ gpgsig`));
         }
         return null;
       });
-      const stats = await fs2.lstat(join33(dir, filepath));
+      const stats = await fs2.lstat(join42(dir, filepath));
       const H = treeOid !== null;
       const I = indexEntry !== null;
       const W = stats !== null;
@@ -16724,7 +16729,7 @@ gpgsig`));
         if (I && !compareStats(indexEntry, stats)) {
           return indexEntry.oid;
         } else {
-          const object = await fs2.read(join33(dir, filepath));
+          const object = await fs2.read(join42(dir, filepath));
           const workdirOid = await hashObject$1({
             gitdir: updatedGitdir,
             type: "blob",
@@ -16817,7 +16822,7 @@ gpgsig`));
   async function statusMatrix({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "HEAD",
     filepaths = ["."],
     filter,
@@ -16894,7 +16899,7 @@ gpgsig`));
   async function tag({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     object,
     force = false
@@ -16926,7 +16931,7 @@ gpgsig`));
   async function updateIndex$1({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     cache = {},
     filepath,
     oid,
@@ -16944,7 +16949,7 @@ gpgsig`));
       if (remove2) {
         return await GitIndexManager.acquire({ fs: fs2, gitdir: updatedGitdir, cache }, async function(index2) {
           if (!force) {
-            const fileStats2 = await fs2.lstat(join33(dir, filepath));
+            const fileStats2 = await fs2.lstat(join42(dir, filepath));
             if (fileStats2) {
               if (fileStats2.isDirectory()) {
                 throw new InvalidFilepathError("directory");
@@ -16961,7 +16966,7 @@ gpgsig`));
       }
       let fileStats;
       if (!oid) {
-        fileStats = await fs2.lstat(join33(dir, filepath));
+        fileStats = await fs2.lstat(join42(dir, filepath));
         if (!fileStats) {
           throw new NotFoundError(`file at "${filepath}" on disk and "remove" not set`);
         }
@@ -16976,7 +16981,7 @@ gpgsig`));
         let stats;
         if (!oid) {
           stats = fileStats;
-          const object = stats.isSymbolicLink() ? await fs2.readlink(join33(dir, filepath)) : await fs2.read(join33(dir, filepath));
+          const object = stats.isSymbolicLink() ? await fs2.readlink(join42(dir, filepath)) : await fs2.read(join42(dir, filepath));
           oid = await _writeObject({
             fs: fs2,
             gitdir: updatedGitdir,
@@ -17019,7 +17024,7 @@ gpgsig`));
   async function walk({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     trees,
     map,
     reduce,
@@ -17047,7 +17052,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function writeBlob({ fs: fs2, dir, gitdir = join33(dir, ".git"), blob }) {
+  async function writeBlob({ fs: fs2, dir, gitdir = join42(dir, ".git"), blob }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -17069,7 +17074,7 @@ gpgsig`));
   async function writeCommit({
     fs: fs2,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     commit: commit2
   }) {
     try {
@@ -17091,7 +17096,7 @@ gpgsig`));
   async function writeObject({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     type,
     object,
     format = "parsed",
@@ -17137,7 +17142,7 @@ gpgsig`));
   async function writeRef({
     fs: _fs,
     dir,
-    gitdir = join33(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     value,
     force = false,
@@ -17192,7 +17197,7 @@ gpgsig`));
     });
     return oid;
   }
-  async function writeTag({ fs: fs2, dir, gitdir = join33(dir, ".git"), tag: tag2 }) {
+  async function writeTag({ fs: fs2, dir, gitdir = join42(dir, ".git"), tag: tag2 }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -17209,7 +17214,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function writeTree({ fs: fs2, dir, gitdir = join33(dir, ".git"), tree }) {
+  async function writeTree({ fs: fs2, dir, gitdir = join42(dir, ".git"), tree }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -20667,13 +20672,13 @@ var require_readable = __commonJS((exports, module) => {
     return state[kPaused] === true || state.flowing === false;
   };
   Readable.prototype.setEncoding = function(enc) {
-    const decoder3 = new StringDecoder(enc);
-    this._readableState.decoder = decoder3;
+    const decoder4 = new StringDecoder(enc);
+    this._readableState.decoder = decoder4;
     this._readableState.encoding = this._readableState.decoder.encoding;
     const buffer = this._readableState.buffer;
     let content = "";
     for (const data of buffer) {
-      content += decoder3.write(data);
+      content += decoder4.write(data);
     }
     buffer.clear();
     if (content !== "")
@@ -25372,7 +25377,7 @@ class FileTransportHandler2 {
     const entries = await readdir2(currentPath, { withFileTypes: true });
     const results = [];
     for (const entry of entries) {
-      const fullPath = join3(currentPath, entry.name);
+      const fullPath = join2(currentPath, entry.name);
       const relativePath = fullPath.substring(basePath.length + 1);
       if (entry.isDirectory()) {
         const subEntries = await this.listRecursive(basePath, fullPath);
@@ -25720,6 +25725,1275 @@ class ARP2 {
 function createARP2(config) {
   return new ARP2(config);
 }
+
+class ResourceXError3 extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResourceXError";
+  }
+}
+
+class ManifestError2 extends ResourceXError3 {
+  constructor(message) {
+    super(message);
+    this.name = "ManifestError";
+  }
+}
+
+class ContentError2 extends ResourceXError3 {
+  constructor(message) {
+    super(message);
+    this.name = "ContentError";
+  }
+}
+
+class RXLImpl3 {
+  domain;
+  path;
+  name;
+  type;
+  version;
+  constructor(parts) {
+    this.domain = parts.domain;
+    this.path = parts.path;
+    this.name = parts.name;
+    this.type = parts.type;
+    this.version = parts.version;
+  }
+  toString() {
+    let result = "";
+    if (this.domain) {
+      result += this.domain + "/";
+      if (this.path) {
+        result += this.path + "/";
+      }
+    }
+    result += this.name;
+    if (this.type) {
+      result += "." + this.type;
+    }
+    if (this.version) {
+      result += "@" + this.version;
+    }
+    return result;
+  }
+}
+function isDomain3(str) {
+  if (str === "localhost")
+    return true;
+  return str.includes(".");
+}
+function parseRXL3(locator) {
+  let remaining = locator;
+  let version;
+  let type;
+  let domain;
+  let path;
+  let name;
+  const atIndex = remaining.indexOf("@");
+  if (atIndex !== -1) {
+    version = remaining.slice(atIndex + 1);
+    remaining = remaining.slice(0, atIndex);
+  }
+  const segments = remaining.split("/");
+  if (segments.length > 1 && isDomain3(segments[0])) {
+    domain = segments[0];
+    const lastSegment = segments[segments.length - 1];
+    if (segments.length > 2) {
+      path = segments.slice(1, -1).join("/");
+    }
+    remaining = lastSegment;
+  } else {
+    remaining = segments.join("/");
+  }
+  const dotIndex = remaining.lastIndexOf(".");
+  if (dotIndex !== -1) {
+    type = remaining.slice(dotIndex + 1);
+    name = remaining.slice(0, dotIndex);
+  } else {
+    name = remaining;
+  }
+  return new RXLImpl3({ domain, path, name, type, version });
+}
+
+class RXMImpl2 {
+  domain;
+  path;
+  name;
+  type;
+  version;
+  constructor(data) {
+    this.domain = data.domain;
+    this.path = data.path;
+    this.name = data.name;
+    this.type = data.type;
+    this.version = data.version;
+  }
+  toLocator() {
+    let result = this.domain + "/";
+    if (this.path) {
+      result += this.path + "/";
+    }
+    result += this.name;
+    result += "." + this.type;
+    result += "@" + this.version;
+    return result;
+  }
+  toJSON() {
+    const json = {
+      domain: this.domain,
+      name: this.name,
+      type: this.type,
+      version: this.version
+    };
+    if (this.path !== undefined) {
+      json.path = this.path;
+    }
+    return json;
+  }
+}
+function createRXM2(data) {
+  if (!data.domain) {
+    throw new ManifestError2("domain is required");
+  }
+  if (!data.name) {
+    throw new ManifestError2("name is required");
+  }
+  if (!data.type) {
+    throw new ManifestError2("type is required");
+  }
+  if (!data.version) {
+    throw new ManifestError2("version is required");
+  }
+  return new RXMImpl2({
+    domain: data.domain,
+    path: data.path,
+    name: data.name,
+    type: data.type,
+    version: data.version
+  });
+}
+var BLOCK_SIZE3 = 512;
+var BLOCK_SIZE_MASK2 = 511;
+var DEFAULT_FILE_MODE2 = 420;
+var DEFAULT_DIR_MODE2 = 493;
+var USTAR_NAME_OFFSET2 = 0;
+var USTAR_NAME_SIZE2 = 100;
+var USTAR_MODE_OFFSET2 = 100;
+var USTAR_MODE_SIZE2 = 8;
+var USTAR_UID_OFFSET2 = 108;
+var USTAR_UID_SIZE2 = 8;
+var USTAR_GID_OFFSET2 = 116;
+var USTAR_GID_SIZE2 = 8;
+var USTAR_SIZE_OFFSET2 = 124;
+var USTAR_SIZE_SIZE2 = 12;
+var USTAR_MTIME_OFFSET2 = 136;
+var USTAR_MTIME_SIZE2 = 12;
+var USTAR_CHECKSUM_OFFSET2 = 148;
+var USTAR_CHECKSUM_SIZE2 = 8;
+var USTAR_TYPEFLAG_OFFSET2 = 156;
+var USTAR_TYPEFLAG_SIZE2 = 1;
+var USTAR_LINKNAME_OFFSET2 = 157;
+var USTAR_LINKNAME_SIZE2 = 100;
+var USTAR_MAGIC_OFFSET2 = 257;
+var USTAR_MAGIC_SIZE2 = 6;
+var USTAR_VERSION_OFFSET2 = 263;
+var USTAR_VERSION_SIZE2 = 2;
+var USTAR_UNAME_OFFSET2 = 265;
+var USTAR_UNAME_SIZE2 = 32;
+var USTAR_GNAME_OFFSET2 = 297;
+var USTAR_GNAME_SIZE2 = 32;
+var USTAR_PREFIX_OFFSET2 = 345;
+var USTAR_PREFIX_SIZE2 = 155;
+var USTAR_VERSION2 = "00";
+var USTAR_MAX_UID_GID2 = 2097151;
+var USTAR_MAX_SIZE2 = 8589934591;
+var FILE2 = "file";
+var LINK2 = "link";
+var SYMLINK2 = "symlink";
+var DIRECTORY2 = "directory";
+var TYPEFLAG2 = {
+  file: "0",
+  link: "1",
+  symlink: "2",
+  "character-device": "3",
+  "block-device": "4",
+  directory: "5",
+  fifo: "6",
+  "pax-header": "x",
+  "pax-global-header": "g",
+  "gnu-long-name": "L",
+  "gnu-long-link-name": "K"
+};
+var FLAGTYPE2 = {
+  "0": FILE2,
+  "1": LINK2,
+  "2": SYMLINK2,
+  "3": "character-device",
+  "4": "block-device",
+  "5": DIRECTORY2,
+  "6": "fifo",
+  x: "pax-header",
+  g: "pax-global-header",
+  L: "gnu-long-name",
+  K: "gnu-long-link-name"
+};
+var ZERO_BLOCK3 = new Uint8Array(BLOCK_SIZE3);
+var EMPTY3 = new Uint8Array(0);
+var encoder3 = new TextEncoder;
+var decoder3 = new TextDecoder;
+function writeString2(view, offset, size, value) {
+  if (value)
+    encoder3.encodeInto(value, view.subarray(offset, offset + size));
+}
+function writeOctal2(view, offset, size, value) {
+  if (value === undefined)
+    return;
+  const octalString = value.toString(8).padStart(size - 1, "0");
+  encoder3.encodeInto(octalString, view.subarray(offset, offset + size - 1));
+}
+function readString2(view, offset, size) {
+  const end = view.indexOf(0, offset);
+  const sliceEnd = end === -1 || end > offset + size ? offset + size : end;
+  return decoder3.decode(view.subarray(offset, sliceEnd));
+}
+function readOctal2(view, offset, size) {
+  let value = 0;
+  const end = offset + size;
+  for (let i = offset;i < end; i++) {
+    const charCode = view[i];
+    if (charCode === 0)
+      break;
+    if (charCode === 32)
+      continue;
+    value = value * 8 + (charCode - 48);
+  }
+  return value;
+}
+function readNumeric2(view, offset, size) {
+  if (view[offset] & 128) {
+    let result = 0;
+    result = view[offset] & 127;
+    for (let i = 1;i < size; i++)
+      result = result * 256 + view[offset + i];
+    if (!Number.isSafeInteger(result))
+      throw new Error("TAR number too large");
+    return result;
+  }
+  return readOctal2(view, offset, size);
+}
+var isBodyless2 = (header) => header.type === DIRECTORY2 || header.type === SYMLINK2 || header.type === LINK2;
+async function normalizeBody2(body) {
+  if (body === null || body === undefined)
+    return EMPTY3;
+  if (body instanceof Uint8Array)
+    return body;
+  if (typeof body === "string")
+    return encoder3.encode(body);
+  if (body instanceof ArrayBuffer)
+    return new Uint8Array(body);
+  if (body instanceof Blob)
+    return new Uint8Array(await body.arrayBuffer());
+  throw new TypeError("Unsupported content type for entry body.");
+}
+function transformHeader2(header, options) {
+  const { strip, filter, map } = options;
+  if (!strip && !filter && !map)
+    return header;
+  const h = { ...header };
+  if (strip && strip > 0) {
+    const components = h.name.split("/").filter(Boolean);
+    if (strip >= components.length)
+      return null;
+    const newName = components.slice(strip).join("/");
+    h.name = h.type === DIRECTORY2 && !newName.endsWith("/") ? `${newName}/` : newName;
+    if (h.linkname?.startsWith("/")) {
+      const linkComponents = h.linkname.split("/").filter(Boolean);
+      h.linkname = strip >= linkComponents.length ? "/" : `/${linkComponents.slice(strip).join("/")}`;
+    }
+  }
+  if (filter?.(h) === false)
+    return null;
+  const result = map ? map(h) : h;
+  if (result && (!result.name || !result.name.trim() || result.name === "." || result.name === "/"))
+    return null;
+  return result;
+}
+var CHECKSUM_SPACE2 = 32;
+var ASCII_ZERO2 = 48;
+function validateChecksum2(block) {
+  const stored = readOctal2(block, USTAR_CHECKSUM_OFFSET2, USTAR_CHECKSUM_SIZE2);
+  let sum = 0;
+  for (let i = 0;i < block.length; i++)
+    if (i >= USTAR_CHECKSUM_OFFSET2 && i < USTAR_CHECKSUM_OFFSET2 + USTAR_CHECKSUM_SIZE2)
+      sum += CHECKSUM_SPACE2;
+    else
+      sum += block[i];
+  return stored === sum;
+}
+function writeChecksum2(block) {
+  block.fill(CHECKSUM_SPACE2, USTAR_CHECKSUM_OFFSET2, USTAR_CHECKSUM_OFFSET2 + USTAR_CHECKSUM_SIZE2);
+  let checksum = 0;
+  for (const byte of block)
+    checksum += byte;
+  for (let i = USTAR_CHECKSUM_OFFSET2 + 6 - 1;i >= USTAR_CHECKSUM_OFFSET2; i--) {
+    block[i] = (checksum & 7) + ASCII_ZERO2;
+    checksum >>= 3;
+  }
+  block[USTAR_CHECKSUM_OFFSET2 + 6] = 0;
+  block[USTAR_CHECKSUM_OFFSET2 + 7] = CHECKSUM_SPACE2;
+}
+function generatePax2(header) {
+  const paxRecords = {};
+  if (header.name.length > USTAR_NAME_SIZE2) {
+    if (findUstarSplit2(header.name) === null)
+      paxRecords.path = header.name;
+  }
+  if (header.linkname && header.linkname.length > USTAR_NAME_SIZE2)
+    paxRecords.linkpath = header.linkname;
+  if (header.uname && header.uname.length > USTAR_UNAME_SIZE2)
+    paxRecords.uname = header.uname;
+  if (header.gname && header.gname.length > USTAR_GNAME_SIZE2)
+    paxRecords.gname = header.gname;
+  if (header.uid != null && header.uid > USTAR_MAX_UID_GID2)
+    paxRecords.uid = String(header.uid);
+  if (header.gid != null && header.gid > USTAR_MAX_UID_GID2)
+    paxRecords.gid = String(header.gid);
+  if (header.size != null && header.size > USTAR_MAX_SIZE2)
+    paxRecords.size = String(header.size);
+  if (header.pax)
+    Object.assign(paxRecords, header.pax);
+  const paxEntries = Object.entries(paxRecords);
+  if (paxEntries.length === 0)
+    return null;
+  const paxBody = encoder3.encode(paxEntries.map(([key, value]) => {
+    const record = `${key}=${value}
+`;
+    const partLength = encoder3.encode(record).length + 1;
+    let totalLength = partLength + String(partLength).length;
+    totalLength = partLength + String(totalLength).length;
+    return `${totalLength} ${record}`;
+  }).join(""));
+  return {
+    paxHeader: createTarHeader2({
+      name: decoder3.decode(encoder3.encode(`PaxHeader/${header.name}`).slice(0, 100)),
+      size: paxBody.length,
+      type: "pax-header",
+      mode: 420,
+      mtime: header.mtime,
+      uname: header.uname,
+      gname: header.gname,
+      uid: header.uid,
+      gid: header.gid
+    }),
+    paxBody
+  };
+}
+function findUstarSplit2(path) {
+  if (path.length <= USTAR_NAME_SIZE2)
+    return null;
+  const minSlashIndex = path.length - USTAR_NAME_SIZE2 - 1;
+  const slashIndex = path.lastIndexOf("/", USTAR_PREFIX_SIZE2);
+  if (slashIndex > 0 && slashIndex >= minSlashIndex)
+    return {
+      prefix: path.slice(0, slashIndex),
+      name: path.slice(slashIndex + 1)
+    };
+  return null;
+}
+function createTarHeader2(header) {
+  const view = new Uint8Array(BLOCK_SIZE3);
+  const size = isBodyless2(header) ? 0 : header.size ?? 0;
+  let name = header.name;
+  let prefix = "";
+  if (!header.pax?.path) {
+    const split = findUstarSplit2(name);
+    if (split) {
+      name = split.name;
+      prefix = split.prefix;
+    }
+  }
+  writeString2(view, USTAR_NAME_OFFSET2, USTAR_NAME_SIZE2, name);
+  writeOctal2(view, USTAR_MODE_OFFSET2, USTAR_MODE_SIZE2, header.mode ?? (header.type === DIRECTORY2 ? DEFAULT_DIR_MODE2 : DEFAULT_FILE_MODE2));
+  writeOctal2(view, USTAR_UID_OFFSET2, USTAR_UID_SIZE2, header.uid ?? 0);
+  writeOctal2(view, USTAR_GID_OFFSET2, USTAR_GID_SIZE2, header.gid ?? 0);
+  writeOctal2(view, USTAR_SIZE_OFFSET2, USTAR_SIZE_SIZE2, size);
+  writeOctal2(view, USTAR_MTIME_OFFSET2, USTAR_MTIME_SIZE2, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1000));
+  writeString2(view, USTAR_TYPEFLAG_OFFSET2, USTAR_TYPEFLAG_SIZE2, TYPEFLAG2[header.type ?? FILE2]);
+  writeString2(view, USTAR_LINKNAME_OFFSET2, USTAR_LINKNAME_SIZE2, header.linkname);
+  writeString2(view, USTAR_MAGIC_OFFSET2, USTAR_MAGIC_SIZE2, "ustar\x00");
+  writeString2(view, USTAR_VERSION_OFFSET2, USTAR_VERSION_SIZE2, USTAR_VERSION2);
+  writeString2(view, USTAR_UNAME_OFFSET2, USTAR_UNAME_SIZE2, header.uname);
+  writeString2(view, USTAR_GNAME_OFFSET2, USTAR_GNAME_SIZE2, header.gname);
+  writeString2(view, USTAR_PREFIX_OFFSET2, USTAR_PREFIX_SIZE2, prefix);
+  writeChecksum2(view);
+  return view;
+}
+function parseUstarHeader2(block, strict) {
+  if (strict && !validateChecksum2(block))
+    throw new Error("Invalid tar header checksum.");
+  const typeflag = readString2(block, USTAR_TYPEFLAG_OFFSET2, USTAR_TYPEFLAG_SIZE2);
+  const header = {
+    name: readString2(block, USTAR_NAME_OFFSET2, USTAR_NAME_SIZE2),
+    mode: readOctal2(block, USTAR_MODE_OFFSET2, USTAR_MODE_SIZE2),
+    uid: readNumeric2(block, USTAR_UID_OFFSET2, USTAR_UID_SIZE2),
+    gid: readNumeric2(block, USTAR_GID_OFFSET2, USTAR_GID_SIZE2),
+    size: readNumeric2(block, USTAR_SIZE_OFFSET2, USTAR_SIZE_SIZE2),
+    mtime: /* @__PURE__ */ new Date(readNumeric2(block, USTAR_MTIME_OFFSET2, USTAR_MTIME_SIZE2) * 1000),
+    type: FLAGTYPE2[typeflag] || FILE2,
+    linkname: readString2(block, USTAR_LINKNAME_OFFSET2, USTAR_LINKNAME_SIZE2)
+  };
+  const magic = readString2(block, USTAR_MAGIC_OFFSET2, USTAR_MAGIC_SIZE2);
+  if (magic.trim() === "ustar") {
+    header.uname = readString2(block, USTAR_UNAME_OFFSET2, USTAR_UNAME_SIZE2);
+    header.gname = readString2(block, USTAR_GNAME_OFFSET2, USTAR_GNAME_SIZE2);
+  }
+  if (magic === "ustar")
+    header.prefix = readString2(block, USTAR_PREFIX_OFFSET2, USTAR_PREFIX_SIZE2);
+  return header;
+}
+var PAX_MAPPING2 = {
+  path: ["name", (v) => v],
+  linkpath: ["linkname", (v) => v],
+  size: ["size", (v) => parseInt(v, 10)],
+  mtime: ["mtime", parseFloat],
+  uid: ["uid", (v) => parseInt(v, 10)],
+  gid: ["gid", (v) => parseInt(v, 10)],
+  uname: ["uname", (v) => v],
+  gname: ["gname", (v) => v]
+};
+function parsePax2(buffer) {
+  const decoder$1 = new TextDecoder("utf-8");
+  const overrides = {};
+  const pax = {};
+  let offset = 0;
+  while (offset < buffer.length) {
+    const spaceIndex = buffer.indexOf(32, offset);
+    if (spaceIndex === -1)
+      break;
+    const length = parseInt(decoder$1.decode(buffer.subarray(offset, spaceIndex)), 10);
+    if (Number.isNaN(length) || length === 0)
+      break;
+    const recordEnd = offset + length;
+    const [key, value] = decoder$1.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
+    if (key && value !== undefined) {
+      pax[key] = value;
+      const mapping = PAX_MAPPING2[key];
+      if (mapping) {
+        const [targetKey, parser] = mapping;
+        const parsedValue = parser(value);
+        if (typeof parsedValue === "string" || !Number.isNaN(parsedValue))
+          overrides[targetKey] = parsedValue;
+      }
+    }
+    offset = recordEnd;
+  }
+  if (Object.keys(pax).length > 0)
+    overrides.pax = pax;
+  return overrides;
+}
+function applyOverrides2(header, overrides) {
+  if (overrides.name !== undefined)
+    header.name = overrides.name;
+  if (overrides.linkname !== undefined)
+    header.linkname = overrides.linkname;
+  if (overrides.size !== undefined)
+    header.size = overrides.size;
+  if (overrides.mtime !== undefined)
+    header.mtime = /* @__PURE__ */ new Date(overrides.mtime * 1000);
+  if (overrides.uid !== undefined)
+    header.uid = overrides.uid;
+  if (overrides.gid !== undefined)
+    header.gid = overrides.gid;
+  if (overrides.uname !== undefined)
+    header.uname = overrides.uname;
+  if (overrides.gname !== undefined)
+    header.gname = overrides.gname;
+  if (overrides.pax)
+    header.pax = Object.assign({}, header.pax ?? {}, overrides.pax);
+}
+function getMetaParser2(type) {
+  switch (type) {
+    case "pax-global-header":
+    case "pax-header":
+      return parsePax2;
+    case "gnu-long-name":
+      return (data) => ({ name: readString2(data, 0, data.length) });
+    case "gnu-long-link-name":
+      return (data) => ({ linkname: readString2(data, 0, data.length) });
+    default:
+      return;
+  }
+}
+function getHeaderBlocks2(header) {
+  const base = createTarHeader2(header);
+  const pax = generatePax2(header);
+  if (!pax)
+    return [base];
+  const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK2;
+  const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK3.subarray(0, paxPadding)] : [];
+  return [
+    pax.paxHeader,
+    pax.paxBody,
+    ...paddingBlocks,
+    base
+  ];
+}
+var EOF_BUFFER3 = new Uint8Array(BLOCK_SIZE3 * 2);
+function createTarPacker3(onData, onError, onFinalize) {
+  let currentHeader = null;
+  let bytesWritten = 0;
+  let finalized = false;
+  return {
+    add(header) {
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("No new tar entries after finalize.");
+        onError(error);
+        throw error;
+      }
+      if (currentHeader !== null) {
+        const error = /* @__PURE__ */ new Error("Previous entry must be completed before adding a new one");
+        onError(error);
+        throw error;
+      }
+      try {
+        const size = isBodyless2(header) ? 0 : header.size ?? 0;
+        const headerBlocks = getHeaderBlocks2({
+          ...header,
+          size
+        });
+        for (const block of headerBlocks)
+          onData(block);
+        currentHeader = {
+          ...header,
+          size
+        };
+        bytesWritten = 0;
+      } catch (error) {
+        onError(error);
+      }
+    },
+    write(chunk) {
+      if (!currentHeader) {
+        const error = /* @__PURE__ */ new Error("No active tar entry.");
+        onError(error);
+        throw error;
+      }
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Cannot write data after finalize.");
+        onError(error);
+        throw error;
+      }
+      const newTotal = bytesWritten + chunk.length;
+      if (newTotal > currentHeader.size) {
+        const error = /* @__PURE__ */ new Error(`"${currentHeader.name}" exceeds given size of ${currentHeader.size} bytes.`);
+        onError(error);
+        throw error;
+      }
+      try {
+        bytesWritten = newTotal;
+        onData(chunk);
+      } catch (error) {
+        onError(error);
+      }
+    },
+    endEntry() {
+      if (!currentHeader) {
+        const error = /* @__PURE__ */ new Error("No active entry to end.");
+        onError(error);
+        throw error;
+      }
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Cannot end entry after finalize.");
+        onError(error);
+        throw error;
+      }
+      try {
+        if (bytesWritten !== currentHeader.size) {
+          const error = /* @__PURE__ */ new Error(`Size mismatch for "${currentHeader.name}".`);
+          onError(error);
+          throw error;
+        }
+        const paddingSize = -currentHeader.size & BLOCK_SIZE_MASK2;
+        if (paddingSize > 0)
+          onData(new Uint8Array(paddingSize));
+        currentHeader = null;
+        bytesWritten = 0;
+      } catch (error) {
+        onError(error);
+        throw error;
+      }
+    },
+    finalize() {
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Archive has already been finalized");
+        onError(error);
+        throw error;
+      }
+      if (currentHeader !== null) {
+        const error = /* @__PURE__ */ new Error("Cannot finalize while an entry is still active");
+        onError(error);
+        throw error;
+      }
+      try {
+        onData(EOF_BUFFER3);
+        finalized = true;
+        if (onFinalize)
+          onFinalize();
+      } catch (error) {
+        onError(error);
+      }
+    }
+  };
+}
+var INITIAL_CAPACITY2 = 256;
+function createChunkQueue2() {
+  let chunks = new Array(INITIAL_CAPACITY2);
+  let capacityMask = chunks.length - 1;
+  let head = 0;
+  let tail = 0;
+  let totalAvailable = 0;
+  const consumeFromHead = (count) => {
+    const chunk = chunks[head];
+    if (count === chunk.length) {
+      chunks[head] = EMPTY3;
+      head = head + 1 & capacityMask;
+    } else
+      chunks[head] = chunk.subarray(count);
+    totalAvailable -= count;
+    if (totalAvailable === 0 && chunks.length > INITIAL_CAPACITY2) {
+      chunks = new Array(INITIAL_CAPACITY2);
+      capacityMask = INITIAL_CAPACITY2 - 1;
+      head = 0;
+      tail = 0;
+    }
+  };
+  function pull(bytes, callback) {
+    if (callback) {
+      let fed = 0;
+      let remaining$1 = Math.min(bytes, totalAvailable);
+      while (remaining$1 > 0) {
+        const chunk = chunks[head];
+        const toFeed = Math.min(remaining$1, chunk.length);
+        const segment = toFeed === chunk.length ? chunk : chunk.subarray(0, toFeed);
+        consumeFromHead(toFeed);
+        remaining$1 -= toFeed;
+        fed += toFeed;
+        if (!callback(segment))
+          break;
+      }
+      return fed;
+    }
+    if (totalAvailable < bytes)
+      return null;
+    if (bytes === 0)
+      return EMPTY3;
+    const firstChunk = chunks[head];
+    if (firstChunk.length >= bytes) {
+      const view = firstChunk.length === bytes ? firstChunk : firstChunk.subarray(0, bytes);
+      consumeFromHead(bytes);
+      return view;
+    }
+    const result = new Uint8Array(bytes);
+    let copied = 0;
+    let remaining = bytes;
+    while (remaining > 0) {
+      const chunk = chunks[head];
+      const toCopy = Math.min(remaining, chunk.length);
+      result.set(toCopy === chunk.length ? chunk : chunk.subarray(0, toCopy), copied);
+      copied += toCopy;
+      remaining -= toCopy;
+      consumeFromHead(toCopy);
+    }
+    return result;
+  }
+  return {
+    push: (chunk) => {
+      if (chunk.length === 0)
+        return;
+      let nextTail = tail + 1 & capacityMask;
+      if (nextTail === head) {
+        const oldLen = chunks.length;
+        const newLen = oldLen * 2;
+        const newChunks = new Array(newLen);
+        const count = tail - head + oldLen & oldLen - 1;
+        if (head < tail)
+          for (let i = 0;i < count; i++)
+            newChunks[i] = chunks[head + i];
+        else if (count > 0) {
+          const firstPart = oldLen - head;
+          for (let i = 0;i < firstPart; i++)
+            newChunks[i] = chunks[head + i];
+          for (let i = 0;i < tail; i++)
+            newChunks[firstPart + i] = chunks[i];
+        }
+        chunks = newChunks;
+        capacityMask = newLen - 1;
+        head = 0;
+        tail = count;
+        nextTail = tail + 1 & capacityMask;
+      }
+      chunks[tail] = chunk;
+      tail = nextTail;
+      totalAvailable += chunk.length;
+    },
+    available: () => totalAvailable,
+    peek: (bytes) => {
+      if (totalAvailable < bytes)
+        return null;
+      if (bytes === 0)
+        return EMPTY3;
+      const firstChunk = chunks[head];
+      if (firstChunk.length >= bytes)
+        return firstChunk.length === bytes ? firstChunk : firstChunk.subarray(0, bytes);
+      const result = new Uint8Array(bytes);
+      let copied = 0;
+      let index = head;
+      while (copied < bytes) {
+        const chunk = chunks[index];
+        const toCopy = Math.min(bytes - copied, chunk.length);
+        if (toCopy === chunk.length)
+          result.set(chunk, copied);
+        else
+          result.set(chunk.subarray(0, toCopy), copied);
+        copied += toCopy;
+        index = index + 1 & capacityMask;
+      }
+      return result;
+    },
+    discard: (bytes) => {
+      if (bytes > totalAvailable)
+        throw new Error("Too many bytes consumed");
+      if (bytes === 0)
+        return;
+      let remaining = bytes;
+      while (remaining > 0) {
+        const chunk = chunks[head];
+        const toConsume = Math.min(remaining, chunk.length);
+        consumeFromHead(toConsume);
+        remaining -= toConsume;
+      }
+    },
+    pull
+  };
+}
+var STATE_HEADER2 = 0;
+var STATE_BODY2 = 1;
+var truncateErr2 = /* @__PURE__ */ new Error("Tar archive is truncated.");
+function createUnpacker2(options = {}) {
+  const strict = options.strict ?? false;
+  const { available, peek, push, discard, pull } = createChunkQueue2();
+  let state = STATE_HEADER2;
+  let ended = false;
+  let done = false;
+  let eof = false;
+  let currentEntry = null;
+  const paxGlobals = {};
+  let nextEntryOverrides = {};
+  const unpacker = {
+    isEntryActive: () => state === STATE_BODY2,
+    isBodyComplete: () => !currentEntry || currentEntry.remaining === 0,
+    write(chunk) {
+      if (ended)
+        throw new Error("Archive already ended.");
+      push(chunk);
+    },
+    end() {
+      ended = true;
+    },
+    readHeader() {
+      if (state !== STATE_HEADER2)
+        throw new Error("Cannot read header while an entry is active");
+      if (done)
+        return;
+      while (!done) {
+        if (available() < BLOCK_SIZE3) {
+          if (ended) {
+            if (available() > 0 && strict)
+              throw truncateErr2;
+            done = true;
+            return;
+          }
+          return null;
+        }
+        const headerBlock = peek(BLOCK_SIZE3);
+        if (isZeroBlock2(headerBlock)) {
+          if (available() < BLOCK_SIZE3 * 2) {
+            if (ended) {
+              if (strict)
+                throw truncateErr2;
+              done = true;
+              return;
+            }
+            return null;
+          }
+          if (isZeroBlock2(peek(BLOCK_SIZE3 * 2).subarray(BLOCK_SIZE3))) {
+            discard(BLOCK_SIZE3 * 2);
+            done = true;
+            eof = true;
+            return;
+          }
+          if (strict)
+            throw new Error("Invalid tar header.");
+          discard(BLOCK_SIZE3);
+          continue;
+        }
+        let internalHeader;
+        try {
+          internalHeader = parseUstarHeader2(headerBlock, strict);
+        } catch (err) {
+          if (strict)
+            throw err;
+          discard(BLOCK_SIZE3);
+          continue;
+        }
+        const metaParser = getMetaParser2(internalHeader.type);
+        if (metaParser) {
+          const paddedSize = internalHeader.size + BLOCK_SIZE_MASK2 & ~BLOCK_SIZE_MASK2;
+          if (available() < BLOCK_SIZE3 + paddedSize) {
+            if (ended && strict)
+              throw truncateErr2;
+            return null;
+          }
+          discard(BLOCK_SIZE3);
+          const overrides = metaParser(pull(paddedSize).subarray(0, internalHeader.size));
+          const target = internalHeader.type === "pax-global-header" ? paxGlobals : nextEntryOverrides;
+          for (const key in overrides)
+            target[key] = overrides[key];
+          continue;
+        }
+        discard(BLOCK_SIZE3);
+        const header = internalHeader;
+        if (internalHeader.prefix)
+          header.name = `${internalHeader.prefix}/${header.name}`;
+        applyOverrides2(header, paxGlobals);
+        applyOverrides2(header, nextEntryOverrides);
+        nextEntryOverrides = {};
+        currentEntry = {
+          header,
+          remaining: header.size,
+          padding: -header.size & BLOCK_SIZE_MASK2
+        };
+        state = STATE_BODY2;
+        return header;
+      }
+    },
+    streamBody(callback) {
+      if (state !== STATE_BODY2 || !currentEntry || currentEntry.remaining === 0)
+        return 0;
+      const bytesToFeed = Math.min(currentEntry.remaining, available());
+      if (bytesToFeed === 0)
+        return 0;
+      const fed = pull(bytesToFeed, callback);
+      currentEntry.remaining -= fed;
+      return fed;
+    },
+    skipPadding() {
+      if (state !== STATE_BODY2 || !currentEntry)
+        return true;
+      if (currentEntry.remaining > 0)
+        throw new Error("Body not fully consumed");
+      if (available() < currentEntry.padding)
+        return false;
+      discard(currentEntry.padding);
+      currentEntry = null;
+      state = STATE_HEADER2;
+      return true;
+    },
+    skipEntry() {
+      if (state !== STATE_BODY2 || !currentEntry)
+        return true;
+      const toDiscard = Math.min(currentEntry.remaining, available());
+      if (toDiscard > 0) {
+        discard(toDiscard);
+        currentEntry.remaining -= toDiscard;
+      }
+      if (currentEntry.remaining > 0)
+        return false;
+      return unpacker.skipPadding();
+    },
+    validateEOF() {
+      if (strict) {
+        if (!eof)
+          throw truncateErr2;
+        if (available() > 0) {
+          if (pull(available()).some((byte) => byte !== 0))
+            throw new Error("Invalid EOF.");
+        }
+      }
+    }
+  };
+  return unpacker;
+}
+function isZeroBlock2(block) {
+  if (block.byteOffset % 8 === 0) {
+    const view = new BigUint64Array(block.buffer, block.byteOffset, block.length / 8);
+    for (let i = 0;i < view.length; i++)
+      if (view[i] !== 0n)
+        return false;
+    return true;
+  }
+  for (let i = 0;i < block.length; i++)
+    if (block[i] !== 0)
+      return false;
+  return true;
+}
+function createTarPacker22() {
+  let streamController;
+  let packer;
+  return {
+    readable: new ReadableStream({ start(controller) {
+      streamController = controller;
+      packer = createTarPacker3(controller.enqueue.bind(controller), controller.error.bind(controller), controller.close.bind(controller));
+    } }),
+    controller: {
+      add(header) {
+        const bodyless = isBodyless2(header);
+        const h = { ...header };
+        if (bodyless)
+          h.size = 0;
+        packer.add(h);
+        if (bodyless)
+          packer.endEntry();
+        return new WritableStream({
+          write(chunk) {
+            packer.write(chunk);
+          },
+          close() {
+            if (!bodyless)
+              packer.endEntry();
+          },
+          abort(reason) {
+            streamController.error(reason);
+          }
+        });
+      },
+      finalize() {
+        packer.finalize();
+      },
+      error(err) {
+        streamController.error(err);
+      }
+    }
+  };
+}
+async function streamToBuffer2(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  let totalLength = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      chunks.push(value);
+      totalLength += value.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  } finally {
+    reader.releaseLock();
+  }
+}
+var drain2 = (stream) => stream.pipeTo(new WritableStream);
+function createTarDecoder2(options = {}) {
+  const unpacker = createUnpacker2(options);
+  let bodyController = null;
+  let pumping = false;
+  const pump = (controller) => {
+    if (pumping)
+      return;
+    pumping = true;
+    try {
+      while (true)
+        if (unpacker.isEntryActive()) {
+          if (bodyController) {
+            if (unpacker.streamBody((c) => (bodyController.enqueue(c), true)) === 0 && !unpacker.isBodyComplete())
+              break;
+          } else if (!unpacker.skipEntry())
+            break;
+          if (unpacker.isBodyComplete()) {
+            try {
+              bodyController?.close();
+            } catch {}
+            bodyController = null;
+            if (!unpacker.skipPadding())
+              break;
+          }
+        } else {
+          const header = unpacker.readHeader();
+          if (header === null || header === undefined)
+            break;
+          controller.enqueue({
+            header,
+            body: new ReadableStream({
+              start(c) {
+                if (header.size === 0)
+                  c.close();
+                else
+                  bodyController = c;
+              },
+              pull: () => pump(controller),
+              cancel() {
+                bodyController = null;
+                pump(controller);
+              }
+            })
+          });
+        }
+    } catch (error) {
+      try {
+        bodyController?.error(error);
+      } catch {}
+      bodyController = null;
+      throw error;
+    } finally {
+      pumping = false;
+    }
+  };
+  return new TransformStream({
+    transform(chunk, controller) {
+      try {
+        unpacker.write(chunk);
+        pump(controller);
+      } catch (error) {
+        try {
+          bodyController?.error(error);
+        } catch {}
+        throw error;
+      }
+    },
+    flush(controller) {
+      try {
+        unpacker.end();
+        pump(controller);
+        unpacker.validateEOF();
+        if (unpacker.isEntryActive() && !unpacker.isBodyComplete())
+          try {
+            bodyController?.close();
+          } catch {}
+      } catch (error) {
+        try {
+          bodyController?.error(error);
+        } catch {}
+        throw error;
+      }
+    }
+  }, undefined, { highWaterMark: 1 });
+}
+async function packTar2(entries) {
+  const { readable, controller } = createTarPacker22();
+  await (async () => {
+    for (const entry of entries) {
+      const entryStream = controller.add(entry.header);
+      const body = "body" in entry ? entry.body : entry.data;
+      if (!body) {
+        await entryStream.close();
+        continue;
+      }
+      if (body instanceof ReadableStream)
+        await body.pipeTo(entryStream);
+      else if (body instanceof Blob)
+        await body.stream().pipeTo(entryStream);
+      else
+        try {
+          const chunk = await normalizeBody2(body);
+          if (chunk.length > 0) {
+            const writer = entryStream.getWriter();
+            await writer.write(chunk);
+            await writer.close();
+          } else
+            await entryStream.close();
+        } catch {
+          throw new TypeError(`Unsupported content type for entry "${entry.header.name}".`);
+        }
+    }
+  })().then(() => controller.finalize()).catch((err) => controller.error(err));
+  return new Uint8Array(await streamToBuffer2(readable));
+}
+async function unpackTar2(archive, options = {}) {
+  const sourceStream = archive instanceof ReadableStream ? archive : new ReadableStream({ start(controller) {
+    controller.enqueue(archive instanceof Uint8Array ? archive : new Uint8Array(archive));
+    controller.close();
+  } });
+  const results = [];
+  const entryStream = sourceStream.pipeThrough(createTarDecoder2(options));
+  for await (const entry of entryStream) {
+    let processedHeader;
+    try {
+      processedHeader = transformHeader2(entry.header, options);
+    } catch (error) {
+      await entry.body.cancel();
+      throw error;
+    }
+    if (processedHeader === null) {
+      await drain2(entry.body);
+      continue;
+    }
+    if (isBodyless2(processedHeader)) {
+      await drain2(entry.body);
+      results.push({ header: processedHeader });
+    } else
+      results.push({
+        header: processedHeader,
+        data: await streamToBuffer2(entry.body)
+      });
+  }
+  return results;
+}
+var gzipAsync3 = promisify3(gzip3);
+var gunzipAsync3 = promisify3(gunzip3);
+
+class RXCImpl2 {
+  _buffer;
+  _filesCache = null;
+  constructor(buffer) {
+    this._buffer = buffer;
+  }
+  get stream() {
+    const buffer = this._buffer;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(buffer));
+        controller.close();
+      }
+    });
+  }
+  async buffer() {
+    return this._buffer;
+  }
+  async file(path) {
+    const filesMap = await this.files();
+    const content = filesMap.get(path);
+    if (!content) {
+      throw new ContentError2(`file not found: ${path}`);
+    }
+    return content;
+  }
+  async files() {
+    if (this._filesCache) {
+      return this._filesCache;
+    }
+    const tarBuffer = await gunzipAsync3(this._buffer);
+    const entries = await unpackTar2(tarBuffer);
+    const filesMap = new Map;
+    for (const entry of entries) {
+      if ((entry.header.type === "file" || entry.header.type === undefined) && entry.data) {
+        filesMap.set(entry.header.name, Buffer.from(entry.data));
+      }
+    }
+    this._filesCache = filesMap;
+    return filesMap;
+  }
+}
+function isArchiveInput2(input) {
+  return "archive" in input && Buffer.isBuffer(input.archive);
+}
+async function createRXC2(input) {
+  if (isArchiveInput2(input)) {
+    return new RXCImpl2(input.archive);
+  }
+  const entries = Object.entries(input).map(([name, content]) => {
+    const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
+    const size = typeof content === "string" ? Buffer.byteLength(content) : content.length;
+    return {
+      header: { name, size, type: "file" },
+      body
+    };
+  });
+  const tarBuffer = await packTar2(entries);
+  const gzipBuffer = await gzipAsync3(Buffer.from(tarBuffer));
+  return new RXCImpl2(gzipBuffer);
+}
+
+class FolderLoader {
+  async canLoad(source) {
+    try {
+      const stats = await stat22(source);
+      if (!stats.isDirectory()) {
+        return false;
+      }
+      const manifestPath = join22(source, "resource.json");
+      const manifestStats = await stat22(manifestPath);
+      return manifestStats.isFile();
+    } catch {
+      return false;
+    }
+  }
+  async load(folderPath) {
+    const manifestPath = join22(folderPath, "resource.json");
+    let manifestJson;
+    try {
+      manifestJson = await readFile22(manifestPath, "utf-8");
+    } catch (error) {
+      throw new ResourceXError3(`Failed to read resource.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let manifestData;
+    try {
+      manifestData = JSON.parse(manifestJson);
+    } catch (error) {
+      throw new ResourceXError3(`Invalid JSON in resource.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!manifestData.name) {
+      throw new ResourceXError3("Invalid resource.json: missing required field 'name'");
+    }
+    if (!manifestData.type) {
+      throw new ResourceXError3("Invalid resource.json: missing required field 'type'");
+    }
+    if (!manifestData.version) {
+      throw new ResourceXError3("Invalid resource.json: missing required field 'version'");
+    }
+    const manifest = createRXM2({
+      domain: manifestData.domain ?? "localhost",
+      path: manifestData.path,
+      name: manifestData.name,
+      type: manifestData.type,
+      version: manifestData.version
+    });
+    const files = await this.readFolderFiles(folderPath);
+    if (Object.keys(files).length === 0) {
+      throw new ResourceXError3("No content files found in resource folder");
+    }
+    const content = await createRXC2(files);
+    const locator = parseRXL3(manifest.toLocator());
+    return {
+      locator,
+      manifest,
+      content
+    };
+  }
+  async readFolderFiles(folderPath, basePath = folderPath) {
+    const files = {};
+    const entries = await readdir22(folderPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join22(folderPath, entry.name);
+      const relativePath = relative(basePath, fullPath);
+      if (relativePath === "resource.json") {
+        continue;
+      }
+      if (entry.isFile()) {
+        files[relativePath] = await readFile22(fullPath);
+      } else if (entry.isDirectory()) {
+        const subFiles = await this.readFolderFiles(fullPath, basePath);
+        Object.assign(files, subFiles);
+      }
+    }
+    return files;
+  }
+}
+async function loadResource(source, config) {
+  const loader = config?.loader ?? new FolderLoader;
+  const canLoad = await loader.canLoad(source);
+  if (!canLoad) {
+    throw new ResourceXError3(`Cannot load resource from: ${source}`);
+  }
+  return loader.load(source);
+}
 var DEFAULT_PATH = `${homedir()}/.resourcex`;
 
 class LocalRegistry {
@@ -25747,14 +27021,14 @@ class LocalRegistry {
     const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
     const version = rxl.version ?? "latest";
     if (area === "local") {
-      return join2(this.basePath, "local", resourceName, version);
+      return join3(this.basePath, "local", resourceName, version);
     } else {
       const domain = rxl.domain ?? "localhost";
-      let path = join2(this.basePath, "cache", domain);
+      let path = join3(this.basePath, "cache", domain);
       if (rxl.path) {
-        path = join2(path, rxl.path);
+        path = join3(path, rxl.path);
       }
-      return join2(path, resourceName, version);
+      return join3(path, resourceName, version);
     }
   }
   isLocalOnlyLocator(locator) {
@@ -25762,7 +27036,7 @@ class LocalRegistry {
     return !rxl.domain || rxl.domain === "localhost";
   }
   async existsAt(resourcePath) {
-    const manifestPath = join2(resourcePath, "manifest.json");
+    const manifestPath = join3(resourcePath, "manifest.json");
     const arl = this.arp.parse(this.toArpUrl(manifestPath));
     return arl.exists();
   }
@@ -25777,39 +27051,72 @@ class LocalRegistry {
     }
     return null;
   }
+  async isSymlink(path) {
+    try {
+      const stats = await lstat(path);
+      return stats.isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
   async loadFrom(resourcePath) {
-    const manifestPath = join2(resourcePath, "manifest.json");
+    if (await this.isSymlink(resourcePath)) {
+      const targetPath = await readlink(resourcePath);
+      return loadResource(targetPath);
+    }
+    const manifestPath = join3(resourcePath, "manifest.json");
     const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
     const manifestResource = await manifestArl.resolve();
     const manifestContent = manifestResource.content.toString("utf-8");
     const manifestData = JSON.parse(manifestContent);
     const manifest = createRXM(manifestData);
-    const contentPath = join2(resourcePath, "content.tar.gz");
+    const contentPath = join3(resourcePath, "content.tar.gz");
     const contentArl = this.arp.parse(this.toArpUrl(contentPath));
     const contentResource = await contentArl.resolve();
     const data = contentResource.content;
     return this.typeHandler.deserialize(data, manifest);
   }
-  async pull(_locator, _options) {
-    throw new RegistryError("Pull not implemented yet - see issue #018");
-  }
-  async publish(_resource, _options) {
-    throw new RegistryError("Publish not implemented yet - see issue #018");
-  }
-  async link(resource) {
+  async link(path) {
+    const rxr = await loadResource(path);
+    const locator = rxr.manifest.toLocator();
+    const resourcePath = this.buildPath(locator, "local");
+    try {
+      const arl = this.arp.parse(this.toArpUrl(resourcePath));
+      if (await arl.exists()) {
+        await arl.delete();
+      }
+    } catch {}
+    const parentPath = join3(resourcePath, "..");
+    const parentArl = this.arp.parse(this.toArpUrl(parentPath));
+    await parentArl.mkdir();
+    const absolutePath = resolvePath(path);
+    await symlink(absolutePath, resourcePath);
+  }
+  async add(source) {
+    const resource = typeof source === "string" ? await loadResource(source) : source;
     const locator = resource.manifest.toLocator();
     const resourcePath = this.buildPath(locator, "local");
+    if (await this.isSymlink(resourcePath)) {
+      const arl = this.arp.parse(this.toArpUrl(resourcePath));
+      await arl.delete();
+    }
     const dirArl = this.arp.parse(this.toArpUrl(resourcePath));
     await dirArl.mkdir();
-    const manifestPath = join2(resourcePath, "manifest.json");
+    const manifestPath = join3(resourcePath, "manifest.json");
     const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
     const manifestContent = Buffer.from(JSON.stringify(resource.manifest.toJSON(), null, 2), "utf-8");
     await manifestArl.deposit(manifestContent);
-    const contentPath = join2(resourcePath, "content.tar.gz");
+    const contentPath = join3(resourcePath, "content.tar.gz");
     const contentArl = this.arp.parse(this.toArpUrl(contentPath));
     const serialized = await this.typeHandler.serialize(resource);
     await contentArl.deposit(serialized);
   }
+  async pull(_locator, _options) {
+    throw new RegistryError("Pull not implemented yet - see issue #018");
+  }
+  async publish(_source, _options) {
+    throw new RegistryError("Publish not implemented yet - see issue #018");
+  }
   async get(locator) {
     const area = await this.findArea(locator);
     if (!area) {
@@ -25845,7 +27152,7 @@ class LocalRegistry {
   async search(options) {
     const { query, limit, offset = 0 } = options ?? {};
     const locators = [];
-    const localDir = join2(this.basePath, "local");
+    const localDir = join3(this.basePath, "local");
     try {
       const localArl = this.arp.parse(this.toArpUrl(localDir));
       const localEntries = await localArl.list({ recursive: true, pattern: "*.json" });
@@ -25857,7 +27164,7 @@ class LocalRegistry {
           locators.push(rxl);
       }
     } catch {}
-    const cacheDir = join2(this.basePath, "cache");
+    const cacheDir = join3(this.basePath, "cache");
     try {
       const cacheArl = this.arp.parse(this.toArpUrl(cacheDir));
       const cacheEntries = await cacheArl.list({ recursive: true, pattern: "*.json" });
@@ -25952,15 +27259,18 @@ class RemoteRegistry {
   supportType(type) {
     this.typeHandler.register(type);
   }
+  async link(_path) {
+    throw new RegistryError("Cannot link to remote registry - use local registry for linking");
+  }
+  async add(_source) {
+    throw new RegistryError("Cannot add to remote registry - use local registry for adding");
+  }
   async pull(_locator, _options) {
     throw new RegistryError("Cannot pull to remote registry - use local registry for pulling");
   }
-  async publish(_resource, _options) {
+  async publish(_source, _options) {
     throw new RegistryError("Remote registry publish not implemented yet");
   }
-  async link(_resource) {
-    throw new RegistryError("Cannot link to remote registry - use local registry for linking");
-  }
   async get(locator) {
     const manifestUrl = `${this.endpoint}/resource?locator=${encodeURIComponent(locator)}`;
     const manifestResponse = await fetch(manifestUrl);
@@ -26223,7 +27533,7 @@ class GitRegistry {
       normalized = normalized.slice(0, -4);
     }
     const dirName = normalized.replace(/\//g, "-");
-    return join32(DEFAULT_GIT_CACHE, dirName);
+    return join4(DEFAULT_GIT_CACHE, dirName);
   }
   supportType(type) {
     this.typeHandler.register(type);
@@ -26232,7 +27542,7 @@ class GitRegistry {
     return `arp:binary:file://${filePath}`;
   }
   async ensureCloned() {
-    const gitDir = join32(this.cacheDir, ".git");
+    const gitDir = join4(this.cacheDir, ".git");
     const gitArl = this.arp.parse(this.toArpUrl(gitDir));
     if (this.isLocal) {
       if (!await gitArl.exists()) {
@@ -26311,17 +27621,17 @@ class GitRegistry {
     const rxl = parseRXL(locator);
     const domain = rxl.domain ?? "localhost";
     const version = rxl.version ?? "latest";
-    let path = join32(this.cacheDir, this.basePath, domain);
+    let path = join4(this.cacheDir, this.basePath, domain);
     if (rxl.path) {
-      path = join32(path, rxl.path);
+      path = join4(path, rxl.path);
     }
     const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    return join32(path, resourceName, version);
+    return join4(path, resourceName, version);
   }
   async get(locator) {
     await this.ensureCloned();
     const resourcePath = this.buildResourcePath(locator);
-    const manifestPath = join32(resourcePath, "manifest.json");
+    const manifestPath = join4(resourcePath, "manifest.json");
     const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
     if (!await manifestArl.exists()) {
       throw new RegistryError(`Resource not found: ${locator}`);
@@ -26330,7 +27640,7 @@ class GitRegistry {
     const manifestContent = manifestResource.content.toString("utf-8");
     const manifestData = JSON.parse(manifestContent);
     const manifest = createRXM(manifestData);
-    const contentPath = join32(resourcePath, "content.tar.gz");
+    const contentPath = join4(resourcePath, "content.tar.gz");
     const contentArl = this.arp.parse(this.toArpUrl(contentPath));
     const contentResource = await contentArl.resolve();
     const data = contentResource.content;
@@ -26344,7 +27654,7 @@ class GitRegistry {
     try {
       await this.ensureCloned();
       const resourcePath = this.buildResourcePath(locator);
-      const manifestPath = join32(resourcePath, "manifest.json");
+      const manifestPath = join4(resourcePath, "manifest.json");
       const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
       return await manifestArl.exists();
     } catch {
@@ -26355,7 +27665,7 @@ class GitRegistry {
     await this.ensureCloned();
     const { query, limit, offset = 0 } = options ?? {};
     const locators = [];
-    const baseDir = join32(this.cacheDir, this.basePath);
+    const baseDir = join4(this.cacheDir, this.basePath);
     try {
       const baseArl = this.arp.parse(this.toArpUrl(baseDir));
       const entries = await baseArl.list({ recursive: true, pattern: "*.json" });
@@ -26415,15 +27725,18 @@ class GitRegistry {
       return null;
     }
   }
+  async link(_path) {
+    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.link()");
+  }
+  async add(_source) {
+    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.add()");
+  }
   async pull(_locator, _options) {
     throw new RegistryError("GitRegistry is read-only - use LocalRegistry.pull()");
   }
-  async publish(_resource, _options) {
+  async publish(_source, _options) {
     throw new RegistryError("GitRegistry is read-only - use LocalRegistry.publish()");
   }
-  async link(_resource) {
-    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.link()");
-  }
   async delete(_locator) {
     throw new RegistryError("GitRegistry is read-only - use LocalRegistry.delete()");
   }
@@ -26437,14 +27750,17 @@ class RegistryMiddleware {
   supportType(type) {
     this.inner.supportType(type);
   }
+  link(path) {
+    return this.inner.link(path);
+  }
+  add(source) {
+    return this.inner.add(source);
+  }
   pull(locator, options) {
     return this.inner.pull(locator, options);
   }
-  publish(resource, options) {
-    return this.inner.publish(resource, options);
-  }
-  link(resource) {
-    return this.inner.link(resource);
+  publish(source, options) {
+    return this.inner.publish(source, options);
   }
   get(locator) {
     return this.inner.get(locator);
@@ -26639,4 +27955,4 @@ export {
   ARP
 };
 
-//# debugId=52B495D4FD58599564756E2164756E21
+//# debugId=8A456A3331FC3D3E64756E2164756E21