@ai-sdk/quiverai 2.0.43 → 2.0.45

package/dist/index.js

@@ -11,11 +11,12 @@ import {
 
 // src/quiverai-image-model.ts
 import {
-  InvalidArgumentError
+  InvalidArgumentError as InvalidArgumentError2
 } from "@ai-sdk/provider";
 import {
   combineHeaders,
-  convertUint8ArrayToBase64,
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   parseProviderOptions,
@@ -41,8 +42,12 @@ var quiveraiImageModelOptionsSchema = lazySchema(
        * - `generate`: Text-to-SVG generation. Requires `prompt`.
        * - `vectorize`: Convert an input raster image into an SVG. Requires a
        *   single image in `prompt.images` / `files`.
+       * - `animate`: Animate an input SVG. Requires a single SVG in
+       *   `prompt.images` / `files`; the text prompt is optional.
+       * - `edit`: Edit a single SVG from `prompt.images` using `prompt.text`
+       *   as the required instruction.
        */
-      operation: z.enum(["generate", "vectorize"]).optional(),
+      operation: z.enum(["generate", "vectorize", "animate", "edit"]).optional(),
       /**
        * Extra style guidance for prompt-based generation.
        */
@@ -51,6 +56,20 @@ var quiveraiImageModelOptionsSchema = lazySchema(
        * Reasoning effort applied to generation or vectorization.
        */
       reasoningEffort: z.enum(["low", "medium", "high", "xhigh"]).optional(),
+      /**
+       * Optional reference images for SVG editing. Use
+       * `prepareQuiverAIImageReference` to convert binary inputs.
+       */
+      referenceImages: z.array(
+        z.union([
+          z.object({ url: z.string().min(1) }).strict(),
+          z.object({ base64: z.string().min(1).max(16777216) }).strict()
+        ])
+      ).max(4).optional(),
+      /**
+       * Maximum number of edit review and redo steps (0-5).
+       */
+      maxReviewSteps: z.number().int().min(0).max(5).optional(),
       /**
        * SVG root attributes requested for generation or vectorization.
        */
@@ -79,6 +98,14 @@ var quiveraiImageModelOptionsSchema = lazySchema(
        * The legacy upper bound of 131072 is retained for other model IDs.
        */
       maxOutputTokens: z.number().int().min(1).max(131072).optional(),
+      /**
+       * Provider orchestrator token budget for SVG editing (1-65536).
+       */
+      orchestratorMaxOutputTokens: z.number().int().min(1).max(65536).optional(),
+      /**
+       * Provider shallow edit token budget for SVG editing (1-65536).
+       */
+      shallowMaxOutputTokens: z.number().int().min(1).max(65536).optional(),
       /**
        * Whether to auto-crop the input image before vectorization.
        * Only used when `operation` is `vectorize`.
@@ -93,6 +120,113 @@ var quiveraiImageModelOptionsSchema = lazySchema(
   )
 );
 
+// src/prepare-quiverai-image-reference.ts
+import { InvalidArgumentError } from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64,
+  detectMediaType
+} from "@ai-sdk/provider-utils";
+var MAX_REFERENCE_BASE64_LENGTH = 16777216;
+var MAX_REFERENCE_BYTES = 12582912;
+var supportedReferenceMediaTypes = /* @__PURE__ */ new Set([
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/svg+xml",
+  "image/webp"
+]);
+function prepareQuiverAIImageReference(input) {
+  if (input instanceof URL) {
+    return { url: validateQuiverAIImageUrl(input.toString()) };
+  }
+  if (typeof input === "string") {
+    if (/^[a-z][a-z\d+.-]*:\/\//i.test(input)) {
+      return { url: validateQuiverAIImageUrl(input) };
+    }
+    if (input.startsWith("data:")) {
+      const match = /^data:([^;,]+);base64,(.+)$/s.exec(input);
+      if (match == null || !supportedReferenceMediaTypes.has(match[1])) {
+        throw new InvalidArgumentError({
+          argument: "input",
+          message: "QuiverAI reference image data URLs must use base64 encoding and a supported image media type."
+        });
+      }
+      validateQuiverAIReferenceBase64(match[2], "input");
+      return { base64: match[2] };
+    }
+    validateQuiverAIReferenceBase64(input, "input");
+    return { base64: input };
+  }
+  const data = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input);
+  validateQuiverAIReferenceBytes(data, "input");
+  return { base64: convertUint8ArrayToBase64(data) };
+}
+function validateQuiverAIImageUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (e) {
+    throw new InvalidArgumentError({
+      argument: "url",
+      message: "QuiverAI image URLs must be valid HTTP or HTTPS URLs."
+    });
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new InvalidArgumentError({
+      argument: "url",
+      message: "QuiverAI image URLs must use HTTP or HTTPS."
+    });
+  }
+  return parsed.toString();
+}
+function validateQuiverAIReferenceBase64(base64, argument) {
+  if (base64.length === 0 || base64.length > MAX_REFERENCE_BASE64_LENGTH) {
+    throw new InvalidArgumentError({
+      argument,
+      message: `QuiverAI reference images must contain 1-${MAX_REFERENCE_BASE64_LENGTH} base64 characters.`
+    });
+  }
+  let data;
+  try {
+    data = convertBase64ToUint8Array(base64);
+  } catch (cause) {
+    throw new InvalidArgumentError({
+      argument,
+      message: "QuiverAI reference image data must be valid base64.",
+      cause
+    });
+  }
+  validateQuiverAIReferenceBytes(data, argument);
+}
+function validateQuiverAIReferenceBytes(data, argument) {
+  if (data.length === 0 || data.length > MAX_REFERENCE_BYTES) {
+    throw new InvalidArgumentError({
+      argument,
+      message: `QuiverAI reference images must decode to 1-${MAX_REFERENCE_BYTES} bytes.`
+    });
+  }
+  const mediaType = isSvg(data) ? "image/svg+xml" : detectMediaType({ data, topLevelType: "image" });
+  if (mediaType == null || !supportedReferenceMediaTypes.has(mediaType)) {
+    throw new InvalidArgumentError({
+      argument,
+      message: "QuiverAI reference images must be PNG, JPEG, WebP, GIF, or SVG data."
+    });
+  }
+}
+function isSvg(data) {
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(data);
+  } catch (e) {
+    return false;
+  }
+  const normalized = text.replace(/^\uFEFF/, "").trim();
+  return /^(?:<\?xml[\s\S]*?\?>\s*)?(?:<!--[\s\S]*?-->\s*)?(?:<!DOCTYPE[\s\S]*?>\s*)?<svg[\s>]/i.test(
+    normalized
+  ) && (/<\/svg>\s*$/i.test(normalized) || /<svg(?:\s[^>]*)?\/>\s*$/is.test(normalized));
+}
+
 // src/quiverai-image-model.ts
 var QuiverAIImageModel = class _QuiverAIImageModel {
   constructor(modelId, config) {
@@ -138,6 +272,7 @@ var QuiverAIImageModel = class _QuiverAIImageModel {
       n,
       prompt,
       files,
+      mask,
       operation,
       options: quiveraiOptions != null ? quiveraiOptions : {}
     });
@@ -164,7 +299,13 @@ var QuiverAIImageModel = class _QuiverAIImageModel {
           ...response.credits != null && { credits: response.credits },
           images: response.data.map((image, index) => ({
             index,
-            mimeType: image.mime_type
+            mimeType: image.mime_type,
+            ...image.loop_period_ms !== void 0 && {
+              loopPeriodMs: image.loop_period_ms
+            },
+            ...image.opening_animation_ms !== void 0 && {
+              openingAnimationMs: image.opening_animation_ms
+            }
           }))
         }
       },
@@ -184,7 +325,16 @@ var QuiverAIImageModel = class _QuiverAIImageModel {
   }
 };
 function getOperationPath(operation) {
-  return operation === "generate" ? "/svgs/generations" : "/svgs/vectorizations";
+  switch (operation) {
+    case "generate":
+      return "/svgs/generations";
+    case "vectorize":
+      return "/svgs/vectorizations";
+    case "edit":
+      return "/svgs/edits";
+    case "animate":
+      return "/svgs/animations";
+  }
 }
 function getGenerateReferenceLimit(modelId) {
   return ["arrow-1", "arrow-1.0", "arrow-1.1"].includes(modelId) ? 4 : 16;
@@ -194,19 +344,79 @@ function toQuiverAIImageReference(image) {
     return { url: image.url };
   }
   return {
-    base64: typeof image.data === "string" ? image.data : convertUint8ArrayToBase64(image.data)
+    base64: typeof image.data === "string" ? image.data : convertUint8ArrayToBase642(image.data)
   };
 }
+var maxAnimationSourceBase64Length = 1066668;
+function toQuiverAIAnimationSource(image) {
+  var _a;
+  if (image.type === "url") {
+    let url;
+    try {
+      url = new URL(image.url);
+    } catch (e) {
+      throw new InvalidArgumentError2({
+        argument: "files",
+        message: "QuiverAI animate requires a valid HTTP or HTTPS SVG URL."
+      });
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new InvalidArgumentError2({
+        argument: "files",
+        message: "QuiverAI animate requires an HTTP or HTTPS SVG URL."
+      });
+    }
+    return { url: image.url };
+  }
+  let base64;
+  let bytes;
+  if (typeof image.data === "string") {
+    const dataUrlMatch = /^data:image\/svg\+xml(?:;[^,]*)?;base64,([\s\S]+)$/i.exec(image.data);
+    const encodedData = (_a = dataUrlMatch == null ? void 0 : dataUrlMatch[1]) != null ? _a : image.data;
+    try {
+      bytes = convertBase64ToUint8Array2(encodedData);
+    } catch (e) {
+      throw new InvalidArgumentError2({
+        argument: "files",
+        message: "QuiverAI animate requires the source SVG string to be valid base64 or an SVG data URL."
+      });
+    }
+    base64 = convertUint8ArrayToBase642(bytes);
+  } else {
+    bytes = image.data;
+    base64 = convertUint8ArrayToBase642(bytes);
+  }
+  if (!isSvg2(bytes)) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: "QuiverAI animate requires the input file to contain SVG data."
+    });
+  }
+  if (base64.length > maxAnimationSourceBase64Length) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: `QuiverAI animate accepts at most ${maxAnimationSourceBase64Length} base64 characters for the source SVG.`
+    });
+  }
+  return { base64 };
+}
+function isSvg2(data) {
+  const head = new TextDecoder("utf-8", { fatal: false }).decode(data.subarray(0, 4096)).trimStart();
+  return /^(?:(?:<\?xml[\s\S]*?\?>|<!--[\s\S]*?-->|<!DOCTYPE[\s\S]*?>)\s*)*<svg(?:\s|>)/i.test(
+    head
+  );
+}
 function buildRequestBody({
   modelId,
   n,
   prompt,
   files,
+  mask,
   operation,
   options
 }) {
   if ((modelId === "arrow-2" || modelId === "arrow-2-telos") && options.maxOutputTokens != null && options.maxOutputTokens > 65536) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "maxOutputTokens",
       message: `QuiverAI model "${modelId}" supports at most 65536 output tokens.`
     });
