@metamask/snaps-controllers 5.0.1 → 6.0.1

package/dist/esm/snaps/location/http.js

@@ -1,96 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { VirtualFile, HttpSnapIdStruct, NpmSnapFileNames, createSnapManifest, normalizeRelative, parseJson } from '@metamask/snaps-utils';
-import { assert, assertStruct } from '@metamask/utils';
-export class HttpLocation {
-    async manifest() {
-        if (this.validatedManifest) {
-            return this.validatedManifest.clone();
-        }
-        // jest-fetch-mock doesn't handle new URL(), we need to convert .toString()
-        const canonicalPath = new URL(NpmSnapFileNames.Manifest, this.url).toString();
-        const response = await this.fetchFn(canonicalPath, this.fetchOptions);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch "${canonicalPath}". Status code: ${response.status}.`);
-        }
-        const contents = await response.text();
-        const manifest = parseJson(contents);
-        const vfile = new VirtualFile({
-            value: contents,
-            result: createSnapManifest(manifest),
-            path: NpmSnapFileNames.Manifest,
-            data: {
-                canonicalPath
-            }
-        });
-        this.validatedManifest = vfile;
-        return this.manifest();
-    }
-    async fetch(path) {
-        const relativePath = normalizeRelative(path);
-        const cached = this.cache.get(relativePath);
-        if (cached !== undefined) {
-            const { file, contents } = cached;
-            const value = new Uint8Array(await contents.arrayBuffer());
-            const vfile = file.clone();
-            vfile.value = value;
-            return vfile;
-        }
-        const canonicalPath = this.toCanonical(relativePath).toString();
-        const response = await this.fetchFn(canonicalPath, this.fetchOptions);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch "${canonicalPath}". Status code: ${response.status}.`);
-        }
-        const vfile = new VirtualFile({
-            value: '',
-            path: relativePath,
-            data: {
-                canonicalPath
-            }
-        });
-        const blob = await response.blob();
-        assert(!this.cache.has(relativePath), 'Corrupted cache, multiple files with same path.');
-        this.cache.set(relativePath, {
-            file: vfile,
-            contents: blob
-        });
-        return this.fetch(relativePath);
-    }
-    get root() {
-        return new URL(this.url);
-    }
-    toCanonical(path) {
-        assert(!path.startsWith('/'), 'Tried to parse absolute path.');
-        return new URL(path, this.url);
-    }
-    constructor(url, opts = {}){
-        // We keep contents separate because then we can use only one Blob in cache,
-        // which we convert to Uint8Array when actually returning the file.
-        //
-        // That avoids deepCloning file contents.
-        // I imagine ArrayBuffers are copy-on-write optimized, meaning
-        // in most often case we'll only have one file contents in common case.
-        _define_property(this, "cache", new Map());
-        _define_property(this, "validatedManifest", void 0);
-        _define_property(this, "url", void 0);
-        _define_property(this, "fetchFn", void 0);
-        _define_property(this, "fetchOptions", void 0);
-        assertStruct(url.toString(), HttpSnapIdStruct, 'Invalid Snap Id: ');
-        this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
-        this.fetchOptions = opts.fetchOptions;
-        this.url = url;
-    }
-}
-
-//# sourceMappingURL=http.js.map

