@character-foundry/character-foundry 0.1.3 → 0.1.5

package/dist/core.js

@@ -1,2 +1,645 @@
-export * from '@character-foundry/core';
+// ../core/dist/index.js
+function readUInt32BE(data, offset) {
+  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+function writeUInt32BE(data, value, offset) {
+  data[offset] = value >>> 24 & 255;
+  data[offset + 1] = value >>> 16 & 255;
+  data[offset + 2] = value >>> 8 & 255;
+  data[offset + 3] = value & 255;
+}
+function readUInt16BE(data, offset) {
+  return (data[offset] << 8 | data[offset + 1]) >>> 0;
+}
+function writeUInt16BE(data, value, offset) {
+  data[offset] = value >>> 8 & 255;
+  data[offset + 1] = value & 255;
+}
+function indexOf(data, search, fromIndex = 0) {
+  outer: for (let i = fromIndex; i <= data.length - search.length; i++) {
+    for (let j = 0; j < search.length; j++) {
+      if (data[i + j] !== search[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function concat(...arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function slice(data, start, end) {
+  return data.subarray(start, end);
+}
+function copy(data, start, end) {
+  return data.slice(start, end);
+}
+function fromString(str) {
+  return new TextEncoder().encode(str);
+}
+function toString(data) {
+  return new TextDecoder().decode(data);
+}
+function fromLatin1(str) {
+  const result = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    result[i] = str.charCodeAt(i) & 255;
+  }
+  return result;
+}
+function toLatin1(data) {
+  let result = "";
+  for (let i = 0; i < data.length; i++) {
+    result += String.fromCharCode(data[i]);
+  }
+  return result;
+}
+function equals(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function alloc(size) {
+  return new Uint8Array(size);
+}
+function from(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  return new Uint8Array(data);
+}
+function isBinaryData(value) {
+  return value instanceof Uint8Array;
+}
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) {
+    if (Object.getPrototypeOf(data).constructor.name === "Buffer") {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return data;
+  }
+  return new Uint8Array(data);
+}
+function toHex(data) {
+  return Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fromHex(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+function encode(data) {
+  if (isNode) {
+    return Buffer.from(data).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < data.length; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  return btoa(binary);
+}
+function decode(base64) {
+  if (isNode) {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  const binary = atob(base64);
+  const result = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    result[i] = binary.charCodeAt(i);
+  }
+  return result;
+}
+function isBase64(str) {
+  if (str.length === 0) return false;
+  const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+  return base64Regex.test(str) && str.length % 4 === 0;
+}
+function encodeUrlSafe(data) {
+  return encode(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeUrlSafe(base64) {
+  let padded = base64.replace(/-/g, "+").replace(/_/g, "/");
+  while (padded.length % 4 !== 0) {
+    padded += "=";
+  }
+  return decode(padded);
+}
+var ENCODE_CHUNK_SIZE = 64 * 1024;
+function encodeChunked(data) {
+  if (isNode) {
+    return Buffer.from(data).toString("base64");
+  }
+  const chunks = [];
+  for (let i = 0; i < data.length; i += ENCODE_CHUNK_SIZE) {
+    const chunk = data.subarray(i, Math.min(i + ENCODE_CHUNK_SIZE, data.length));
+    let binary = "";
+    for (let j = 0; j < chunk.length; j++) {
+      binary += String.fromCharCode(chunk[j]);
+    }
+    chunks.push(binary);
+  }
+  return btoa(chunks.join(""));
+}
+var FOUNDRY_ERROR_MARKER = /* @__PURE__ */ Symbol.for("@character-foundry/core:FoundryError");
+var FoundryError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FoundryError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /** @internal Marker for cross-module identification */
+  [FOUNDRY_ERROR_MARKER] = true;
+};
+var ParseError = class extends FoundryError {
+  constructor(message, format) {
+    super(message, "PARSE_ERROR");
+    this.format = format;
+    this.name = "ParseError";
+  }
+};
+var ValidationError = class extends FoundryError {
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR");
+    this.field = field;
+    this.name = "ValidationError";
+  }
+};
+var AssetNotFoundError = class extends FoundryError {
+  constructor(uri) {
+    super(`Asset not found: ${uri}`, "ASSET_NOT_FOUND");
+    this.uri = uri;
+    this.name = "AssetNotFoundError";
+  }
+};
+var FormatNotSupportedError = class extends FoundryError {
+  constructor(format, operation) {
+    const msg = operation ? `Format '${format}' not supported for ${operation}` : `Format not supported: ${format}`;
+    super(msg, "FORMAT_NOT_SUPPORTED");
+    this.format = format;
+    this.name = "FormatNotSupportedError";
+  }
+};
+var SizeLimitError = class extends FoundryError {
+  constructor(actualSize, maxSize, context) {
+    const actualMB = (actualSize / 1024 / 1024).toFixed(2);
+    const maxMB = (maxSize / 1024 / 1024).toFixed(2);
+    const msg = context ? `${context}: Size ${actualMB}MB exceeds limit ${maxMB}MB` : `Size ${actualMB}MB exceeds limit ${maxMB}MB`;
+    super(msg, "SIZE_LIMIT_EXCEEDED");
+    this.actualSize = actualSize;
+    this.maxSize = maxSize;
+    this.name = "SizeLimitError";
+  }
+};
+var PathTraversalError = class extends FoundryError {
+  constructor(path) {
+    super(`Unsafe path detected: ${path}`, "PATH_TRAVERSAL");
+    this.path = path;
+    this.name = "PathTraversalError";
+  }
+};
+var DataLossError = class extends FoundryError {
+  constructor(lostFields, targetFormat) {
+    const fields = lostFields.slice(0, 3).join(", ");
+    const more = lostFields.length > 3 ? ` and ${lostFields.length - 3} more` : "";
+    super(
+      `Export to ${targetFormat} would lose: ${fields}${more}`,
+      "DATA_LOSS"
+    );
+    this.lostFields = lostFields;
+    this.targetFormat = targetFormat;
+    this.name = "DataLossError";
+  }
+};
+function isFoundryError(error) {
+  return error instanceof Error && FOUNDRY_ERROR_MARKER in error && error[FOUNDRY_ERROR_MARKER] === true;
+}
+function wrapError(error, context) {
+  if (isFoundryError(error)) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new FoundryError(
+    context ? `${context}: ${message}` : message,
+    "UNKNOWN_ERROR"
+  );
+}
+function toDataURL(buffer, mimeType) {
+  const base64 = encodeChunked(buffer);
+  return `data:${mimeType};base64,${base64}`;
+}
+function fromDataURL(dataUrl) {
+  if (!dataUrl.startsWith("data:")) {
+    throw new ValidationError('Invalid data URL: must start with "data:"', "dataUrl");
+  }
+  const commaIndex = dataUrl.indexOf(",");
+  if (commaIndex === -1) {
+    throw new ValidationError("Invalid data URL: missing comma separator", "dataUrl");
+  }
+  const header = dataUrl.slice(5, commaIndex);
+  const data = dataUrl.slice(commaIndex + 1);
+  let mimeType = "text/plain";
+  let isBase642 = false;
+  const parts = header.split(";");
+  for (const part of parts) {
+    if (part === "base64") {
+      isBase642 = true;
+    } else if (part && !part.includes("=")) {
+      mimeType = part;
+    }
+  }
+  if (!isBase642) {
+    throw new ValidationError("Non-base64 data URLs are not supported", "dataUrl");
+  }
+  const buffer = decode(data);
+  return { buffer, mimeType };
+}
+function isDataURL(str) {
+  if (!str.startsWith("data:")) return false;
+  const commaIndex = str.indexOf(",");
+  if (commaIndex === -1) return false;
+  const header = str.slice(5, commaIndex);
+  return header.includes("base64");
+}
+function normalizeURI(uri) {
+  const trimmed = uri.trim();
+  if (trimmed.startsWith("embedded://")) {
+    return "embeded://" + trimmed.substring("embedded://".length);
+  }
+  if (trimmed.startsWith("__asset:")) {
+    const id = trimmed.substring("__asset:".length);
+    return `pngchunk:${id}`;
+  }
+  if (trimmed.startsWith("asset:")) {
+    const id = trimmed.substring("asset:".length);
+    return `pngchunk:${id}`;
+  }
+  if (trimmed.startsWith("chara-ext-asset_:")) {
+    const id = trimmed.substring("chara-ext-asset_:".length);
+    return `pngchunk:${id}`;
+  }
+  if (trimmed.startsWith("chara-ext-asset_")) {
+    const id = trimmed.substring("chara-ext-asset_".length);
+    return `pngchunk:${id}`;
+  }
+  return trimmed;
+}
+function parseURI(uri) {
+  const trimmed = uri.trim();
+  const normalized = normalizeURI(trimmed);
+  if (trimmed.startsWith("__asset:") || trimmed.startsWith("asset:") || trimmed.startsWith("chara-ext-asset_") || trimmed.startsWith("pngchunk:")) {
+    let assetId;
+    if (trimmed.startsWith("__asset:")) {
+      assetId = trimmed.substring("__asset:".length);
+    } else if (trimmed.startsWith("asset:")) {
+      assetId = trimmed.substring("asset:".length);
+    } else if (trimmed.startsWith("chara-ext-asset_:")) {
+      assetId = trimmed.substring("chara-ext-asset_:".length);
+    } else if (trimmed.startsWith("pngchunk:")) {
+      assetId = trimmed.substring("pngchunk:".length);
+    } else {
+      assetId = trimmed.substring("chara-ext-asset_".length);
+    }
+    const candidates = [
+      assetId,
+      // "0" or "filename.png"
+      trimmed,
+      // Original URI
+      `asset:${assetId}`,
+      // "asset:0"
+      `__asset:${assetId}`,
+      // "__asset:0"
+      `__asset_${assetId}`,
+      // "__asset_0"
+      `chara-ext-asset_${assetId}`,
+      // "chara-ext-asset_0"
+      `chara-ext-asset_:${assetId}`,
+      // "chara-ext-asset_:0"
+      `pngchunk:${assetId}`
+      // "pngchunk:0"
+    ];
+    return {
+      scheme: "pngchunk",
+      originalUri: uri,
+      normalizedUri: normalized,
+      chunkKey: assetId,
+      chunkCandidates: candidates
+    };
+  }
+  if (trimmed === "ccdefault:" || trimmed.startsWith("ccdefault:")) {
+    return {
+      scheme: "ccdefault",
+      originalUri: uri,
+      normalizedUri: normalized
+    };
+  }
+  if (trimmed.startsWith("embeded://") || trimmed.startsWith("embedded://")) {
+    const path = trimmed.startsWith("embeded://") ? trimmed.substring("embeded://".length) : trimmed.substring("embedded://".length);
+    return {
+      scheme: "embeded",
+      originalUri: uri,
+      normalizedUri: normalized,
+      path
+    };
+  }
+  if (trimmed.startsWith("https://")) {
+    return {
+      scheme: "https",
+      originalUri: uri,
+      normalizedUri: normalized,
+      url: trimmed
+    };
+  }
+  if (trimmed.startsWith("http://")) {
+    return {
+      scheme: "http",
+      originalUri: uri,
+      normalizedUri: normalized,
+      url: trimmed
+    };
+  }
+  if (trimmed.startsWith("data:")) {
+    const parsed = parseDataURI(trimmed);
+    return {
+      scheme: "data",
+      originalUri: uri,
+      normalizedUri: normalized,
+      ...parsed
+    };
+  }
+  if (trimmed.startsWith("file://")) {
+    const path = trimmed.substring("file://".length);
+    return {
+      scheme: "file",
+      originalUri: uri,
+      normalizedUri: normalized,
+      path
+    };
+  }
+  if (/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
+    return {
+      scheme: "internal",
+      originalUri: uri,
+      normalizedUri: normalized,
+      path: trimmed
+    };
+  }
+  return {
+    scheme: "unknown",
+    originalUri: uri,
+    normalizedUri: normalized
+  };
+}
+function parseDataURI(uri) {
+  const match = uri.match(/^data:([^;,]+)?(;base64)?,(.*)$/);
+  if (!match) {
+    return {};
+  }
+  return {
+    mimeType: match[1] || "text/plain",
+    encoding: match[2] ? "base64" : void 0,
+    data: match[3]
+  };
+}
+function isImageExt(ext) {
+  const imageExts = ["png", "jpg", "jpeg", "webp", "gif", "avif", "bmp", "svg"];
+  return imageExts.includes(ext.toLowerCase());
+}
+function isAudioExt(ext) {
+  const audioExts = ["mp3", "wav", "ogg", "flac", "m4a", "aac"];
+  return audioExts.includes(ext.toLowerCase());
+}
+function isVideoExt(ext) {
+  const videoExts = ["mp4", "webm", "avi", "mov", "mkv"];
+  return videoExts.includes(ext.toLowerCase());
+}
+function isURISafe(uri, options = {}) {
+  const parsed = parseURI(uri);
+  switch (parsed.scheme) {
+    case "embeded":
+    case "ccdefault":
+    case "internal":
+    case "data":
+    case "https":
+    case "pngchunk":
+      return true;
+    case "http":
+      return options.allowHttp === true;
+    case "file":
+      return options.allowFile === true;
+    case "unknown":
+    default:
+      return false;
+  }
+}
+function getExtensionFromURI(uri) {
+  const parsed = parseURI(uri);
+  if (parsed.path) {
+    const parts = parsed.path.split(".");
+    if (parts.length > 1) {
+      return parts[parts.length - 1].toLowerCase();
+    }
+  }
+  if (parsed.url) {
+    const urlParts = parsed.url.split("?")[0].split(".");
+    if (urlParts.length > 1) {
+      return urlParts[urlParts.length - 1].toLowerCase();
+    }
+  }
+  if (parsed.mimeType) {
+    return getExtFromMimeType(parsed.mimeType);
+  }
+  return "unknown";
+}
+function getMimeTypeFromExt(ext) {
+  const extToMime = {
+    // Images
+    "png": "image/png",
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "webp": "image/webp",
+    "gif": "image/gif",
+    "avif": "image/avif",
+    "svg": "image/svg+xml",
+    "bmp": "image/bmp",
+    "ico": "image/x-icon",
+    // Audio
+    "mp3": "audio/mpeg",
+    "wav": "audio/wav",
+    "ogg": "audio/ogg",
+    "flac": "audio/flac",
+    "m4a": "audio/mp4",
+    "aac": "audio/aac",
+    // Video
+    "mp4": "video/mp4",
+    "webm": "video/webm",
+    "avi": "video/x-msvideo",
+    "mov": "video/quicktime",
+    "mkv": "video/x-matroska",
+    // Text/Data
+    "json": "application/json",
+    "txt": "text/plain",
+    "html": "text/html",
+    "css": "text/css",
+    "js": "application/javascript"
+  };
+  return extToMime[ext.toLowerCase()] || "application/octet-stream";
+}
+function getExtFromMimeType(mimeType) {
+  const mimeToExt = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/webp": "webp",
+    "image/gif": "gif",
+    "image/avif": "avif",
+    "image/svg+xml": "svg",
+    "image/bmp": "bmp",
+    "image/x-icon": "ico",
+    "audio/mpeg": "mp3",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg",
+    "audio/flac": "flac",
+    "audio/mp4": "m4a",
+    "audio/aac": "aac",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "video/x-msvideo": "avi",
+    "video/quicktime": "mov",
+    "video/x-matroska": "mkv",
+    "application/json": "json",
+    "text/plain": "txt",
+    "text/html": "html",
+    "text/css": "css",
+    "application/javascript": "js"
+  };
+  return mimeToExt[mimeType] || "bin";
+}
+function buildDataURI(data, mimeType, isBase642 = true) {
+  if (isBase642) {
+    return `data:${mimeType};base64,${data}`;
+  }
+  return `data:${mimeType},${encodeURIComponent(data)}`;
+}
+function isAnimatedImage(data, mimeType) {
+  if (data.length > 12 && data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && // RIFF
+  data[8] === 87 && data[9] === 69 && data[10] === 66 && data[11] === 80) {
+    if (data[12] === 86 && data[13] === 80 && data[14] === 56 && data[15] === 88) {
+      const flags = data[20];
+      return (flags & 2) !== 0;
+    }
+    return false;
+  }
+  if (data.length > 8 && data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) {
+    const actlSig = fromLatin1("acTL");
+    const idatSig = fromLatin1("IDAT");
+    const actlIndex = indexOf(data, actlSig);
+    if (actlIndex === -1) return false;
+    const idatIndex = indexOf(data, idatSig);
+    return idatIndex === -1 || actlIndex < idatIndex;
+  }
+  if (data.length > 6 && data[0] === 71 && data[1] === 73 && data[2] === 70) {
+    const netscape = fromLatin1("NETSCAPE2.0");
+    return indexOf(data, netscape) !== -1;
+  }
+  return false;
+}
+function formatUUID(bytes) {
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function mathRandomUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    return formatUUID(bytes);
+  }
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "development") {
+    console.warn("[character-foundry/core] generateUUID: Using insecure Math.random() fallback");
+  }
+  return mathRandomUUID();
+}
+function isValidUUID(uuid) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid);
+}
+export {
+  AssetNotFoundError,
+  DataLossError,
+  FormatNotSupportedError,
+  FoundryError,
+  ParseError,
+  PathTraversalError,
+  SizeLimitError,
+  ValidationError,
+  alloc,
+  decode as base64Decode,
+  decodeUrlSafe as base64DecodeUrlSafe,
+  encode as base64Encode,
+  encodeChunked as base64EncodeChunked,
+  encodeUrlSafe as base64EncodeUrlSafe,
+  buildDataURI,
+  concat,
+  copy,
+  equals,
+  from,
+  fromDataURL,
+  fromHex,
+  fromLatin1,
+  fromString,
+  generateUUID,
+  getExtFromMimeType,
+  getExtensionFromURI,
+  getMimeTypeFromExt,
+  indexOf,
+  isAnimatedImage,
+  isAudioExt,
+  isBase64,
+  isBinaryData,
+  isDataURL,
+  isFoundryError,
+  isImageExt,
+  isURISafe,
+  isValidUUID,
+  isVideoExt,
+  normalizeURI,
+  parseURI,
+  readUInt16BE,
+  readUInt32BE,
+  slice,
+  toDataURL,
+  toHex,
+  toLatin1,
+  toString,
+  toUint8Array,
+  wrapError,
+  writeUInt16BE,
+  writeUInt32BE
+};
 //# sourceMappingURL=core.js.map