@@ -220,9 +430,12 @@ function buildRequestBody({
     attributes: options.attributes,
     stream: false
   };
+  if (operation !== "edit") {
+    rejectEditOnlyOptions(operation, options);
+  }
   if (operation === "generate") {
     if (prompt == null || prompt.trim().length === 0) {
-      throw new InvalidArgumentError({
+      throw new InvalidArgumentError2({
         argument: "prompt",
         message: "QuiverAI image generation requires a non-empty prompt for generateImage."
       });
@@ -230,7 +443,7 @@ function buildRequestBody({
     const references = files == null ? void 0 : files.map(toQuiverAIImageReference);
     const maxReferences = getGenerateReferenceLimit(modelId);
     if (references != null && references.length > maxReferences) {
-      throw new InvalidArgumentError({
+      throw new InvalidArgumentError2({
         argument: "files",
         message: `QuiverAI generate supports up to ${maxReferences} reference images for model "${modelId}".`
       });
@@ -244,20 +457,40 @@ function buildRequestBody({
       references
     };
   }
+  if (operation === "edit") {
+    return buildEditRequestBody({
+      modelId,
+      n,
+      prompt,
+      files,
+      mask,
+      options
+    });
+  }
+  if (operation === "animate") {
+    return buildAnimationRequestBody({
+      modelId,
+      n,
+      prompt,
+      files,
+      mask,
+      options
+    });
+  }
   if (files == null || files.length === 0) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "files",
       message: 'QuiverAI vectorize requires an input image. Pass an image in the generateImage prompt and set providerOptions.quiverai.operation to "vectorize".'
     });
   }
   if (files.length > 1) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "files",
       message: "QuiverAI vectorize accepts a single input image."
     });
   }
   if (n !== 1) {
-    throw new InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "n",
       message: "QuiverAI vectorize returns one SVG per request. Set maxImagesPerCall to 1 in generateImage to vectorize multiple times."
     });
@@ -270,6 +503,454 @@ function buildRequestBody({
     target_size: options.targetSize
   };
 }
+function buildAnimationRequestBody({
+  modelId,
+  n,
+  prompt,
+  files,
+  mask,
+  options
+}) {
+  if (modelId !== "arrow-2" && modelId !== "arrow-2-telos") {
+    throw new InvalidArgumentError2({
+      argument: "modelId",
+      message: 'QuiverAI animate is supported by the "arrow-2" and "arrow-2-telos" models.'
+    });
+  }
+  if (files == null || files.length === 0) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: "QuiverAI animate requires exactly one source SVG in prompt.images."
+    });
+  }
+  if (files.length !== 1) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: "QuiverAI animate accepts exactly one source SVG in prompt.images."
+    });
+  }
+  if (n !== 1) {
+    throw new InvalidArgumentError2({
+      argument: "n",
+      message: "QuiverAI animate returns one SVG per request. Set maxImagesPerCall to 1 in generateImage to animate multiple times."
+    });
+  }
+  if (mask != null) {
+    throw new InvalidArgumentError2({
+      argument: "mask",
+      message: "QuiverAI animate does not support masks."
+    });
+  }
+  if (prompt != null && prompt.trim().length === 0) {
+    throw new InvalidArgumentError2({
+      argument: "prompt",
+      message: "QuiverAI animate requires a non-empty prompt when an animation instruction is provided."
+    });
+  }
+  const unsupportedOptions = [
+    ["instructions", options.instructions],
+    ["topP", options.topP],
+    ["presencePenalty", options.presencePenalty],
+    ["attributes", options.attributes],
+    ["autoCrop", options.autoCrop],
+    ["targetSize", options.targetSize]
+  ].filter((option) => {
+    return option[1] !== void 0;
+  });
+  if (unsupportedOptions.length > 0) {
+    throw new InvalidArgumentError2({
+      argument: `providerOptions.quiverai.${unsupportedOptions[0][0]}`,
+      message: `QuiverAI animate does not support providerOptions.quiverai.${unsupportedOptions[0][0]}.`
+    });
+  }
+  return {
+    model: modelId,
+    svg_source: toQuiverAIAnimationSource(files[0]),
+    prompt,
+    temperature: options.temperature,
+    max_output_tokens: options.maxOutputTokens,
+    reasoning_effort: options.reasoningEffort,
+    stream: false
+  };
+}
+var editModelIds = /* @__PURE__ */ new Set(["arrow-2", "arrow-2-telos"]);
+var MAX_EDIT_SVG_BYTES = 2e5;
+function buildEditRequestBody({
+  modelId,
+  n,
+  prompt,
+  files,
+  mask,
+  options
+}) {
+  var _a;
+  if (!editModelIds.has(modelId)) {
+    throw new InvalidArgumentError2({
+      argument: "modelId",
+      message: 'QuiverAI SVG editing is supported by the "arrow-2" and "arrow-2-telos" models.'
+    });
+  }
+  if (prompt == null || prompt.trim().length === 0) {
+    throw new InvalidArgumentError2({
+      argument: "prompt",
+      message: "QuiverAI SVG editing requires a non-empty instruction in generateImage prompt.text."
+    });
+  }
+  if (prompt.length > 4e3) {
+    throw new InvalidArgumentError2({
+      argument: "prompt",
+      message: "QuiverAI SVG editing instructions must contain at most 4000 characters."
+    });
+  }
+  if (files == null || files.length === 0) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: "QuiverAI SVG editing requires one source SVG in generateImage prompt.images."
+    });
+  }
+  if (files.length !== 1) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: "QuiverAI SVG editing accepts exactly one source SVG."
+    });
+  }
+  if (n !== 1) {
+    throw new InvalidArgumentError2({
+      argument: "n",
+      message: "QuiverAI SVG editing returns exactly one SVG per request. Set maxImagesPerCall to 1 in generateImage to edit multiple times."
+    });
+  }
+  if (mask != null) {
+    throw new InvalidArgumentError2({
+      argument: "mask",
+      message: "QuiverAI SVG editing does not support masks."
+    });
+  }
+  const unsupportedOptions = [
+    ["instructions", options.instructions],
+    ["attributes", options.attributes],
+    ["topP", options.topP],
+    ["presencePenalty", options.presencePenalty],
+    ["autoCrop", options.autoCrop],
+    ["targetSize", options.targetSize]
+  ].flatMap(([name, value]) => value == null ? [] : [name]);
+  if (unsupportedOptions.length > 0) {
+    throw new InvalidArgumentError2({
+      argument: "providerOptions",
+      message: `QuiverAI SVG editing does not support these provider options: ${unsupportedOptions.join(
+        ", "
+      )}.`
+    });
+  }
+  const referenceImages = (_a = options.referenceImages) == null ? void 0 : _a.map((reference, index) => {
+    if ("url" in reference) {
+      return {
+        url: validateQuiverAIImageUrl(reference.url)
+      };
+    }
+    validateQuiverAIReferenceBase64(
+      reference.base64,
+      `providerOptions.quiverai.referenceImages[${index}]`
+    );
+    return { base64: reference.base64 };
+  });
+  const settings = {
+    max_output_tokens: options.maxOutputTokens,
+    orchestrator_max_output_tokens: options.orchestratorMaxOutputTokens,
+    shallow_max_output_tokens: options.shallowMaxOutputTokens,
+    temperature: options.temperature
+  };
+  const hasSettings = Object.values(settings).some((value) => value != null);
+  return {
+    model: modelId,
+    prompt,
+    ...toQuiverAIEditSource(files[0]),
+    reference_images: referenceImages,
+    max_review_steps: options.maxReviewSteps,
+    reasoning_effort: options.reasoningEffort,
+    ...hasSettings && { settings },
+    stream: false
+  };
+}
+function rejectEditOnlyOptions(operation, options) {
+  const editOnlyOptions = [
+    ["referenceImages", options.referenceImages],
+    ["maxReviewSteps", options.maxReviewSteps],
+    ["orchestratorMaxOutputTokens", options.orchestratorMaxOutputTokens],
+    ["shallowMaxOutputTokens", options.shallowMaxOutputTokens]
+  ].flatMap(([name, value]) => value == null ? [] : [name]);
+  if (editOnlyOptions.length > 0) {
+    throw new InvalidArgumentError2({
+      argument: "providerOptions",
+      message: `QuiverAI ${operation} does not support these edit-only provider options: ${editOnlyOptions.join(
+        ", "
+      )}.`
+    });
+  }
+}
+function toQuiverAIEditSource(file) {
+  if (file.type === "url") {
+    return {
+      svg_source: {
+        url: validateQuiverAIImageUrl(file.url)
+      }
+    };
+  }
+  let data;
+  try {
+    data = typeof file.data === "string" ? convertBase64ToUint8Array2(file.data) : file.data;
+  } catch (cause) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: "QuiverAI SVG source data must be valid base64 or binary data.",
+      cause
+    });
+  }
+  if (data.length === 0 || data.length > MAX_EDIT_SVG_BYTES) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: `QuiverAI SVG source data must contain 1-${MAX_EDIT_SVG_BYTES} bytes.`
+    });
+  }
+  let svg;
+  try {
+    svg = new TextDecoder("utf-8", { fatal: true }).decode(data);
+  } catch (cause) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: "QuiverAI SVG source data must be valid UTF-8.",
+      cause
+    });
+  }
+  if (svg.length > MAX_EDIT_SVG_BYTES || !isSvgMarkup(svg)) {
+    throw new InvalidArgumentError2({
+      argument: "files",
+      message: "QuiverAI SVG source data must contain a complete SVG document."
+    });
+  }
+  return {
+    svg_source: {
+      base64: convertUint8ArrayToBase642(data)
+    }
+  };
+}
+function isSvgMarkup(svg) {
+  var _a;
+  const document = svg.replace(/^\uFEFF/, "");
+  const elements = [];
+  let position = 0;
+  let rootSeen = false;
+  let rootClosed = false;
+  let doctypeSeen = false;
+  while (position < document.length) {
+    if (document[position] !== "<") {
+      const nextTag = document.indexOf("<", position);
+      const end = nextTag === -1 ? document.length : nextTag;
+      const text = document.slice(position, end);
+      if (elements.length === 0 && text.trim().length > 0 || text.includes("]]>") || !hasValidXmlReferences(text)) {
+        return false;
+      }
+      position = end;
+      continue;
+    }
+    if (document.startsWith("<!--", position)) {
+      const commentEnd = document.indexOf("-->", position + 4);
+      if (commentEnd === -1 || document.slice(position + 4, commentEnd).includes("--")) {
+        return false;
+      }
+      position = commentEnd + 3;
+      continue;
+    }
+    if (document.startsWith("<?", position)) {
+      const instructionEnd = document.indexOf("?>", position + 2);
+      if (instructionEnd === -1) {
+        return false;
+      }
+      position = instructionEnd + 2;
+      continue;
+    }
+    if (document.startsWith("<![CDATA[", position)) {
+      if (elements.length === 0) {
+        return false;
+      }
+      const cdataEnd = document.indexOf("]]>", position + 9);
+      if (cdataEnd === -1) {
+        return false;
+      }
+      position = cdataEnd + 3;
+      continue;
+    }
+    if (document.slice(position, position + 9).toUpperCase() === "<!DOCTYPE") {
+      if (rootSeen || doctypeSeen || elements.length > 0 || !/[\t\n\r ]/.test((_a = document[position + 9]) != null ? _a : "")) {
+        return false;
+      }
+      const doctypeName = readXmlName(
+        document,
+        skipXmlWhitespace(document, position + 9)
+      );
+      if ((doctypeName == null ? void 0 : doctypeName.name.toLowerCase()) !== "svg") {
+        return false;
+      }
+      const doctypeEnd = findDoctypeEnd(document, doctypeName.end);
+      if (doctypeEnd === -1) {
+        return false;
+      }
+      doctypeSeen = true;
+      position = doctypeEnd;
+      continue;
+    }
+    if (document.startsWith("<!", position)) {
+      return false;
+    }
+    if (document.startsWith("</", position)) {
+      const closingTag = readXmlName(document, position + 2);
+      if (closingTag == null) {
+        return false;
+      }
+      let tagEnd = skipXmlWhitespace(document, closingTag.end);
+      if (document[tagEnd] !== ">") {
+        return false;
+      }
+      const expectedTag = elements.pop();
+      if (expectedTag !== closingTag.name) {
+        return false;
+      }
+      tagEnd += 1;
+      if (elements.length === 0) {
+        rootClosed = true;
+      }
+      position = tagEnd;
+      continue;
+    }
+    if (rootClosed) {
+      return false;
+    }
+    const openingTag = readXmlName(document, position + 1);
+    if (openingTag == null) {
+      return false;
+    }
+    if (!rootSeen) {
+      if (openingTag.name.toLowerCase() !== "svg") {
+        return false;
+      }
+      rootSeen = true;
+    }
+    const attributes = /* @__PURE__ */ new Set();
+    let tagPosition = openingTag.end;
+    while (tagPosition < document.length) {
+      const beforeWhitespace = tagPosition;
+      tagPosition = skipXmlWhitespace(document, tagPosition);
+      if (document.startsWith("/>", tagPosition)) {
+        tagPosition += 2;
+        if (elements.length === 0) {
+          rootClosed = true;
+        }
+        position = tagPosition;
+        break;
+      }
+      if (document[tagPosition] === ">") {
+        elements.push(openingTag.name);
+        position = tagPosition + 1;
+        break;
+      }
+      if (tagPosition === beforeWhitespace) {
+        return false;
+      }
+      const attribute = readXmlName(document, tagPosition);
+      if (attribute == null || attributes.has(attribute.name)) {
+        return false;
+      }
+      attributes.add(attribute.name);
+      tagPosition = skipXmlWhitespace(document, attribute.end);
+      if (document[tagPosition] !== "=") {
+        return false;
+      }
+      tagPosition = skipXmlWhitespace(document, tagPosition + 1);
+      const quote = document[tagPosition];
+      if (quote !== '"' && quote !== "'") {
+        return false;
+      }
+      const valueEnd = document.indexOf(quote, tagPosition + 1);
+      if (valueEnd === -1 || document.slice(tagPosition + 1, valueEnd).includes("<") || !hasValidXmlReferences(document.slice(tagPosition + 1, valueEnd))) {
+        return false;
+      }
+      tagPosition = valueEnd + 1;
+    }
+    if (tagPosition >= document.length && position !== document.length) {
+      return false;
+    }
+  }
+  return rootSeen && rootClosed && elements.length === 0;
+}
+function isXmlNameStart(character) {
+  return character != null && /[A-Z_a-z:\u0080-\uFFFF]/.test(character);
+}
+function isXmlNameCharacter(character) {
+  return character != null && /[-.0-9A-Z_a-z:\u00B7\u0080-\uFFFF]/.test(character);
+}
+function readXmlName(value, position) {
+  if (!isXmlNameStart(value[position])) {
+    return void 0;
+  }
+  const start = position;
+  position += 1;
+  while (isXmlNameCharacter(value[position])) {
+    position += 1;
+  }
+  return {
+    name: value.slice(start, position),
+    end: position
+  };
+}
+function skipXmlWhitespace(value, position) {
+  var _a;
+  while (/[\t\n\r ]/.test((_a = value[position]) != null ? _a : "")) {
+    position += 1;
+  }
+  return position;
+}
+function hasValidXmlReferences(value) {
+  let position = value.indexOf("&");
+  while (position !== -1) {
+    const end = value.indexOf(";", position + 1);
+    if (end === -1) {
+      return false;
+    }
+    const reference = value.slice(position + 1, end);
+    if (!/^#\d+$/.test(reference) && !/^#x[\dA-Fa-f]+$/.test(reference) && !/^[A-Z_a-z:\u0080-\uFFFF][-.0-9A-Z_a-z:\u00B7\u0080-\uFFFF]*$/.test(
+      reference
+    )) {
+      return false;
+    }
+    position = value.indexOf("&", end + 1);
+  }
+  return true;
+}
+function findDoctypeEnd(value, position) {
+  let subsetDepth = 0;
+  let quote;
+  while (position < value.length) {
+    const character = value[position];
+    if (quote != null) {
+      if (character === quote) {
+        quote = void 0;
+      }
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === "[") {
+      subsetDepth += 1;
+    } else if (character === "]") {
+      if (subsetDepth === 0) {
+        return -1;
+      }
+      subsetDepth -= 1;
+    } else if (character === ">" && subsetDepth === 0) {
+      return position + 1;
+    }
+    position += 1;
+  }
+  return -1;
+}
 function collectWarnings({
   size,
   aspectRatio,
@@ -314,7 +995,9 @@ var svgUsageSchema = z2.object({
 });
 var svgDocumentSchema = z2.object({
   svg: z2.string().min(1),
-  mime_type: z2.literal("image/svg+xml")
+  mime_type: z2.literal("image/svg+xml"),
+  loop_period_ms: z2.number().int().nonnegative().nullish(),
+  opening_animation_ms: z2.number().int().nonnegative().nullish()
 });
 var svgGenerationResponseSchema = z2.object({
   id: z2.string().min(1),
@@ -336,7 +1019,7 @@ var quiveraiFailedResponseHandler = createJsonErrorResponseHandler({
 });
 
 // src/version.ts
-var VERSION = true ? "2.0.43" : "0.0.0-test";
+var VERSION = true ? "2.0.45" : "0.0.0-test";
 
 // src/quiverai-provider.ts
 var defaultBaseURL = "https://api.quiver.ai/v1";
@@ -389,6 +1072,7 @@ var quiverai = createQuiverAI();
 export {
   VERSION,
   createQuiverAI,
+  prepareQuiverAIImageReference,
   quiverai
 };
 //# sourceMappingURL=index.js.map