@carbonenginejs/runtime-resource 0.8.0 → 0.9.0

package/dist/formats/webm/index.js

@@ -1,2 +1,2 @@
-export { CjsWebmFormat, CjsWebmFormat as default } from './CjsWebmFormat.js';
-//# sourceMappingURL=index.js.map
+export { CjsWebmFormat, CjsWebmFormat as default } from './CjsWebmFormat.js';
+//# sourceMappingURL=index.js.map

package/dist/formats/webp/CjsWebpFormat.js

@@ -1,86 +1,86 @@
-import { DEFAULT_VALUES, normalizeValues, readWithValues, inspectWithValues, isSupportedWithValues, toJsonValue, isWebP, toBytes, OUTPUT_JSON, OUTPUT_RAW } from './core/helpers.js';
-
-const FORMAT_NAME = "CjsWebpFormat";
-class CjsWebpFormat {
-  #values = DEFAULT_VALUES;
-  constructor(options = {}) {
-    this.SetValues(options);
-  }
-  SetValues(options = {}) {
-    this.#values = normalizeValues(this.#values, {
-      inputType: "webp",
-      ...options
-    }, FORMAT_NAME);
-    return this;
-  }
-  GetValues(options = {}) {
-    return normalizeValues(this.#values, {
-      inputType: "webp",
-      ...options
-    }, FORMAT_NAME);
-  }
-  Read(input, options = {}) {
-    return readWithValues(input, this.GetValues(options));
-  }
-  async ReadAsync(input, options = {}) {
-    return this.Read(input, options);
-  }
-  Inspect(input, options = {}) {
-    return inspectWithValues(input, this.GetValues(options));
-  }
-  IsSupported(input, options = {}) {
-    return isSupportedWithValues(input, this.GetValues(options));
-  }
-  ToJSON(value) {
-    return toJsonValue(value);
-  }
-  static read(input, options = {}) {
-    return readWithValues(input, normalizeValues(DEFAULT_VALUES, {
-      inputType: "webp",
-      ...options
-    }, FORMAT_NAME));
-  }
-  static async readAsync(input, options = {}) {
-    return CjsWebpFormat.read(input, options);
-  }
-  static inspect(input, options = {}) {
-    return inspectWithValues(input, normalizeValues(DEFAULT_VALUES, {
-      inputType: "webp",
-      ...options
-    }, FORMAT_NAME));
-  }
-  static isSupported(input, options = {}) {
-    return isSupportedWithValues(input, normalizeValues(DEFAULT_VALUES, {
-      inputType: "webp",
-      ...options
-    }, FORMAT_NAME));
-  }
-  static toJSON(value) {
-    return toJsonValue(value);
-  }
-  static isWebP(input) {
-    try {
-      return isWebP(toBytes(input));
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Emit targets for this format (canonical frozen enum).
-   */
-  static Output = Object.freeze({
-    RAW: OUTPUT_RAW,
-    JSON: OUTPUT_JSON
-  });
-  static OUTPUT_WEBP_JSON = "webpJson";
-  static type = Object.freeze(["image"]);
-  static mediaTypes = Object.freeze(["image"]);
-  static inputTypes = Object.freeze(["webp"]);
-  static outputTypes = Object.freeze([]);
-  static debugOutputTypes = Object.freeze(["webpJson", OUTPUT_RAW]);
-  static implementationStatus = "metadata-only";
-}
-
-export { CjsWebpFormat };
-//# sourceMappingURL=CjsWebpFormat.js.map
+import { DEFAULT_VALUES, normalizeValues, readWithValues, inspectWithValues, isSupportedWithValues, toJsonValue, isWebP, toBytes, OUTPUT_JSON, OUTPUT_RAW } from './core/helpers.js';
+
+const FORMAT_NAME = "CjsWebpFormat";
+class CjsWebpFormat {
+  #values = DEFAULT_VALUES;
+  constructor(options = {}) {
+    this.SetValues(options);
+  }
+  SetValues(options = {}) {
+    this.#values = normalizeValues(this.#values, {
+      inputType: "webp",
+      ...options
+    }, FORMAT_NAME);
+    return this;
+  }
+  GetValues(options = {}) {
+    return normalizeValues(this.#values, {
+      inputType: "webp",
+      ...options
+    }, FORMAT_NAME);
+  }
+  Read(input, options = {}) {
+    return readWithValues(input, this.GetValues(options));
+  }
+  async ReadAsync(input, options = {}) {
+    return this.Read(input, options);
+  }
+  Inspect(input, options = {}) {
+    return inspectWithValues(input, this.GetValues(options));
+  }
+  IsSupported(input, options = {}) {
+    return isSupportedWithValues(input, this.GetValues(options));
+  }
+  ToJSON(value) {
+    return toJsonValue(value);
+  }
+  static read(input, options = {}) {
+    return readWithValues(input, normalizeValues(DEFAULT_VALUES, {
+      inputType: "webp",
+      ...options
+    }, FORMAT_NAME));
+  }
+  static async readAsync(input, options = {}) {
+    return CjsWebpFormat.read(input, options);
+  }
+  static inspect(input, options = {}) {
+    return inspectWithValues(input, normalizeValues(DEFAULT_VALUES, {
+      inputType: "webp",
+      ...options
+    }, FORMAT_NAME));
+  }
+  static isSupported(input, options = {}) {
+    return isSupportedWithValues(input, normalizeValues(DEFAULT_VALUES, {
+      inputType: "webp",
+      ...options
+    }, FORMAT_NAME));
+  }
+  static toJSON(value) {
+    return toJsonValue(value);
+  }
+  static isWebP(input) {
+    try {
+      return isWebP(toBytes(input));
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Emit targets for this format (canonical frozen enum).
+   */
+  static Output = Object.freeze({
+    RAW: OUTPUT_RAW,
+    JSON: OUTPUT_JSON
+  });
+  static OUTPUT_WEBP_JSON = "webpJson";
+  static type = Object.freeze(["image"]);
+  static mediaTypes = Object.freeze(["image"]);
+  static inputTypes = Object.freeze(["webp"]);
+  static outputTypes = Object.freeze([]);
+  static debugOutputTypes = Object.freeze(["webpJson", OUTPUT_RAW]);
+  static implementationStatus = "metadata-only";
+}
+
+export { CjsWebpFormat };
+//# sourceMappingURL=CjsWebpFormat.js.map

package/dist/formats/webp/core/helpers.js

@@ -1,214 +1,214 @@
-const OUTPUT_RAW = "raw";
-const OUTPUT_JSON = "json";
-const DEFAULT_VALUES = Object.freeze({
-  emit: OUTPUT_RAW,
-  inputType: "webp",
-  source: ""
-});
-function normalizeValues(base = DEFAULT_VALUES, options = {}, readerName = "CjsWebpFormat") {
-  if (!options || typeof options !== "object" || Array.isArray(options)) {
-    throw new TypeError(`${readerName}: options must be an object`);
-  }
-  const allowed = new Set(["emit", "inputType", "source"]);
-  for (const key of Object.keys(options)) {
-    if (!allowed.has(key)) throw new TypeError(`${readerName}: unknown option ${JSON.stringify(key)}`);
-  }
-  const values = {
-    ...DEFAULT_VALUES,
-    ...(base || {}),
-    ...options
-  };
-  if (![OUTPUT_RAW, OUTPUT_JSON, "webpJson"].includes(values.emit)) {
-    throw new TypeError(`${readerName}: unknown emit value ${JSON.stringify(values.emit)}`);
-  }
-  return values;
-}
-function toBytes(input) {
-  if (input instanceof Uint8Array) return input;
-  if (input instanceof ArrayBuffer) return new Uint8Array(input);
-  if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-  throw new TypeError("WebP input must be Uint8Array, ArrayBuffer, or a view");
-}
-function isWebP(bytes) {
-  return bytes.byteLength >= 12 && ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP";
-}
-function inspectWithValues(input, values = DEFAULT_VALUES, expectedType = "webp") {
-  const bytes = toBytes(input);
-  if (!isWebP(bytes)) throw new TypeError("CjsWebpFormat: input is not a RIFF WebP container");
-  const metadata = inspectWebP(bytes);
-  if (expectedType && metadata.sourceFormat !== expectedType) {
-    throw new TypeError(`CjsWebpFormat: expected ${expectedType}, got ${metadata.sourceFormat}`);
-  }
-  return {
-    ...metadata,
-    byteLength: bytes.byteLength,
-    source: values.source || "buffer"
-  };
-}
-function isSupportedWithValues(input, values = DEFAULT_VALUES) {
-  try {
-    const metadata = inspectWithValues(input, values);
-    return {
-      format: "webp",
-      source: values.source || "buffer",
-      supported: "partial",
-      confidence: 1,
-      preferred: "raw",
-      reason: "WebP container and image metadata are recognized; software RGBA decode is not implemented.",
-      metadata,
-      variants: [{
-        kind: "raw",
-        payloadType: "raw",
-        codec: "webp",
-        mimeType: "image/webp",
-        supported: true,
-        containerOnly: true,
-        isDecoded: false,
-        rgbaDecodeSupported: false
-      }, {
-        kind: "rgba",
-        payloadType: "rgba",
-        codec: "rgba8unorm",
-        supported: false,
-        reason: "WebP software RGBA decode is not implemented yet."
-      }],
-      warnings: [],
-      errors: []
-    };
-  } catch (error) {
-    return {
-      format: "webp",
-      source: values.source || "buffer",
-      supported: "none",
-      confidence: 0,
-      preferred: "",
-      reason: error.message,
-      metadata: null,
-      variants: [],
-      warnings: [],
-      errors: [error.message]
-    };
-  }
-}
-function readWithValues(input, values = DEFAULT_VALUES) {
-  const bytes = toBytes(input);
-  const metadata = inspectWithValues(bytes, values);
-  if (values.emit === OUTPUT_RAW) {
-    return {
-      payloadType: "raw",
-      sourceFormat: "webp",
-      mimeType: "image/webp",
-      containerOnly: true,
-      isDecoded: false,
-      rgbaDecodeSupported: false,
-      metadata,
-      bytes
-    };
-  }
-  if (values.emit === OUTPUT_JSON || values.emit === "webpJson") return metadata;
-  const error = new Error(`webp: emit "${values.emit}" is not implemented yet`);
-  error.code = "CJS_FORMAT_OUTPUT_NOT_IMPLEMENTED";
-  throw error;
-}
-function toJsonValue(value) {
-  if (value instanceof Uint8Array) return {
-    byteLength: value.byteLength
-  };
-  if (Array.isArray(value)) return value.map(toJsonValue);
-  if (value && typeof value === "object") {
-    const output = {};
-    for (const [key, entry] of Object.entries(value)) output[key] = toJsonValue(entry);
-    return output;
-  }
-  return value;
-}
-function inspectWebP(bytes) {
-  const riffLength = readU32LE(bytes, 4);
-  const chunks = [];
-  let width = 0;
-  let height = 0;
-  let codec = "webp";
-  let hasAlpha = false;
-  let animated = false;
-  const animationFrames = [];
-  let offset = 12;
-  while (offset + 8 <= bytes.byteLength) {
-    const type = ascii(bytes, offset, 4);
-    const size = readU32LE(bytes, offset + 4);
-    const dataOffset = offset + 8;
-    if (dataOffset + size > bytes.byteLength) throw new Error(`webp: ${type} chunk is truncated`);
-    chunks.push({
-      type,
-      byteOffset: dataOffset,
-      byteLength: size
-    });
-    if (type === "VP8 ") {
-      codec = "vp8";
-      if (size >= 10 && bytes[dataOffset + 3] === 0x9d && bytes[dataOffset + 4] === 0x01 && bytes[dataOffset + 5] === 0x2a) {
-        width = readU16LE(bytes, dataOffset + 6) & 0x3fff;
-        height = readU16LE(bytes, dataOffset + 8) & 0x3fff;
-      }
-    } else if (type === "VP8L") {
-      codec = "vp8l";
-      if (size >= 5 && bytes[dataOffset] === 0x2f) {
-        width = 1 + (bytes[dataOffset + 1] | (bytes[dataOffset + 2] & 0x3f) << 8);
-        height = 1 + (bytes[dataOffset + 2] >>> 6 | bytes[dataOffset + 3] << 2 | (bytes[dataOffset + 4] & 0x0f) << 10);
-        hasAlpha = true;
-      }
-    } else if (type === "VP8X") {
-      codec = "vp8x";
-      if (size >= 10) {
-        const flags = bytes[dataOffset];
-        hasAlpha = !!(flags & 0x10);
-        animated = !!(flags & 0x02);
-        width = 1 + readU24LE(bytes, dataOffset + 4);
-        height = 1 + readU24LE(bytes, dataOffset + 7);
-      }
-    } else if (type === "ALPH") hasAlpha = true;else if (type === "ANIM") animated = true;else if (type === "ANMF") {
-      animated = true;
-      if (size >= 16) {
-        animationFrames.push({
-          x: readU24LE(bytes, dataOffset),
-          y: readU24LE(bytes, dataOffset + 3),
-          width: 1 + readU24LE(bytes, dataOffset + 6),
-          height: 1 + readU24LE(bytes, dataOffset + 9),
-          durationMs: readU24LE(bytes, dataOffset + 12),
-          flags: bytes[dataOffset + 15]
-        });
-      }
-    }
-    offset = dataOffset + size + (size & 1);
-  }
-  return {
-    payloadType: "image",
-    mediaTypes: ["image"],
-    sourceFormat: "webp",
-    container: "riff",
-    riffLength,
-    codec,
-    width,
-    height,
-    hasAlpha,
-    animated,
-    animationFrameCount: animationFrames.length,
-    animationDurationMs: animationFrames.reduce((sum, frame) => sum + frame.durationMs, 0),
-    animationFrames,
-    isCompressed: true,
-    chunks
-  };
-}
-function ascii(bytes, offset, length) {
-  return String.fromCharCode(...bytes.subarray(offset, offset + length));
-}
-function readU16LE(bytes, offset) {
-  return bytes[offset] | bytes[offset + 1] << 8;
-}
-function readU24LE(bytes, offset) {
-  return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16;
-}
-function readU32LE(bytes, offset) {
-  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] * 0x1000000) >>> 0;
-}
-
-export { DEFAULT_VALUES, OUTPUT_JSON, OUTPUT_RAW, inspectWithValues, isSupportedWithValues, isWebP, normalizeValues, readWithValues, toBytes, toJsonValue };
-//# sourceMappingURL=helpers.js.map
+const OUTPUT_RAW = "raw";
+const OUTPUT_JSON = "json";
+const DEFAULT_VALUES = Object.freeze({
+  emit: OUTPUT_RAW,
+  inputType: "webp",
+  source: ""
+});
+function normalizeValues(base = DEFAULT_VALUES, options = {}, readerName = "CjsWebpFormat") {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError(`${readerName}: options must be an object`);
+  }
+  const allowed = new Set(["emit", "inputType", "source"]);
+  for (const key of Object.keys(options)) {
+    if (!allowed.has(key)) throw new TypeError(`${readerName}: unknown option ${JSON.stringify(key)}`);
+  }
+  const values = {
+    ...DEFAULT_VALUES,
+    ...(base || {}),
+    ...options
+  };
+  if (![OUTPUT_RAW, OUTPUT_JSON, "webpJson"].includes(values.emit)) {
+    throw new TypeError(`${readerName}: unknown emit value ${JSON.stringify(values.emit)}`);
+  }
+  return values;
+}
+function toBytes(input) {
+  if (input instanceof Uint8Array) return input;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  throw new TypeError("WebP input must be Uint8Array, ArrayBuffer, or a view");
+}
+function isWebP(bytes) {
+  return bytes.byteLength >= 12 && ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP";
+}
+function inspectWithValues(input, values = DEFAULT_VALUES, expectedType = "webp") {
+  const bytes = toBytes(input);
+  if (!isWebP(bytes)) throw new TypeError("CjsWebpFormat: input is not a RIFF WebP container");
+  const metadata = inspectWebP(bytes);
+  if (expectedType && metadata.sourceFormat !== expectedType) {
+    throw new TypeError(`CjsWebpFormat: expected ${expectedType}, got ${metadata.sourceFormat}`);
+  }
+  return {
+    ...metadata,
+    byteLength: bytes.byteLength,
+    source: values.source || "buffer"
+  };
+}
+function isSupportedWithValues(input, values = DEFAULT_VALUES) {
+  try {
+    const metadata = inspectWithValues(input, values);
+    return {
+      format: "webp",
+      source: values.source || "buffer",
+      supported: "partial",
+      confidence: 1,
+      preferred: "raw",
+      reason: "WebP container and image metadata are recognized; software RGBA decode is not implemented.",
+      metadata,
+      variants: [{
+        kind: "raw",
+        payloadType: "raw",
+        codec: "webp",
+        mimeType: "image/webp",
+        supported: true,
+        containerOnly: true,
+        isDecoded: false,
+        rgbaDecodeSupported: false
+      }, {
+        kind: "rgba",
+        payloadType: "rgba",
+        codec: "rgba8unorm",
+        supported: false,
+        reason: "WebP software RGBA decode is not implemented yet."
+      }],
+      warnings: [],
+      errors: []
+    };
+  } catch (error) {
+    return {
+      format: "webp",
+      source: values.source || "buffer",
+      supported: "none",
+      confidence: 0,
+      preferred: "",
+      reason: error.message,
+      metadata: null,
+      variants: [],
+      warnings: [],
+      errors: [error.message]
+    };
+  }
+}
+function readWithValues(input, values = DEFAULT_VALUES) {
+  const bytes = toBytes(input);
+  const metadata = inspectWithValues(bytes, values);
+  if (values.emit === OUTPUT_RAW) {
+    return {
+      payloadType: "raw",
+      sourceFormat: "webp",
+      mimeType: "image/webp",
+      containerOnly: true,
+      isDecoded: false,
+      rgbaDecodeSupported: false,
+      metadata,
+      bytes
+    };
+  }
+  if (values.emit === OUTPUT_JSON || values.emit === "webpJson") return metadata;
+  const error = new Error(`webp: emit "${values.emit}" is not implemented yet`);
+  error.code = "CJS_FORMAT_OUTPUT_NOT_IMPLEMENTED";
+  throw error;
+}
+function toJsonValue(value) {
+  if (value instanceof Uint8Array) return {
+    byteLength: value.byteLength
+  };
+  if (Array.isArray(value)) return value.map(toJsonValue);
+  if (value && typeof value === "object") {
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) output[key] = toJsonValue(entry);
+    return output;
+  }
+  return value;
+}
+function inspectWebP(bytes) {
+  const riffLength = readU32LE(bytes, 4);
+  const chunks = [];
+  let width = 0;
+  let height = 0;
+  let codec = "webp";
+  let hasAlpha = false;
+  let animated = false;
+  const animationFrames = [];
+  let offset = 12;
+  while (offset + 8 <= bytes.byteLength) {
+    const type = ascii(bytes, offset, 4);
+    const size = readU32LE(bytes, offset + 4);
+    const dataOffset = offset + 8;
+    if (dataOffset + size > bytes.byteLength) throw new Error(`webp: ${type} chunk is truncated`);
+    chunks.push({
+      type,
+      byteOffset: dataOffset,
+      byteLength: size
+    });
+    if (type === "VP8 ") {
+      codec = "vp8";
+      if (size >= 10 && bytes[dataOffset + 3] === 0x9d && bytes[dataOffset + 4] === 0x01 && bytes[dataOffset + 5] === 0x2a) {
+        width = readU16LE(bytes, dataOffset + 6) & 0x3fff;
+        height = readU16LE(bytes, dataOffset + 8) & 0x3fff;
+      }
+    } else if (type === "VP8L") {
+      codec = "vp8l";
+      if (size >= 5 && bytes[dataOffset] === 0x2f) {
+        width = 1 + (bytes[dataOffset + 1] | (bytes[dataOffset + 2] & 0x3f) << 8);
+        height = 1 + (bytes[dataOffset + 2] >>> 6 | bytes[dataOffset + 3] << 2 | (bytes[dataOffset + 4] & 0x0f) << 10);
+        hasAlpha = true;
+      }
+    } else if (type === "VP8X") {
+      codec = "vp8x";
+      if (size >= 10) {
+        const flags = bytes[dataOffset];
+        hasAlpha = !!(flags & 0x10);
+        animated = !!(flags & 0x02);
+        width = 1 + readU24LE(bytes, dataOffset + 4);
+        height = 1 + readU24LE(bytes, dataOffset + 7);
+      }
+    } else if (type === "ALPH") hasAlpha = true;else if (type === "ANIM") animated = true;else if (type === "ANMF") {
+      animated = true;
+      if (size >= 16) {
+        animationFrames.push({
+          x: readU24LE(bytes, dataOffset),
+          y: readU24LE(bytes, dataOffset + 3),
+          width: 1 + readU24LE(bytes, dataOffset + 6),
+          height: 1 + readU24LE(bytes, dataOffset + 9),
+          durationMs: readU24LE(bytes, dataOffset + 12),
+          flags: bytes[dataOffset + 15]
+        });
+      }
+    }
+    offset = dataOffset + size + (size & 1);
+  }
+  return {
+    payloadType: "image",
+    mediaTypes: ["image"],
+    sourceFormat: "webp",
+    container: "riff",
+    riffLength,
+    codec,
+    width,
+    height,
+    hasAlpha,
+    animated,
+    animationFrameCount: animationFrames.length,
+    animationDurationMs: animationFrames.reduce((sum, frame) => sum + frame.durationMs, 0),
+    animationFrames,
+    isCompressed: true,
+    chunks
+  };
+}
+function ascii(bytes, offset, length) {
+  return String.fromCharCode(...bytes.subarray(offset, offset + length));
+}
+function readU16LE(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8;
+}
+function readU24LE(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16;
+}
+function readU32LE(bytes, offset) {
+  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] * 0x1000000) >>> 0;
+}
+
+export { DEFAULT_VALUES, OUTPUT_JSON, OUTPUT_RAW, inspectWithValues, isSupportedWithValues, isWebP, normalizeValues, readWithValues, toBytes, toJsonValue };
+//# sourceMappingURL=helpers.js.map

package/dist/formats/webp/index.js

@@ -1,2 +1,2 @@
-export { CjsWebpFormat, CjsWebpFormat as default } from './CjsWebpFormat.js';
-//# sourceMappingURL=index.js.map
+export { CjsWebpFormat, CjsWebpFormat as default } from './CjsWebpFormat.js';
+//# sourceMappingURL=index.js.map