package/dist/esm/snaps/location/http.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/snaps/location/http.ts"],"sourcesContent":["import type { SnapManifest } from '@metamask/snaps-utils';\nimport {\n  VirtualFile,\n  HttpSnapIdStruct,\n  NpmSnapFileNames,\n  createSnapManifest,\n  normalizeRelative,\n  parseJson,\n} from '@metamask/snaps-utils';\nimport { assert, assertStruct } from '@metamask/utils';\n\nimport type { SnapLocation } from './location';\n\nexport interface HttpOptions {\n  /**\n   * @default fetch\n   */\n  fetch?: typeof fetch;\n  fetchOptions?: RequestInit;\n}\n\nexport class HttpLocation implements SnapLocation {\n  // We keep contents separate because then we can use only one Blob in cache,\n  // which we convert to Uint8Array when actually returning the file.\n  //\n  // That avoids deepCloning file contents.\n  // I imagine ArrayBuffers are copy-on-write optimized, meaning\n  // in most often case we'll only have one file contents in common case.\n  private readonly cache = new Map<\n    string,\n    { file: VirtualFile; contents: Blob }\n  >();\n\n  private validatedManifest?: VirtualFile<SnapManifest>;\n\n  private readonly url: URL;\n\n  private readonly fetchFn: typeof fetch;\n\n  private readonly fetchOptions?: RequestInit;\n\n  constructor(url: URL, opts: HttpOptions = {}) {\n    assertStruct(url.toString(), HttpSnapIdStruct, 'Invalid Snap Id: ');\n    this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);\n    this.fetchOptions = opts.fetchOptions;\n    this.url = url;\n  }\n\n  async manifest(): Promise<VirtualFile<SnapManifest>> {\n    if (this.validatedManifest) {\n      return this.validatedManifest.clone();\n    }\n\n    // jest-fetch-mock doesn't handle new URL(), we need to convert .toString()\n    const canonicalPath = new URL(\n      NpmSnapFileNames.Manifest,\n      this.url,\n    ).toString();\n\n    const response = await this.fetchFn(canonicalPath, this.fetchOptions);\n    if (!response.ok) {\n      throw new Error(\n        `Failed to fetch \"${canonicalPath}\". Status code: ${response.status}.`,\n      );\n    }\n    const contents = await response.text();\n    const manifest = parseJson(contents);\n    const vfile = new VirtualFile<SnapManifest>({\n      value: contents,\n      result: createSnapManifest(manifest),\n      path: NpmSnapFileNames.Manifest,\n      data: { canonicalPath },\n    });\n    this.validatedManifest = vfile;\n\n    return this.manifest();\n  }\n\n  async fetch(path: string): Promise<VirtualFile> {\n    const relativePath = normalizeRelative(path);\n    const cached = this.cache.get(relativePath);\n    if (cached !== undefined) {\n      const { file, contents } = cached;\n      const value = new Uint8Array(await contents.arrayBuffer());\n      const vfile = file.clone();\n      vfile.value = value;\n      return vfile;\n    }\n\n    const canonicalPath = this.toCanonical(relativePath).toString();\n    const response = await this.fetchFn(canonicalPath, this.fetchOptions);\n    if (!response.ok) {\n      throw new Error(\n        `Failed to fetch \"${canonicalPath}\". Status code: ${response.status}.`,\n      );\n    }\n    const vfile = new VirtualFile({\n      value: '',\n      path: relativePath,\n      data: { canonicalPath },\n    });\n    const blob = await response.blob();\n    assert(\n      !this.cache.has(relativePath),\n      'Corrupted cache, multiple files with same path.',\n    );\n    this.cache.set(relativePath, { file: vfile, contents: blob });\n\n    return this.fetch(relativePath);\n  }\n\n  get root(): URL {\n    return new URL(this.url);\n  }\n\n  private toCanonical(path: string): URL {\n    assert(!path.startsWith('/'), 'Tried to parse absolute path.');\n    return new URL(path, this.url);\n  }\n}\n"],"names":["VirtualFile","HttpSnapIdStruct","NpmSnapFileNames","createSnapManifest","normalizeRelative","parseJson","assert","assertStruct","HttpLocation","manifest","validatedManifest","clone","canonicalPath","URL","Manifest","url","toString","response","fetchFn","fetchOptions","ok","Error","status","contents","text","vfile","value","result","path","data","fetch","relativePath","cached","cache","get","undefined","file","Uint8Array","arrayBuffer","toCanonical","blob","has","set","root","startsWith","constructor","opts","Map","globalThis","bind"],"mappings":"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"}

package/dist/esm/snaps/location/index.js

@@ -1,6 +0,0 @@
-export * from './location';
-export * from './npm';
-export * from './local';
-export * from './http';
-
-//# sourceMappingURL=index.js.map

package/dist/esm/snaps/location/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/snaps/location/index.ts"],"sourcesContent":["export * from './location';\nexport * from './npm';\nexport * from './local';\nexport * from './http';\n"],"names":[],"mappings":"AAAA,cAAc,aAAa;AAC3B,cAAc,QAAQ;AACtB,cAAc,UAAU;AACxB,cAAc,SAAS"}

package/dist/esm/snaps/location/local.js

@@ -1,83 +0,0 @@
-function _check_private_redeclaration(obj, privateCollection) {
-    if (privateCollection.has(obj)) {
-        throw new TypeError("Cannot initialize the same private elements twice on an object");
-    }
-}
-function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
-    return descriptor.value;
-}
-function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
-        if (!descriptor.writable) {
-            throw new TypeError("attempted to set read only private field");
-        }
-        descriptor.value = value;
-    }
-}
-function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
-    return privateMap.get(receiver);
-}
-function _class_private_field_get(receiver, privateMap) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-    return _class_apply_descriptor_get(receiver, descriptor);
-}
-function _class_private_field_init(obj, privateMap, value) {
-    _check_private_redeclaration(obj, privateMap);
-    privateMap.set(obj, value);
-}
-function _class_private_field_set(receiver, privateMap, value) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
-    _class_apply_descriptor_set(receiver, descriptor, value);
-    return value;
-}
-import { LocalSnapIdStruct, SnapIdPrefixes } from '@metamask/snaps-utils';
-import { assert, assertStruct } from '@metamask/utils';
-import { HttpLocation } from './http';
-var _http = /*#__PURE__*/ new WeakMap();
-export class LocalLocation {
-    async manifest() {
-        const vfile = await _class_private_field_get(this, _http).manifest();
-        return convertCanonical(vfile);
-    }
-    async fetch(path) {
-        return convertCanonical(await _class_private_field_get(this, _http).fetch(path));
-    }
-    get shouldAlwaysReload() {
-        return true;
-    }
-    constructor(url, opts = {}){
-        _class_private_field_init(this, _http, {
-            writable: true,
-            value: void 0
-        });
-        assertStruct(url.toString(), LocalSnapIdStruct, 'Invalid Snap Id');
-        // TODO(ritave): Write deepMerge() which merges fetchOptions.
-        assert(opts.fetchOptions === undefined, 'Currently adding fetch options to local: is unsupported.');
-        _class_private_field_set(this, _http, new HttpLocation(new URL(url.toString().slice(SnapIdPrefixes.local.length)), {
-            ...opts,
-            fetchOptions: {
-                cache: 'no-cache'
-            }
-        }));
-    }
-}
-/**
- * Converts vfiles with canonical `http:` paths into `local:` paths.
- *
- * @param vfile - The {@link VirtualFile} to convert.
- * @returns The same object with updated `.data.canonicalPath`.
- */ function convertCanonical(vfile) {
-    assert(vfile.data.canonicalPath !== undefined);
-    vfile.data.canonicalPath = `local:${vfile.data.canonicalPath}`;
-    return vfile;
-}
-
-//# sourceMappingURL=local.js.map

