@resourcexjs/core 0.4.0 → 0.7.0

package/dist/index.js

@@ -6,521 +6,406 @@ class ResourceXError extends Error {
   }
 }
 
-class ParseError extends ResourceXError {
-  url;
-  constructor(message, url) {
+class LocatorError extends ResourceXError {
+  locator;
+  constructor(message, locator) {
     super(message);
-    this.url = url;
-    this.name = "ParseError";
+    this.locator = locator;
+    this.name = "LocatorError";
   }
 }
 
-class TransportError extends ResourceXError {
-  transport;
-  constructor(message, transport, options) {
-    super(message, options);
-    this.transport = transport;
-    this.name = "TransportError";
+class ManifestError extends ResourceXError {
+  constructor(message) {
+    super(message);
+    this.name = "ManifestError";
   }
 }
 
-class SemanticError extends ResourceXError {
-  semantic;
-  constructor(message, semantic, options) {
-    super(message, options);
-    this.semantic = semantic;
-    this.name = "SemanticError";
+class ContentError extends ResourceXError {
+  constructor(message) {
+    super(message);
+    this.name = "ContentError";
   }
 }
-// src/parser.ts
-function parseARP(url) {
-  if (!url.startsWith("arp:")) {
-    throw new ParseError(`Invalid ARP URL: must start with "arp:"`, url);
-  }
-  const content = url.substring(4);
-  const separatorIndex = content.indexOf("://");
-  if (separatorIndex === -1) {
-    throw new ParseError(`Invalid ARP URL: missing "://"`, url);
-  }
-  const typePart = content.substring(0, separatorIndex);
-  const location = content.substring(separatorIndex + 3);
-  const colonIndex = typePart.indexOf(":");
-  if (colonIndex === -1) {
-    throw new ParseError(`Invalid ARP URL: must have exactly 2 types (semantic:transport)`, url);
-  }
-  const semantic = typePart.substring(0, colonIndex);
-  const transport = typePart.substring(colonIndex + 1);
-  if (!semantic) {
-    throw new ParseError(`Invalid ARP URL: semantic type cannot be empty`, url);
-  }
-  if (!transport) {
-    throw new ParseError(`Invalid ARP URL: transport type cannot be empty`, url);
-  }
-  if (!location) {
-    throw new ParseError(`Invalid ARP URL: location cannot be empty`, url);
-  }
-  return { semantic, transport, location };
+
+class ResourceTypeError extends ResourceXError {
+  constructor(message) {
+    super(message);
+    this.name = "ResourceTypeError";
+  }
 }
-// src/transport/http.ts
-class HttpTransportHandler {
+// src/locator/parseRXL.ts
+class RXLImpl {
+  domain;
+  path;
   name;
-  protocol;
-  capabilities = {
-    canRead: true,
-    canWrite: false,
-    canList: false,
-    canDelete: false,
-    canStat: false
-  };
-  constructor(protocol = "https") {
-    this.protocol = protocol;
-    this.name = protocol;
-  }
-  async read(location) {
-    const url = `${this.protocol}://${location}`;
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new TransportError(`HTTP ${response.status}: ${response.statusText} - ${url}`, this.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 + "/";
       }
-      const arrayBuffer = await response.arrayBuffer();
-      return Buffer.from(arrayBuffer);
-    } catch (error) {
-      if (error instanceof TransportError) {
-        throw error;
-      }
-      throw new TransportError(`Network error: ${url}`, this.name, {
-        cause: error
-      });
     }
+    result += this.name;
+    if (this.type) {
+      result += "." + this.type;
+    }
+    if (this.version) {
+      result += "@" + this.version;
+    }
+    return result;
   }
 }
-var httpsHandler = new HttpTransportHandler("https");
-var httpHandler = new HttpTransportHandler("http");
-// src/transport/file.ts
-import { readFile, writeFile, readdir, mkdir, rm, access, stat as fsStat } from "node:fs/promises";
-import { resolve, dirname } from "node:path";
-class FileTransportHandler {
-  name = "file";
-  capabilities = {
-    canRead: true,
-    canWrite: true,
-    canList: true,
-    canDelete: true,
-    canStat: true
-  };
-  resolvePath(location) {
-    return resolve(process.cwd(), location);
-  }
-  async read(location) {
-    const filePath = this.resolvePath(location);
-    try {
-      return await readFile(filePath);
-    } catch (error) {
-      const err = error;
-      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.name, {
-        cause: err
-      });
+function isDomain(str) {
+  if (str === "localhost")
+    return true;
+  return str.includes(".");
+}
+function parseRXL(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 && isDomain(segments[0])) {
+    domain = segments[0];
+    const lastSegment = segments[segments.length - 1];
+    if (segments.length > 2) {
+      path = segments.slice(1, -1).join("/");
     }
-  }
-  async write(location, content) {
-    const filePath = this.resolvePath(location);
-    try {
-      await mkdir(dirname(filePath), { recursive: true });
-      await writeFile(filePath, content);
-    } catch (error) {
-      const err = error;
-      throw new TransportError(`File write error: ${err.code} - ${filePath}`, this.name, {
-        cause: err
-      });
+    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 RXLImpl({ domain, path, name, type, version });
+}
+// src/manifest/createRXM.ts
+class RXMImpl {
+  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 + "/";
     }
-  }
-  async list(location) {
-    const dirPath = this.resolvePath(location);
-    try {
-      return await readdir(dirPath);
-    } catch (error) {
-      const err = error;
-      throw new TransportError(`Directory list error: ${err.code} - ${dirPath}`, this.name, {
-        cause: err
-      });
+    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;
   }
-  async mkdir(location) {
-    const dirPath = this.resolvePath(location);
-    try {
-      await mkdir(dirPath, { recursive: true });
-    } catch (error) {
-      const err = error;
-      throw new TransportError(`Directory create error: ${err.code} - ${dirPath}`, this.name, {
-        cause: err
-      });
+}
+function createRXM(data) {
+  if (!data.domain) {
+    throw new ManifestError("domain is required");
+  }
+  if (!data.name) {
+    throw new ManifestError("name is required");
+  }
+  if (!data.type) {
+    throw new ManifestError("type is required");
+  }
+  if (!data.version) {
+    throw new ManifestError("version is required");
+  }
+  return new RXMImpl({
+    domain: data.domain,
+    path: data.path,
+    name: data.name,
+    type: data.type,
+    version: data.version
+  });
+}
+// src/content/createRXC.ts
+class RXCImpl {
+  _stream;
+  _consumed = false;
+  constructor(stream) {
+    this._stream = stream;
+  }
+  get stream() {
+    if (this._consumed) {
+      throw new ContentError("Content has already been consumed");
     }
+    this._consumed = true;
+    return this._stream;
   }
-  async exists(location) {
-    const filePath = this.resolvePath(location);
-    try {
-      await access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
+  async text() {
+    const buffer = await this.buffer();
+    return buffer.toString("utf-8");
   }
-  async stat(location) {
-    const filePath = this.resolvePath(location);
-    try {
-      const stats = await fsStat(filePath);
-      return {
-        size: stats.size,
-        modifiedAt: stats.mtime,
-        isDirectory: stats.isDirectory()
-      };
-    } catch (error) {
-      const err = error;
-      throw new TransportError(`File stat error: ${err.code} - ${filePath}`, this.name, {
-        cause: err
-      });
+  async buffer() {
+    if (this._consumed) {
+      throw new ContentError("Content has already been consumed");
     }
-  }
-  async delete(location) {
-    const filePath = this.resolvePath(location);
-    try {
-      await rm(filePath, { recursive: true });
-    } catch (error) {
-      const err = error;
-      throw new TransportError(`File delete error: ${err.code} - ${filePath}`, this.name, {
-        cause: err
-      });
+    this._consumed = true;
+    const reader = this._stream.getReader();
+    const chunks = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      chunks.push(value);
     }
+    return Buffer.concat(chunks);
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
   }
 }
-var fileHandler = new FileTransportHandler;
-// src/transport/deepractice.ts
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { readFile as readFile2, writeFile as writeFile2, readdir as readdir2, access as access2, unlink, mkdir as mkdir2, stat, rm as rm2 } from "node:fs/promises";
-function deepracticeHandler(config = {}) {
-  const parentDir = config.parentDir || homedir();
-  const baseDir = join(parentDir, ".deepractice");
-  function resolvePath(location) {
-    return join(baseDir, location);
-  }
-  return {
-    name: "deepractice",
-    capabilities: {
-      canRead: true,
-      canWrite: true,
-      canList: true,
-      canDelete: true,
-      canStat: true
-    },
-    async read(location) {
-      const fullPath = resolvePath(location);
-      try {
-        return await readFile2(fullPath);
-      } catch (error) {
-        throw new TransportError(`Failed to read from deepractice: ${error.message}`, "deepractice", { cause: error });
-      }
-    },
-    async write(location, content) {
-      const fullPath = resolvePath(location);
-      try {
-        await mkdir2(join(fullPath, ".."), { recursive: true });
-        await writeFile2(fullPath, content);
-      } catch (error) {
-        throw new TransportError(`Failed to write to deepractice: ${error.message}`, "deepractice", { cause: error });
+function createRXC(data) {
+  let stream;
+  if (typeof data === "string") {
+    const encoded = new TextEncoder().encode(data);
+    stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoded);
+        controller.close();
       }
-    },
-    async list(location) {
-      const fullPath = resolvePath(location);
-      try {
-        return await readdir2(fullPath);
-      } catch (error) {
-        throw new TransportError(`Failed to list deepractice directory: ${error.message}`, "deepractice", { cause: error });
-      }
-    },
-    async exists(location) {
-      const fullPath = resolvePath(location);
-      try {
-        await access2(fullPath);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    async stat(location) {
-      const fullPath = resolvePath(location);
-      try {
-        const stats = await stat(fullPath);
-        return {
-          size: stats.size,
-          isDirectory: stats.isDirectory(),
-          modifiedAt: stats.mtime
-        };
-      } catch (error) {
-        throw new TransportError(`Failed to stat deepractice resource: ${error.message}`, "deepractice", { cause: error });
-      }
-    },
-    async delete(location) {
-      const fullPath = resolvePath(location);
-      try {
-        const stats = await stat(fullPath);
-        if (stats.isDirectory()) {
-          await rm2(fullPath, { recursive: true, force: true });
-        } else {
-          await unlink(fullPath);
-        }
-      } catch (error) {
-        throw new TransportError(`Failed to delete from deepractice: ${error.message}`, "deepractice", { cause: error });
+    });
+  } else if (Buffer.isBuffer(data)) {
+    stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(data));
+        controller.close();
       }
+    });
+  } else {
+    stream = data;
+  }
+  return new RXCImpl(stream);
+}
+// src/content/loadRXC.ts
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+async function loadRXC(source) {
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${source}: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error(`No body in response from ${source}`);
     }
-  };
+    return createRXC(response.body);
+  }
+  const nodeStream = createReadStream(source);
+  const webStream = Readable.toWeb(nodeStream);
+  return createRXC(webStream);
 }
-// src/transport/index.ts
-var handlers = new Map([
-  ["https", httpsHandler],
-  ["http", httpHandler],
-  ["file", fileHandler]
-]);
-function getTransportHandler(name) {
-  const handler = handlers.get(name);
-  if (!handler) {
-    throw new TransportError(`Unsupported transport type: ${name}`, name);
-  }
-  return handler;
+// src/resource/defineResourceType.ts
+var resourceTypes = new Map;
+function defineResourceType(config) {
+  if (resourceTypes.has(config.name)) {
+    throw new ResourceTypeError(`Resource type "${config.name}" is already registered`);
+  }
+  resourceTypes.set(config.name, config);
+  return config;
 }
-function registerTransportHandler(handler) {
-  handlers.set(handler.name, handler);
+function getResourceType(name) {
+  return resourceTypes.get(name);
 }
-// src/semantic/text.ts
-class TextSemanticHandler {
-  name = "text";
-  async resolve(transport, location, context) {
-    const buffer = await transport.read(location);
-    const text = buffer.toString("utf-8");
-    const meta = {
-      url: context.url,
-      semantic: context.semantic,
-      transport: context.transport,
-      location: context.location,
-      size: buffer.length,
-      encoding: "utf-8",
-      mimeType: "text/plain",
-      resolvedAt: context.timestamp.toISOString()
-    };
+function clearResourceTypes() {
+  resourceTypes.clear();
+}
+// src/resource/builtinTypes.ts
+var textSerializer = {
+  async serialize(rxr) {
+    const text = await rxr.content.text();
+    return Buffer.from(text, "utf-8");
+  },
+  async deserialize(data, manifest) {
+    const text = data.toString("utf-8");
     return {
-      type: "text",
-      content: text,
-      meta
+      locator: parseRXL(manifest.toLocator()),
+      manifest,
+      content: createRXC(text)
     };
   }
-  async deposit(transport, location, data, _context) {
-    if (!transport.write) {
-      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
-    }
-    const buffer = Buffer.from(data, "utf-8");
-    await transport.write(location, buffer);
+};
+var textResolver = {
+  async resolve(rxr) {
+    return rxr.content.text();
   }
-  async exists(transport, location, _context) {
-    if (transport.exists) {
-      return transport.exists(location);
-    }
-    try {
-      await transport.read(location);
-      return true;
-    } catch {
-      return false;
-    }
+};
+var textType = {
+  name: "text",
+  aliases: ["txt", "plaintext"],
+  description: "Plain text content",
+  serializer: textSerializer,
+  resolver: textResolver
+};
+var jsonSerializer = {
+  async serialize(rxr) {
+    const json = await rxr.content.json();
+    return Buffer.from(JSON.stringify(json, null, 2), "utf-8");
+  },
+  async deserialize(data, manifest) {
+    const text = data.toString("utf-8");
+    return {
+      locator: parseRXL(manifest.toLocator()),
+      manifest,
+      content: createRXC(text)
+    };
   }
-  async delete(transport, location, _context) {
-    if (!transport.delete) {
-      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
-    }
-    await transport.delete(location);
+};
+var jsonResolver = {
+  async resolve(rxr) {
+    return rxr.content.json();
   }
-}
-var textHandler = new TextSemanticHandler;
-// src/semantic/binary.ts
-function toBuffer(data) {
-  if (Buffer.isBuffer(data)) {
-    return data;
+};
+var jsonType = {
+  name: "json",
+  aliases: ["config", "manifest"],
+  description: "JSON content",
+  serializer: jsonSerializer,
+  resolver: jsonResolver
+};
+var binarySerializer = {
+  async serialize(rxr) {
+    return rxr.content.buffer();
+  },
+  async deserialize(data, manifest) {
+    return {
+      locator: parseRXL(manifest.toLocator()),
+      manifest,
+      content: createRXC(data)
+    };
   }
-  if (data instanceof Uint8Array) {
-    return Buffer.from(data);
+};
+var binaryResolver = {
+  async resolve(rxr) {
+    return rxr.content.buffer();
   }
-  if (data instanceof ArrayBuffer) {
-    return Buffer.from(data);
+};
+var binaryType = {
+  name: "binary",
+  aliases: ["bin", "blob", "raw"],
+  description: "Binary content",
+  serializer: binarySerializer,
+  resolver: binaryResolver
+};
+var builtinTypes = [textType, jsonType, binaryType];
+// src/resource/TypeHandlerChain.ts
+class TypeHandlerChain {
+  handlers = new Map;
+  register(type) {
+    this.handlers.set(type.name, type);
+    if (type.aliases) {
+      for (const alias of type.aliases) {
+        this.handlers.set(alias, type);
+      }
+    }
   }
-  if (Array.isArray(data)) {
-    return Buffer.from(data);
+  registerAll(types) {
+    for (const type of types) {
+      this.register(type);
+    }
   }
-  throw new SemanticError(`Unsupported binary input type`, "binary");
-}
-
-class BinarySemanticHandler {
-  name = "binary";
-  async resolve(transport, location, context) {
-    const buffer = await transport.read(location);
-    const meta = {
-      url: context.url,
-      semantic: context.semantic,
-      transport: context.transport,
-      location: context.location,
-      size: buffer.length,
-      resolvedAt: context.timestamp.toISOString()
-    };
-    return {
-      type: "binary",
-      content: buffer,
-      meta
-    };
+  canHandle(typeName) {
+    return this.handlers.has(typeName);
   }
-  async deposit(transport, location, data, _context) {
-    if (!transport.write) {
-      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
-    }
-    const buffer = toBuffer(data);
-    await transport.write(location, buffer);
+  getHandler(typeName) {
+    return this.handlers.get(typeName);
   }
-  async exists(transport, location, _context) {
-    if (transport.exists) {
-      return transport.exists(location);
+  async serialize(rxr) {
+    const typeName = rxr.manifest.type;
+    const handler = this.handlers.get(typeName);
+    if (!handler) {
+      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
     }
-    try {
-      await transport.read(location);
-      return true;
-    } catch {
-      return false;
+    return handler.serializer.serialize(rxr);
+  }
+  async deserialize(data, manifest) {
+    const typeName = manifest.type;
+    const handler = this.handlers.get(typeName);
+    if (!handler) {
+      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
     }
+    return handler.serializer.deserialize(data, manifest);
   }
-  async delete(transport, location, _context) {
-    if (!transport.delete) {
-      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+  async resolve(rxr) {
+    const typeName = rxr.manifest.type;
+    const handler = this.handlers.get(typeName);
+    if (!handler) {
+      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
     }
-    await transport.delete(location);
+    return handler.resolver.resolve(rxr);
   }
 }
-var binaryHandler = new BinarySemanticHandler;
-// src/semantic/index.ts
-var handlers2 = new Map([
-  ["text", textHandler],
-  ["binary", binaryHandler]
-]);
-function getSemanticHandler(name) {
-  const handler = handlers2.get(name);
-  if (!handler) {
-    throw new SemanticError(`Unsupported semantic type: ${name}`, name);
-  }
-  return handler;
-}
-function registerSemanticHandler(handler) {
-  handlers2.set(handler.name, handler);
-}
-// src/resolve.ts
-function createContext(url, semantic, transport, location) {
-  return {
-    url,
-    semantic,
-    transport,
-    location,
-    timestamp: new Date
-  };
-}
-async function resolve2(url) {
-  const parsed = parseARP(url);
-  const transport = getTransportHandler(parsed.transport);
-  const semantic = getSemanticHandler(parsed.semantic);
-  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
-  return semantic.resolve(transport, parsed.location, context);
-}
-async function deposit(url, data) {
-  const parsed = parseARP(url);
-  const transport = getTransportHandler(parsed.transport);
-  const semantic = getSemanticHandler(parsed.semantic);
-  if (!semantic.deposit) {
-    throw new SemanticError(`Semantic "${semantic.name}" does not support deposit operation`, parsed.semantic);
-  }
-  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
-  await semantic.deposit(transport, parsed.location, data, context);
-}
-async function resourceExists(url) {
-  const parsed = parseARP(url);
-  const transport = getTransportHandler(parsed.transport);
-  const semantic = getSemanticHandler(parsed.semantic);
-  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
-  if (semantic.exists) {
-    return semantic.exists(transport, parsed.location, context);
-  }
-  if (transport.exists) {
-    return transport.exists(parsed.location);
-  }
-  try {
-    await transport.read(parsed.location);
-    return true;
-  } catch {
-    return false;
+function createTypeHandlerChain(types) {
+  const chain = new TypeHandlerChain;
+  if (types) {
+    chain.registerAll(types);
   }
+  return chain;
 }
-async function resourceDelete(url) {
-  const parsed = parseARP(url);
-  const transport = getTransportHandler(parsed.transport);
-  const semantic = getSemanticHandler(parsed.semantic);
-  const context = createContext(url, parsed.semantic, parsed.transport, parsed.location);
-  if (semantic.delete) {
-    return semantic.delete(transport, parsed.location, context);
-  }
-  if (!transport.delete) {
-    throw new SemanticError(`Neither semantic "${semantic.name}" nor transport "${transport.name}" supports delete operation`, parsed.semantic);
-  }
-  await transport.delete(parsed.location);
-}
-// src/resource/registry.ts
-function createResourceRegistry() {
-  const registry = new Map;
-  return {
-    register(definition) {
-      if (!/^[a-z][a-z0-9-]*$/.test(definition.name)) {
-        throw new ParseError(`Invalid resource name: "${definition.name}". Must start with lowercase letter and contain only lowercase letters, numbers, and hyphens.`, definition.name);
-      }
-      getSemanticHandler(definition.semantic);
-      getTransportHandler(definition.transport);
-      registry.set(definition.name, definition);
-    },
-    get(name) {
-      return registry.get(name);
-    },
-    has(name) {
-      return registry.has(name);
-    },
-    clear() {
-      registry.clear();
-    }
-  };
-}
-// src/index.ts
-var VERSION = "0.4.0";
 export {
-  textHandler,
-  resourceExists,
-  resourceDelete,
-  resolve2 as resolve,
-  registerTransportHandler,
-  registerSemanticHandler,
-  parseARP,
-  httpsHandler,
-  httpHandler,
-  getTransportHandler,
-  getSemanticHandler,
-  fileHandler,
-  deposit,
-  deepracticeHandler,
-  createResourceRegistry,
-  binaryHandler,
-  VERSION,
-  TransportError,
-  SemanticError,
+  textType,
+  parseRXL,
+  loadRXC,
+  jsonType,
+  getResourceType,
+  defineResourceType,
+  createTypeHandlerChain,
+  createRXM,
+  createRXC,
+  clearResourceTypes,
+  builtinTypes,
+  binaryType,
+  TypeHandlerChain,
   ResourceXError,
-  ParseError
+  ResourceTypeError,
+  ManifestError,
+  LocatorError,
+  ContentError
 };
 
-//# debugId=7CEC90BE3B5822A664756E2164756E21
+//# debugId=B9B3CCB31ADA300B64756E2164756E21