package/dist/esm/snaps/location/local.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/snaps/location/local.ts"],"sourcesContent":["import type { SnapManifest, VirtualFile } from '@metamask/snaps-utils';\nimport { LocalSnapIdStruct, SnapIdPrefixes } from '@metamask/snaps-utils';\nimport { assert, assertStruct } from '@metamask/utils';\n\nimport type { HttpOptions } from './http';\nimport { HttpLocation } from './http';\nimport type { SnapLocation } from './location';\n\nexport class LocalLocation implements SnapLocation {\n  readonly #http: HttpLocation;\n\n  constructor(url: URL, opts: HttpOptions = {}) {\n    assertStruct(url.toString(), LocalSnapIdStruct, 'Invalid Snap Id');\n    // TODO(ritave): Write deepMerge() which merges fetchOptions.\n    assert(\n      opts.fetchOptions === undefined,\n      'Currently adding fetch options to local: is unsupported.',\n    );\n\n    this.#http = new HttpLocation(\n      new URL(url.toString().slice(SnapIdPrefixes.local.length)),\n      { ...opts, fetchOptions: { cache: 'no-cache' } },\n    );\n  }\n\n  async manifest(): Promise<VirtualFile<SnapManifest>> {\n    const vfile = await this.#http.manifest();\n\n    return convertCanonical(vfile);\n  }\n\n  async fetch(path: string): Promise<VirtualFile> {\n    return convertCanonical(await this.#http.fetch(path));\n  }\n\n  get shouldAlwaysReload() {\n    return true;\n  }\n}\n\n/**\n * Converts vfiles with canonical `http:` paths into `local:` paths.\n *\n * @param vfile - The {@link VirtualFile} to convert.\n * @returns The same object with updated `.data.canonicalPath`.\n */\nfunction convertCanonical<Result>(\n  vfile: VirtualFile<Result>,\n): VirtualFile<Result> {\n  assert(vfile.data.canonicalPath !== undefined);\n  vfile.data.canonicalPath = `local:${vfile.data.canonicalPath}`;\n  return vfile;\n}\n"],"names":["LocalSnapIdStruct","SnapIdPrefixes","assert","assertStruct","HttpLocation","LocalLocation","manifest","vfile","http","convertCanonical","fetch","path","shouldAlwaysReload","constructor","url","opts","toString","fetchOptions","undefined","URL","slice","local","length","cache","data","canonicalPath"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAASA,iBAAiB,EAAEC,cAAc,QAAQ,wBAAwB;AAC1E,SAASC,MAAM,EAAEC,YAAY,QAAQ,kBAAkB;AAGvD,SAASC,YAAY,QAAQ,SAAS;IAI3B;AADX,OAAO,MAAMC;IAiBX,MAAMC,WAA+C;QACnD,MAAMC,QAAQ,MAAM,yBAAA,IAAI,EAAEC,OAAKF,QAAQ;QAEvC,OAAOG,iBAAiBF;IAC1B;IAEA,MAAMG,MAAMC,IAAY,EAAwB;QAC9C,OAAOF,iBAAiB,MAAM,yBAAA,IAAI,EAAED,OAAKE,KAAK,CAACC;IACjD;IAEA,IAAIC,qBAAqB;QACvB,OAAO;IACT;IA1BAC,YAAYC,GAAQ,EAAEC,OAAoB,CAAC,CAAC,CAAE;QAF9C,gCAAS;;mBAAT,KAAA;;QAGEZ,aAAaW,IAAIE,QAAQ,IAAIhB,mBAAmB;QAChD,6DAA6D;QAC7DE,OACEa,KAAKE,YAAY,KAAKC,WACtB;uCAGIV,OAAO,IAAIJ,aACf,IAAIe,IAAIL,IAAIE,QAAQ,GAAGI,KAAK,CAACnB,eAAeoB,KAAK,CAACC,MAAM,IACxD;YAAE,GAAGP,IAAI;YAAEE,cAAc;gBAAEM,OAAO;YAAW;QAAE;IAEnD;AAeF;AAEA;;;;;CAKC,GACD,SAASd,iBACPF,KAA0B;IAE1BL,OAAOK,MAAMiB,IAAI,CAACC,aAAa,KAAKP;IACpCX,MAAMiB,IAAI,CAACC,aAAa,GAAG,CAAC,MAAM,EAAElB,MAAMiB,IAAI,CAACC,aAAa,CAAC,CAAC;IAC9D,OAAOlB;AACT"}

package/dist/esm/snaps/location/location.js

@@ -1,30 +0,0 @@
-import { assert } from '@metamask/utils';
-import { HttpLocation } from './http';
-import { LocalLocation } from './local';
-import { NpmLocation } from './npm';
-/**
- * Auto-magically detects which SnapLocation object to create based on the provided {@link location}.
- *
- * @param location - A {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8} uri.
- * @param opts - NPM options and feature flags.
- * @returns SnapLocation based on url.
- */ export function detectSnapLocation(location, opts) {
-    const allowHttp = opts?.allowHttp ?? false;
-    const allowLocal = opts?.allowLocal ?? false;
-    const root = new URL(location);
-    switch(root.protocol){
-        case 'npm:':
-            return new NpmLocation(root, opts);
-        case 'local:':
-            assert(allowLocal, new TypeError('Fetching local snaps is disabled.'));
-            return new LocalLocation(root, opts);
-        case 'http:':
-        case 'https:':
-            assert(allowHttp, new TypeError('Fetching snaps through http/https is disabled.'));
-            return new HttpLocation(root, opts);
-        default:
-            throw new TypeError(`Unrecognized "${root.protocol}" snap location protocol.`);
-    }
-}
-
-//# sourceMappingURL=location.js.map

package/dist/esm/snaps/location/location.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/snaps/location/location.ts"],"sourcesContent":["import type { SnapManifest, VirtualFile } from '@metamask/snaps-utils';\nimport type { SemVerRange } from '@metamask/utils';\nimport { assert } from '@metamask/utils';\n\nimport { HttpLocation } from './http';\nimport { LocalLocation } from './local';\nimport type { NpmOptions } from './npm';\nimport { NpmLocation } from './npm';\n\ndeclare module '@metamask/snaps-utils' {\n  interface DataMap {\n    /**\n     * Fully qualified, canonical path for the file in {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8 } URI format.\n     */\n    canonicalPath: string;\n  }\n}\n\nexport interface SnapLocation {\n  /**\n   * All files are relative to the manifest, except the manifest itself.\n   */\n  manifest(): Promise<VirtualFile<SnapManifest>>;\n  fetch(path: string): Promise<VirtualFile>;\n\n  readonly shouldAlwaysReload?: boolean;\n}\n\nexport type DetectSnapLocationOptions = NpmOptions & {\n  /**\n   * The function used to fetch data.\n   *\n   * @default globalThis.fetch\n   */\n  fetch?: typeof fetch;\n  /**\n   * @default false\n   */\n  allowHttp?: boolean;\n  /**\n   * @default false\n   */\n  allowLocal?: boolean;\n\n  resolveVersion?: (range: SemVerRange) => Promise<SemVerRange>;\n};\n\n/**\n * Auto-magically detects which SnapLocation object to create based on the provided {@link location}.\n *\n * @param location - A {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8} uri.\n * @param opts - NPM options and feature flags.\n * @returns SnapLocation based on url.\n */\nexport function detectSnapLocation(\n  location: string | URL,\n  opts?: DetectSnapLocationOptions,\n): SnapLocation {\n  const allowHttp = opts?.allowHttp ?? false;\n  const allowLocal = opts?.allowLocal ?? false;\n  const root = new URL(location);\n  switch (root.protocol) {\n    case 'npm:':\n      return new NpmLocation(root, opts);\n    case 'local:':\n      assert(allowLocal, new TypeError('Fetching local snaps is disabled.'));\n      return new LocalLocation(root, opts);\n    case 'http:':\n    case 'https:':\n      assert(\n        allowHttp,\n        new TypeError('Fetching snaps through http/https is disabled.'),\n      );\n      return new HttpLocation(root, opts);\n    default:\n      throw new TypeError(\n        `Unrecognized \"${root.protocol}\" snap location protocol.`,\n      );\n  }\n}\n"],"names":["assert","HttpLocation","LocalLocation","NpmLocation","detectSnapLocation","location","opts","allowHttp","allowLocal","root","URL","protocol","TypeError"],"mappings":"AAEA,SAASA,MAAM,QAAQ,kBAAkB;AAEzC,SAASC,YAAY,QAAQ,SAAS;AACtC,SAASC,aAAa,QAAQ,UAAU;AAExC,SAASC,WAAW,QAAQ,QAAQ;AAwCpC;;;;;;CAMC,GACD,OAAO,SAASC,mBACdC,QAAsB,EACtBC,IAAgC;IAEhC,MAAMC,YAAYD,MAAMC,aAAa;IACrC,MAAMC,aAAaF,MAAME,cAAc;IACvC,MAAMC,OAAO,IAAIC,IAAIL;IACrB,OAAQI,KAAKE,QAAQ;QACnB,KAAK;YACH,OAAO,IAAIR,YAAYM,MAAMH;QAC/B,KAAK;YACHN,OAAOQ,YAAY,IAAII,UAAU;YACjC,OAAO,IAAIV,cAAcO,MAAMH;QACjC,KAAK;QACL,KAAK;YACHN,OACEO,WACA,IAAIK,UAAU;YAEhB,OAAO,IAAIX,aAAaQ,MAAMH;QAChC;YACE,MAAM,IAAIM,UACR,CAAC,cAAc,EAAEH,KAAKE,QAAQ,CAAC,yBAAyB,CAAC;IAE/D;AACF"}

package/dist/esm/snaps/location/npm.js

@@ -1,373 +0,0 @@
-function _check_private_redeclaration(obj, privateCollection) {
-    if (privateCollection.has(obj)) {
-        throw new TypeError("Cannot initialize the same private elements twice on an object");
-    }
-}
-function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
-    return descriptor.value;
-}
-function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
-        if (!descriptor.writable) {
-            throw new TypeError("attempted to set read only private field");
-        }
-        descriptor.value = value;
-    }
-}
-function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
-    return privateMap.get(receiver);
-}
-function _class_private_field_get(receiver, privateMap) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-    return _class_apply_descriptor_get(receiver, descriptor);
-}
-function _class_private_field_init(obj, privateMap, value) {
-    _check_private_redeclaration(obj, privateMap);
-    privateMap.set(obj, value);
-}
-function _class_private_field_set(receiver, privateMap, value) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
-    _class_apply_descriptor_set(receiver, descriptor, value);
-    return value;
-}
-function _class_private_method_get(receiver, privateSet, fn) {
-    if (!privateSet.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return fn;
-}
-function _class_private_method_init(obj, privateSet) {
-    _check_private_redeclaration(obj, privateSet);
-    privateSet.add(obj);
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { createSnapManifest, DEFAULT_REQUESTED_SNAP_VERSION, getTargetVersion, isValidUrl, NpmSnapIdStruct, VirtualFile, normalizeRelative, parseJson } from '@metamask/snaps-utils';
-import { assert, assertIsSemVerVersion, assertStruct, isObject, isValidSemVerVersion } from '@metamask/utils';
-import { createGunzip } from 'browserify-zlib';
-import concat from 'concat-stream';
-import getNpmTarballUrl from 'get-npm-tarball-url';
-import { pipeline } from 'readable-stream';
-import { ReadableWebToNodeStream } from 'readable-web-to-node-stream';
-import { extract as tarExtract } from 'tar-stream';
-export const DEFAULT_NPM_REGISTRY = new URL('https://registry.npmjs.org');
-var _validatedManifest = /*#__PURE__*/ new WeakMap(), _files = /*#__PURE__*/ new WeakMap(), _lazyInit = /*#__PURE__*/ new WeakSet();
-// Base class for NPM implementation, useful for extending with custom NPM fetching logic
-export class BaseNpmLocation {
-    async manifest() {
-        if (_class_private_field_get(this, _validatedManifest)) {
-            return _class_private_field_get(this, _validatedManifest).clone();
-        }
-        const vfile = await this.fetch('snap.manifest.json');
-        const result = parseJson(vfile.toString());
-        vfile.result = createSnapManifest(result);
-        _class_private_field_set(this, _validatedManifest, vfile);
-        return this.manifest();
-    }
-    async fetch(path) {
-        const relativePath = normalizeRelative(path);
-        if (!_class_private_field_get(this, _files)) {
-            await _class_private_method_get(this, _lazyInit, lazyInit).call(this);
-            assert(_class_private_field_get(this, _files) !== undefined);
-        }
-        const vfile = _class_private_field_get(this, _files).get(relativePath);
-        assert(vfile !== undefined, new TypeError(`File "${path}" not found in package.`));
-        return vfile.clone();
-    }
-    get packageName() {
-        return this.meta.packageName;
-    }
-    get version() {
-        assert(this.meta.version !== undefined, 'Tried to access version without first fetching NPM package.');
-        return this.meta.version;
-    }
-    get registry() {
-        return this.meta.registry;
-    }
-    get versionRange() {
-        return this.meta.requestedRange;
-    }
-    constructor(url, opts = {}){
-        _class_private_method_init(this, _lazyInit);
-        _define_property(this, "meta", void 0);
-        _class_private_field_init(this, _validatedManifest, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_init(this, _files, {
-            writable: true,
-            value: void 0
-        });
-        const allowCustomRegistries = opts.allowCustomRegistries ?? false;
-        const fetchFunction = opts.fetch ?? globalThis.fetch.bind(globalThis);
-        const requestedRange = opts.versionRange ?? DEFAULT_REQUESTED_SNAP_VERSION;
-        const defaultResolve = async (range)=>range;
-        const resolveVersion = opts.resolveVersion ?? defaultResolve;
-        assertStruct(url.toString(), NpmSnapIdStruct, 'Invalid Snap Id: ');
-        let registry;
-        if (url.host === '' && url.port === '' && url.username === '' && url.password === '') {
-            registry = DEFAULT_NPM_REGISTRY;
-        } else {
-            registry = 'https://';
-            if (url.username) {
-                registry += url.username;
-                if (url.password) {
-                    registry += `:${url.password}`;
-                }
-                registry += '@';
-            }
-            registry += url.host;
-            registry = new URL(registry);
-            assert(allowCustomRegistries, new TypeError(`Custom NPM registries are disabled, tried to use "${registry.toString()}".`));
-        }
-        assert(registry.pathname === '/' && registry.search === '' && registry.hash === '');
-        assert(url.pathname !== '' && url.pathname !== '/', new TypeError('The package name in NPM location is empty.'));
-        let packageName = url.pathname;
-        if (packageName.startsWith('/')) {
-            packageName = packageName.slice(1);
-        }
-        this.meta = {
-            requestedRange,
-            registry,
-            packageName,
-            fetch: fetchFunction,
-            resolveVersion
-        };
-    }
-}
-async function lazyInit() {
-    assert(_class_private_field_get(this, _files) === undefined);
-    const resolvedVersion = await this.meta.resolveVersion(this.meta.requestedRange);
-    const { tarballURL, targetVersion } = await resolveNpmVersion(this.meta.packageName, resolvedVersion, this.meta.registry, this.meta.fetch);
-    if (!isValidUrl(tarballURL) || !tarballURL.toString().endsWith('.tgz')) {
-        throw new Error(`Failed to find valid tarball URL in NPM metadata for package "${this.meta.packageName}".`);
-    }
-    // Override the tarball hostname/protocol with registryUrl hostname/protocol
-    const newTarballUrl = new URL(tarballURL);
-    newTarballUrl.hostname = this.meta.registry.hostname;
-    newTarballUrl.protocol = this.meta.registry.protocol;
-    const files = await this.fetchNpmTarball(newTarballUrl);
-    _class_private_field_set(this, _files, files);
-    this.meta.version = targetVersion;
-}
-// Safety limit for tarballs, 250 MB in bytes
-export const TARBALL_SIZE_SAFETY_LIMIT = 262144000;
-// Main NPM implementation, contains a browser tarball fetching implementation.
-export class NpmLocation extends BaseNpmLocation {
-    /**
-   * Fetches and unpacks the tarball (`.tgz` file) from the specified URL.
-   *
-   * @param tarballUrl - The tarball URL to fetch and unpack.
-   * @returns A the files for the package tarball.
-   * @throws If fetching the tarball fails.
-   */ async fetchNpmTarball(tarballUrl) {
-        // Perform a raw fetch because we want the Response object itself.
-        const tarballResponse = await this.meta.fetch(tarballUrl.toString());
-        if (!tarballResponse.ok || !tarballResponse.body) {
-            throw new Error(`Failed to fetch tarball for package "${this.meta.packageName}".`);
-        }
-        // We assume that NPM is a good actor and provides us with a valid `content-length` header.
-        const tarballSizeString = tarballResponse.headers.get('content-length');
-        assert(tarballSizeString, 'Snap tarball has invalid content-length');
-        const tarballSize = parseInt(tarballSizeString, 10);
-        assert(tarballSize <= TARBALL_SIZE_SAFETY_LIMIT, 'Snap tarball exceeds size limit');
-        return new Promise((resolve, reject)=>{
-            const files = new Map();
-            const tarballStream = createTarballStream(getNpmCanonicalBasePath(this.meta.registry, this.meta.packageName), files);
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const body = tarballResponse.body;
-            // The "gz" in "tgz" stands for "gzip". The tarball needs to be decompressed
-            // before we can actually grab any files from it.
-            // To prevent recursion-based zip bombs, we should not allow recursion here.
-            // If native decompression stream is available we use that, otherwise fallback to zlib.
-            if ('pipeThrough' in body && 'DecompressionStream' in globalThis) {
-                const decompressionStream = new DecompressionStream('gzip');
-                const decompressedStream = body.pipeThrough(decompressionStream);
-                pipeline(getNodeStream(decompressedStream), tarballStream, (error)=>{
-                    error ? reject(error) : resolve(files);
-                });
-                return;
-            }
-            pipeline(getNodeStream(body), createGunzip(), tarballStream, (error)=>{
-                error ? reject(error) : resolve(files);
-            });
-        });
-    }
-}
-/**
- * Fetches the NPM metadata of the specified package from
- * the public npm registry.
- *
- * @param packageName - The name of the package whose metadata to fetch.
- * @param registryUrl - The URL of the npm registry to fetch the metadata from.
- * @param fetchFunction - The fetch function to use. Defaults to the global
- * {@link fetch}. Useful for Node.js compatibility.
- * @returns The NPM metadata object.
- * @throws If fetching the metadata fails.
- */ export async function fetchNpmMetadata(packageName, registryUrl, fetchFunction) {
-    const packageResponse = await fetchFunction(new URL(packageName, registryUrl).toString(), {
-        headers: {
-            // Corgi format is slightly smaller: https://github.com/npm/pacote/blob/main/lib/registry.js#L71
-            accept: isNPM(registryUrl) ? 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*' : 'application/json'
-        }
-    });
-    if (!packageResponse.ok) {
-        throw new Error(`Failed to fetch NPM registry entry. Status code: ${packageResponse.status}.`);
-    }
-    const packageMetadata = await packageResponse.json();
-    if (!isObject(packageMetadata)) {
-        throw new Error(`Failed to fetch package "${packageName}" metadata from npm.`);
-    }
-    return packageMetadata;
-}
-/**
- * Gets the canonical base path for an NPM snap.
- *
- * @param registryUrl - A registry URL.
- * @param packageName - A package name.
- * @returns The canonical base path.
- */ export function getNpmCanonicalBasePath(registryUrl, packageName) {
-    let canonicalBase = 'npm://';
-    if (registryUrl.username !== '') {
-        canonicalBase += registryUrl.username;
-        if (registryUrl.password !== '') {
-            canonicalBase += `:${registryUrl.password}`;
-        }
-        canonicalBase += '@';
-    }
-    return `${canonicalBase}${registryUrl.host}/${packageName}/`;
-}
-/**
- * Determine if a registry URL is NPM.
- *
- * @param registryUrl - A registry url.
- * @returns True if the registry is the NPM registry, otherwise false.
- */ function isNPM(registryUrl) {
-    return registryUrl.toString() === DEFAULT_NPM_REGISTRY.toString();
-}
-/**
- * Resolves a version range to a version using the NPM registry.
- *
- * Unless the version range is already a version, then the NPM registry is skipped.
- *
- * @param packageName - The name of the package whose metadata to fetch.
- * @param versionRange - The version range of the package.
- * @param registryUrl - The URL of the npm registry to fetch the metadata from.
- * @param fetchFunction - The fetch function to use. Defaults to the global
- * {@link fetch}. Useful for Node.js compatibility.
- * @returns An object containing the resolved version and a URL for its tarball.
- * @throws If fetching the metadata fails.
- */ async function resolveNpmVersion(packageName, versionRange, registryUrl, fetchFunction) {
-    // If the version range is already a static version we don't need to look for the metadata.
-    if (isNPM(registryUrl) && isValidSemVerVersion(versionRange)) {
-        return {
-            tarballURL: getNpmTarballUrl(packageName, versionRange),
-            targetVersion: versionRange
-        };
-    }
-    const packageMetadata = await fetchNpmMetadata(packageName, registryUrl, fetchFunction);
-    const versions = Object.keys(packageMetadata?.versions ?? {}).map((version)=>{
-        assertIsSemVerVersion(version);
-        return version;
-    });
-    const targetVersion = getTargetVersion(versions, versionRange);
-    if (targetVersion === null) {
-        throw new Error(`Failed to find a matching version in npm metadata for package "${packageName}" and requested semver range "${versionRange}".`);
-    }
-    const tarballURL = packageMetadata?.versions?.[targetVersion]?.dist?.tarball;
-    return {
-        tarballURL,
-        targetVersion
-    };
-}
-/**
- * The paths of files within npm tarballs appear to always be prefixed with
- * "package/".
- */ const NPM_TARBALL_PATH_PREFIX = /^package\//u;
-/**
- * Converts a {@link ReadableStream} to a Node.js {@link Readable}
- * stream. Returns the stream directly if it is already a Node.js stream.
- * We can't use the native Web {@link ReadableStream} directly because the
- * other stream libraries we use expect Node.js streams.
- *
- * @param stream - The stream to convert.
- * @returns The given stream as a Node.js Readable stream.
- */ function getNodeStream(stream) {
-    if (typeof stream.getReader !== 'function') {
-        return stream;
-    }
-    return new ReadableWebToNodeStream(stream);
-}
-/**
- * Creates a `tar-stream` that will get the necessary files from an npm Snap
- * package tarball (`.tgz` file).
- *
- * @param canonicalBase - A base URI as specified in {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8}. Starting with 'npm:'. Will be used for canonicalPath vfile argument.
- * @param files - An object to write target file contents to.
- * @returns The {@link Writable} tarball extraction stream.
- */ function createTarballStream(canonicalBase, files) {
-    assert(canonicalBase.endsWith('/'), "Base needs to end with '/' for relative paths to be added as children instead of siblings.");
-    assert(canonicalBase.startsWith('npm:'), 'Protocol mismatch, expected "npm:".');
-    // `tar-stream` is pretty old-school, so we create it first and then
-    // instrument it by adding event listeners.
-    const extractStream = tarExtract();
-    let totalSize = 0;
-    // "entry" is fired for every discreet entity in the tarball. This includes
-    // files and folders.
-    extractStream.on('entry', (header, entryStream, next)=>{
-        const { name: headerName, type: headerType } = header;
-        if (headerType === 'file') {
-            // The name is a path if the header type is "file".
-            const path = headerName.replace(NPM_TARBALL_PATH_PREFIX, '');
-            return entryStream.pipe(concat({
-                encoding: 'uint8array'
-            }, (data)=>{
-                try {
-                    totalSize += data.byteLength;
-                    // To prevent zip bombs, we set a safety limit for the total size of tarballs.
-                    assert(totalSize < TARBALL_SIZE_SAFETY_LIMIT, `Snap tarball exceeds limit of ${TARBALL_SIZE_SAFETY_LIMIT} bytes.`);
-                    const vfile = new VirtualFile({
-                        value: data,
-                        path,
-                        data: {
-                            canonicalPath: new URL(path, canonicalBase).toString()
-                        }
-                    });
-                    // We disallow files having identical paths as it may confuse our checksum calculations.
-                    assert(!files.has(path), 'Malformed tarball, multiple files with the same path.');
-                    files.set(path, vfile);
-                    return next();
-                } catch (error) {
-                    return extractStream.destroy(error);
-                }
-            }));
-        }
-        // If we get here, the entry is not a file, and we want to ignore. The entry
-        // stream must be drained, or the extractStream will stop reading. This is
-        // effectively a no-op for the current entry.
-        entryStream.on('end', ()=>next());
-        return entryStream.resume();
-    });
-    return extractStream;
-}
-
-//# sourceMappingURL=npm.js.map