{"version":3,"sources":["../src/index.ts","../src/errors.ts","../src/autoscript-adapter.ts","../src/parameters.ts","../src/base64.ts","../src/client.ts","../src/loader.ts"],"sourcesContent":["export { AutoFirmaClient } from \"./client.js\";\nexport { loadAutoScript } from \"./loader.js\";\nexport type { LoadOptions } from \"./loader.js\";\nexport { AutoFirmaError, AutoScriptUnavailableError } from \"./errors.js\";\nexport { isAutoScriptAvailable } from \"./autoscript-adapter.js\";\nexport { serializeParameters } from \"./parameters.js\";\nexport { fromBase64, toBase64 } from \"./base64.js\";\nexport type {\n  BatchDocumentResult,\n  SignBatchOptions,\n  SignBatchResult,\n  AutoFirmaClientOptions,\n  AutoScriptApi,\n  CertificateResult,\n  CheckTimeOptions,\n  ExtraParameters,\n  SaveOptions,\n  SignableData,\n  SignatureAlgorithm,\n  SignatureClient,\n  SignatureFormat,\n  SignOptions,\n  SignResult,\n} from \"./types.js\";\n","/**\n * Error normalizado que conserva la información devuelta por AutoScript.\n */\nexport class AutoFirmaError extends Error {\n  public readonly code: string;\n  public readonly nativeType: string | undefined;\n  public readonly nativeMessage: string | undefined;\n\n  public constructor(\n    message: string,\n    code = \"AUTOFIRMA_ERROR\",\n    nativeType?: string,\n    nativeMessage?: string,\n  ) {\n    super(message);\n    this.name = \"AutoFirmaError\";\n    this.code = code;\n    this.nativeType = nativeType;\n    this.nativeMessage = nativeMessage;\n  }\n}\n\n/**\n * Error emitido cuando no existe el objeto global AutoScript.\n */\nexport class AutoScriptUnavailableError extends AutoFirmaError {\n  public constructor() {\n    super(\n      \"AutoScript no está disponible en la página.\",\n      \"AUTOSCRIPT_UNAVAILABLE\",\n    );\n    this.name = \"AutoScriptUnavailableError\";\n  }\n}\n\n/**\n * Convierte el error nativo sin perder sus datos originales.\n *\n * AutoScript solo emite cinco tipos nativos. Tres de ellos identifican una\n * causa concreta sobre la que quien integra puede actuar —cancelación, falta de\n * memoria y falta de respuesta— y reciben su propio código; el resto queda como\n * `NATIVE_ERROR` con el tipo y el mensaje originales intactos, porque\n * `java.lang.Exception` es el cajón donde AutoFirma mete sus códigos `SAF_xx` y\n * traducirlos aquí sería inventar categorías que no existen.\n */\nexport function fromNativeError(\n  nativeType: string,\n  nativeMessage: string,\n): AutoFirmaError {\n  const normalizedType = nativeType.toLowerCase();\n  const normalizedMessage = nativeMessage.toLowerCase();\n\n  if (\n    normalizedType.includes(\"cancel\") ||\n    normalizedMessage.includes(\"cancel\")\n  ) {\n    return new AutoFirmaError(\n      \"La operación de firma fue cancelada.\",\n      \"USER_CANCELLED\",\n      nativeType,\n      nativeMessage,\n    );\n  }\n\n  // AutoFirma responde `MEMORY_ERROR` cuando los datos no le caben en memoria,\n  // y AutoScript lo traduce a este tipo. No hay un tamaño máximo declarado en\n  // ninguna parte: el límite lo pone la memoria de la aplicación nativa.\n  if (normalizedType.includes(\"outofmemory\")) {\n    return new AutoFirmaError(\n      \"El fichero excede la memoria disponible de AutoFirma.\",\n      \"DATA_TOO_LARGE\",\n      nativeType,\n      nativeMessage,\n    );\n  }\n\n  // Se agotaron los reintentos de conexión con la aplicación nativa: o no está\n  // instalada, o no llegó a abrirse.\n  if (normalizedType.includes(\"timeout\")) {\n    return new AutoFirmaError(\n      \"AutoFirma no respondió a tiempo.\",\n      \"NATIVE_TIMEOUT\",\n      nativeType,\n      nativeMessage,\n    );\n  }\n\n  return new AutoFirmaError(\n    \"AutoFirma no pudo completar la operación.\",\n    \"NATIVE_ERROR\",\n    nativeType,\n    nativeMessage,\n  );\n}\n","import {\n  AutoFirmaError,\n  AutoScriptUnavailableError,\n  fromNativeError,\n} from \"./errors.js\";\nimport type {\n  BatchDocumentResult,\n  AutoScriptApi,\n  SignatureOperation,\n  SignResult,\n} from \"./types.js\";\n\ndeclare global {\n  interface Window {\n    AutoScript?: AutoScriptApi;\n  }\n}\n\n/**\n * Comprueba que un candidato sea la API de AutoScript y no cualquier otra cosa\n * que ocupe el mismo nombre global.\n *\n * `window.AutoScript` no requiere ejecutar JavaScript para existir: un elemento\n * con `id=\"AutoScript\"` o `name=\"AutoScript\"` lo define solo (DOM clobbering),\n * y los saneadores de HTML habituales permiten `id`. Comprobar únicamente que\n * el global sea *truthy* aceptaba ese elemento como si fuera la API: la firma\n * no fallaba al construir el cliente sino mucho después, con un `TypeError`\n * sin `code` al invocar una operación inexistente.\n *\n * `sign` es la única operación que AutoScript garantiza en todas sus versiones\n * —el resto son opcionales en `AutoScriptApi`—, así que es lo mínimo que puede\n * exigirse sin rechazar versiones legítimas.\n */\nexport function isAutoScriptApi(\n  candidate: unknown,\n): candidate is AutoScriptApi {\n  return (\n    typeof candidate === \"object\" &&\n    candidate !== null &&\n    typeof (candidate as AutoScriptApi).sign === \"function\"\n  );\n}\n\n/**\n * Indica si el objeto global oficial de AutoScript está disponible y tiene la\n * superficie mínima esperada.\n */\nexport function isAutoScriptAvailable(): boolean {\n  return typeof window !== \"undefined\" && isAutoScriptApi(window.AutoScript);\n}\n\n/**\n * Resuelve la API inyectada o el objeto global oficial.\n */\nexport function resolveAutoScript(injected?: AutoScriptApi): AutoScriptApi {\n  if (injected) {\n    return injected;\n  }\n\n  if (typeof window !== \"undefined\" && isAutoScriptApi(window.AutoScript)) {\n    return window.AutoScript;\n  }\n\n  throw new AutoScriptUnavailableError();\n}\n\n/**\n * Adapta una operación nativa basada en callbacks a una promesa.\n */\nexport function invokeSignatureOperation(\n  operation: SignatureOperation,\n  data: string,\n  algorithm: string,\n  format: string,\n  parameters: string,\n): Promise<SignResult> {\n  return new Promise((resolve, reject) => {\n    operation(\n      data,\n      algorithm,\n      format,\n      parameters,\n      (signature, certificate, extraData) => {\n        resolve({\n          signature,\n          ...(certificate ? { certificate } : {}),\n          ...(extraData ? { extraData } : {}),\n        });\n      },\n      (errorType, errorMessage) => {\n        reject(fromNativeError(errorType, errorMessage));\n      },\n    );\n  });\n}\n\n/** Comprueba el contrato de JSONBatchManager y la correspondencia con el lote. */\nexport function readBatchResults(\n  data: unknown,\n  ids: ReadonlySet<string>,\n): readonly BatchDocumentResult[] {\n  const signs = (data as { signs?: unknown } | null)?.signs;\n  const remaining = new Set(ids);\n  if (!Array.isArray(signs) || signs.length !== ids.size) {\n    throw new AutoFirmaError(\n      \"Invalid batch response\",\n      \"INVALID_BATCH_RESPONSE\",\n    );\n  }\n  for (const item of signs) {\n    if (\n      !item ||\n      typeof item.id !== \"string\" ||\n      !remaining.delete(item.id) ||\n      typeof item.result !== \"string\" ||\n      (item.description !== undefined &&\n        typeof item.description !== \"string\") ||\n      (item.signature !== undefined && typeof item.signature !== \"string\") ||\n      (item.result === \"DONE_AND_SAVED\" && !item.signature)\n    ) {\n      throw new AutoFirmaError(\n        \"Invalid batch document result\",\n        \"INVALID_BATCH_RESPONSE\",\n      );\n    }\n  }\n  return signs;\n}\n","import type { ExtraParameters } from \"./types.js\";\n\n/**\n * Serializa parámetros como líneas `clave=valor`, que es el formato exigido\n * por AutoScript. Las claves con separadores se rechazan para evitar resultados\n * ambiguos.\n *\n * **Los valores se modifican en silencio.** Un valor con saltos de línea se\n * aplana a una sola línea sustituyéndolos por espacios, y quien llama no recibe\n * ningún aviso: `layer2Text: \"línea 1\\nlínea 2\"` se envía como\n * `layer2Text=línea 1 línea 2`.\n *\n * No es cosmético, es la barrera que impide inyectar parámetros. AutoScript\n * trocea esta cadena con `split(params, \"\\n\")` (ver `addSignatoryCertificateToExtraParams`\n * en el `vendor/autoscript.js` fijado), así que un valor que conserve un salto\n * de línea añade una línea más y, con ella, un parámetro que quien integra\n * nunca puso. Importa cuando el valor viene de la persona usuaria y no del\n * código: el texto de la firma visible (`layer2Text`) es justo ese caso.\n *\n * De las claves se rechazan `\\r`, `\\n` y `=`, que son los separadores que\n * AutoScript reconoce. No se rechazan los dos puntos ni los espacios: si el\n * lado Java de AutoFirma carga estos parámetros con `java.util.Properties`\n * también los trataría como separador, pero eso no se puede comprobar contra el\n * fichero fijado —ahí solo está el JavaScript— y no se impone una regla por una\n * suposición sobre un parser que no se ha leído. El riesgo real es mínimo: las\n * claves son literales del código de quien integra, no entrada externa.\n */\nexport function serializeParameters(parameters: ExtraParameters = {}): string {\n  return Object.entries(parameters)\n    .filter((entry): entry is [string, string | number | boolean] => {\n      return entry[1] !== undefined && entry[1] !== null;\n    })\n    .map(([key, value]) => {\n      if (/[\\r\\n=]/u.test(key)) {\n        throw new TypeError(`Nombre de parámetro no válido: ${key}`);\n      }\n\n      const serializedValue = String(value).replace(/[\\r\\n]+/gu, \" \");\n      return `${key}=${serializedValue}`;\n    })\n    .join(\"\\n\");\n}\n","import type { SignableData } from \"./types.js\";\n\n/**\n * Convierte datos binarios o texto Base64 en el formato esperado por\n * AutoScript. Las cadenas se consideran ya codificadas en Base64.\n */\nexport async function toBase64(data: SignableData): Promise<string> {\n  if (typeof data === \"string\") {\n    return data;\n  }\n\n  if (typeof Blob !== \"undefined\" && data instanceof Blob) {\n    return bytesToBase64(new Uint8Array(await data.arrayBuffer()));\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return bytesToBase64(new Uint8Array(data));\n  }\n\n  if (data instanceof Uint8Array) {\n    return bytesToBase64(data);\n  }\n\n  throw new TypeError(\"Tipo de dato no compatible.\");\n}\n\n/**\n * Decodifica una cadena Base64 estándar a bytes sin depender de Node.js.\n */\nexport function fromBase64(data: string): Uint8Array {\n  if (typeof atob !== \"function\") {\n    throw new Error(\"El entorno no proporciona una función Base64 compatible.\");\n  }\n\n  const binary = atob(data);\n  const bytes = new Uint8Array(binary.length);\n\n  for (let index = 0; index < binary.length; index += 1) {\n    bytes[index] = binary.charCodeAt(index);\n  }\n\n  return bytes;\n}\n\n/**\n * Codifica bytes sin depender de Node.js, para conservar compatibilidad con\n * navegadores.\n */\nfunction bytesToBase64(bytes: Uint8Array): string {\n  let binary = \"\";\n  const chunkSize = 0x8000;\n\n  for (let offset = 0; offset < bytes.length; offset += chunkSize) {\n    binary += String.fromCharCode(\n      ...bytes.subarray(offset, offset + chunkSize),\n    );\n  }\n\n  if (typeof btoa === \"function\") {\n    return btoa(binary);\n  }\n\n  throw new Error(\"El entorno no proporciona una función Base64 compatible.\");\n}\n","import {\n  invokeSignatureOperation,\n  resolveAutoScript,\n  readBatchResults,\n} from \"./autoscript-adapter.js\";\nimport { AutoFirmaError, fromNativeError } from \"./errors.js\";\nimport { serializeParameters } from \"./parameters.js\";\nimport { toBase64 } from \"./base64.js\";\nimport type {\n  AutoFirmaClientOptions,\n  AutoScriptApi,\n  CertificateResult,\n  CheckTimeOptions,\n  ExtraParameters,\n  SaveOptions,\n  SignatureClient,\n  SignatureOperation,\n  SignOptions,\n  SignResult,\n  SignBatchOptions,\n  SignBatchResult,\n} from \"./types.js\";\n\n// AutoScript comparte callbacks y el lote incluso entre varias fachadas.\nconst activeOperations = new WeakSet<AutoScriptApi>();\n\nconst DEFAULT_ALGORITHM = \"SHA256withRSA\";\n\n/**\n * Cliente moderno y fino sobre la API oficial AutoScript.\n */\nexport class AutoFirmaClient implements SignatureClient {\n  private readonly autoScript: AutoScriptApi;\n\n  public constructor(options: AutoFirmaClientOptions = {}) {\n    this.autoScript = resolveAutoScript(options.autoScript);\n\n    if (options.appName && this.autoScript.setAppName) {\n      this.autoScript.setAppName(options.appName);\n    }\n\n    if (options.locale && this.autoScript.setLocale) {\n      this.autoScript.setLocale(options.locale);\n    }\n\n    if (\n      options.storageUrl &&\n      options.retrieveUrl &&\n      this.autoScript.setServlets\n    ) {\n      this.autoScript.setServlets(options.storageUrl, options.retrieveUrl);\n    }\n  }\n\n  /**\n   * Solicita a AutoScript que prepare o abra AutoFirma.\n   */\n  public initialize(): void {\n    this.autoScript.cargarAppAfirma?.();\n  }\n\n  /**\n   * Firma los datos proporcionados.\n   */\n  public sign(options: SignOptions): Promise<SignResult> {\n    return this.execute(this.autoScript.sign, options);\n  }\n\n  /**\n   * Firma un lote local. Los parámetros del lote son comunes; un documento\n   * puede traer los suyos, que AutoFirma usa en lugar de los comunes.\n   */\n  public signBatch(options: SignBatchOptions): Promise<SignBatchResult> {\n    const api = this.autoScript;\n    const {\n      createBatch,\n      addDocumentToBatch,\n      setLocalBatchProcess,\n      signBatchProcess,\n    } = api;\n    if (\n      !createBatch ||\n      !addDocumentToBatch ||\n      !setLocalBatchProcess ||\n      !signBatchProcess\n    ) {\n      return this.unsupported(\"signBatchProcess\");\n    }\n    return this.withOperation(async () => {\n      const ids = new Set(options.documents.map(({ id }) => id));\n      if (\n        !ids.size ||\n        ids.size !== options.documents.length ||\n        [...ids].some((id) => typeof id !== \"string\" || !id.trim())\n      ) {\n        throw new AutoFirmaError(\n          \"Batch document IDs must be non-empty and unique\",\n          \"INVALID_BATCH\",\n        );\n      }\n      // Convertimos y serializamos antes de modificar el lote global de\n      // AutoScript: un parámetro inválido rechaza sin dejar un lote a medias.\n      const documents = await Promise.all(\n        options.documents.map(async ({ id, data, parameters }) => ({\n          id,\n          data: await toBase64(data),\n          parameters:\n            parameters === undefined ? null : serializeParameters(parameters),\n        })),\n      );\n      const parameters = serializeParameters(options.parameters);\n      const filters = serializeParameters(options.certificateFilters);\n      createBatch(\n        options.algorithm ?? DEFAULT_ALGORITHM,\n        options.format,\n        \"sign\",\n        parameters,\n      );\n      for (const { id, data, parameters } of documents) {\n        addDocumentToBatch(id, data, null, null, parameters);\n      }\n      setLocalBatchProcess(true);\n      try {\n        return await new Promise<SignBatchResult>((resolve, reject) => {\n          signBatchProcess(\n            options.stopOnError ?? false,\n            null,\n            null,\n            filters,\n            (data, certificate) => {\n              try {\n                resolve({\n                  signs: readBatchResults(data, ids),\n                  ...(certificate ? { certificate } : {}),\n                });\n              } catch (error) {\n                reject(error);\n              }\n            },\n            (type, message) => reject(fromNativeError(type, message)),\n          );\n        });\n      } finally {\n        setLocalBatchProcess(false);\n      }\n    });\n  }\n\n  /**\n   * Añade una firma al mismo nivel cuando AutoScript expone la operación.\n   */\n  public coSign(options: SignOptions): Promise<SignResult> {\n    return this.executeRequired(\"coSign\", this.autoScript.coSign, options);\n  }\n\n  /**\n   * Contrafirma cuando AutoScript expone la operación.\n   */\n  public counterSign(options: SignOptions): Promise<SignResult> {\n    return this.executeRequired(\n      \"counterSign\",\n      this.autoScript.counterSign,\n      options,\n    );\n  }\n\n  /**\n   * Abre la selección de certificado sin iniciar una firma.\n   */\n  public selectCertificate(\n    parameters: ExtraParameters = {},\n  ): Promise<CertificateResult> {\n    if (!this.autoScript.selectCertificate) {\n      return this.unsupported(\"selectCertificate\");\n    }\n\n    return this.withOperation(\n      () =>\n        new Promise((resolve, reject) => {\n          this.autoScript.selectCertificate?.(\n            serializeParameters(parameters),\n            (certificate) => resolve({ certificate }),\n            (type, message) => reject(fromNativeError(type, message)),\n          );\n        }),\n    );\n  }\n\n  /**\n   * Pide a AutoFirma que guarde datos en un fichero elegido por la persona\n   * usuaria.\n   */\n  public saveDataToFile(options: SaveOptions): Promise<void> {\n    const operation = this.autoScript.saveDataToFile;\n    if (!operation) {\n      return this.unsupported(\"saveDataToFile\");\n    }\n\n    return this.withOperation(\n      () =>\n        new Promise((resolve, reject) => {\n          operation(\n            options.data,\n            options.title,\n            options.filename,\n            options.extension,\n            options.description,\n            () => resolve(),\n            (type, message) => reject(fromNativeError(type, message)),\n          );\n        }),\n    );\n  }\n\n  /**\n   * Comprueba la sincronía del reloj del equipo contra un servidor.\n   *\n   * AutoScript lo implementa con una petición XHR **síncrona** que bloquea el\n   * hilo principal (`xhr.open('GET', url, false)`) hasta obtener respuesta.\n   * Si no se indica `checkUrl`, la petición se envía contra\n   * `document.URL + '/' + Math.random()`: una URL inventada contra el propio\n   * origen de la página, un acceso de red no documentado en ningún otro sitio\n   * y que este método no evita ni controla, pese a que esta librería no hace\n   * ningún acceso de red propio.\n   *\n   * El único efecto observable de un desfase es un `alert()` nativo; AutoScript\n   * captura y silencia cualquier error (por ejemplo, que la petición falle).\n   * Por eso la promesa devuelta nunca informa del resultado de la\n   * comprobación: se resuelve siempre que la operación exista, haya o no\n   * desfase y haya o no error de red.\n   *\n   * Con `checkType: \"CT_OBLIGATORY\"` y un desfase detectado, AutoScript marca\n   * un estado interno (`severeTimeDelay`) que hace que su función de carga\n   * (`cargarAppAfirma`, a la que invoca `initialize()`) registre un aviso y\n   * retorne sin hacer nada la siguiente vez que se ejecute. El orden de\n   * llamadas importa y no está documentado: invocar\n   * `checkTime({ checkType: \"CT_OBLIGATORY\" })` antes de `initialize()` puede\n   * convertir `initialize()` en un no-op silencioso; invocarlo después de\n   * `initialize()` no afecta a una carga que ya se ha iniciado.\n   *\n   * Si no se indica `maxMillis`, se reenvía tal cual: AutoScript aplica\n   * entonces su propio valor por defecto (300000 ms, 5 minutos) en vez de uno\n   * impuesto aquí.\n   */\n  public checkTime(options: CheckTimeOptions = {}): Promise<void> {\n    const operation = this.autoScript.checkTime;\n    if (!operation) {\n      return this.unsupported(\"checkTime\");\n    }\n\n    operation(\n      options.checkType ?? \"CT_RECOMMENDED\",\n      options.maxMillis,\n      options.checkUrl,\n    );\n    return Promise.resolve();\n  }\n\n  /**\n   * Devuelve el objeto oficial para casos que el wrapper todavía no cubra.\n   */\n  public get raw(): AutoScriptApi {\n    return this.autoScript;\n  }\n\n  /**\n   * Valida que exista la operación opcional antes de ejecutarla.\n   */\n  private executeRequired(\n    name: string,\n    operation: SignatureOperation | undefined,\n    options: SignOptions,\n  ): Promise<SignResult> {\n    if (!operation) {\n      return this.unsupported(name);\n    }\n\n    return this.execute(operation, options);\n  }\n\n  /**\n   * Rechazo homogéneo para operaciones ausentes en la versión fijada.\n   */\n  private unsupported<T>(name: string): Promise<T> {\n    return Promise.reject(\n      new AutoFirmaError(\n        `Esta versión de AutoScript no expone ${name}.`,\n        \"UNSUPPORTED_OPERATION\",\n      ),\n    );\n  }\n\n  /**\n   * Normaliza datos y parámetros antes de delegar en AutoScript.\n   */\n  private async execute(\n    operation: SignatureOperation,\n    options: SignOptions,\n  ): Promise<SignResult> {\n    return this.withOperation(async () =>\n      invokeSignatureOperation(\n        operation,\n        await toBase64(options.data),\n        options.algorithm ?? DEFAULT_ALGORITHM,\n        options.format,\n        serializeParameters(options.parameters),\n      ),\n    );\n  }\n  /** Evita pisar callbacks nativos; libera también tras cancelaciones y errores. */\n  private async withOperation<T>(run: () => Promise<T>): Promise<T> {\n    if (activeOperations.has(this.autoScript)) {\n      throw new AutoFirmaError(\n        \"An AutoFirma operation is already running\",\n        \"OPERATION_IN_PROGRESS\",\n      );\n    }\n    activeOperations.add(this.autoScript);\n    try {\n      return await run();\n    } finally {\n      activeOperations.delete(this.autoScript);\n    }\n  }\n}\n","import { isAutoScriptApi } from \"./autoscript-adapter.js\";\nimport { AutoFirmaError } from \"./errors.js\";\nimport type { AutoScriptApi } from \"./types.js\";\n\n/**\n * Opciones del cargador. `document` existe para poder probarlo sin navegador.\n *\n * `integrity` y `crossOrigin` son los atributos de Subresource Integrity: el\n * navegador descarta el fichero si su huella no coincide. El paquete fija\n * `autoscript.js` por sha256 (ver ADR-0005) y esa garantía se pierde en cuanto\n * el fichero se sirve desde un origen que no se controla, así que esta es la\n * forma de recuperarla. Servirlo del propio origen, como recomienda el README,\n * sigue siendo la opción preferible y ahí SRI aporta poco.\n *\n * `autoscript.lock.json` guarda la huella en hexadecimal y SRI la quiere en\n * base64 con prefijo `sha256-`. La conversión:\n *\n * ```sh\n * printf 'sha256-%s\\n' \"$(node -p \"require('./autoscript.lock.json').sha256\" \\\n *   | xxd -r -p | base64)\"\n * ```\n */\nexport interface LoadOptions {\n  readonly document?: Document;\n  readonly integrity?: string;\n  readonly crossOrigin?: \"anonymous\" | \"use-credentials\";\n}\n\n/**\n * Inserta `autoscript.js` como script clásico y resuelve con el objeto global.\n *\n * AutoScript no es un módulo: no declara UMD, no exporta nada y confía en que\n * su `var` de nivel superior se convierta en global. Importarlo con un\n * empaquetador lo deja en ámbito de módulo y el global nunca aparece, así que\n * la única forma correcta de cargarlo es una etiqueta `script`.\n */\nexport function loadAutoScript(\n  url: string,\n  options: LoadOptions = {},\n): Promise<AutoScriptApi> {\n  const existing = globalThis.window?.AutoScript;\n  if (isAutoScriptApi(existing)) {\n    return Promise.resolve(existing);\n  }\n\n  const target = options.document ?? globalThis.document;\n  if (!target) {\n    return Promise.reject(\n      new AutoFirmaError(\n        \"No hay documento donde insertar AutoScript.\",\n        \"AUTOSCRIPT_UNAVAILABLE\",\n      ),\n    );\n  }\n\n  return new Promise((resolve, reject) => {\n    const script = target.createElement(\"script\");\n    script.src = url;\n    script.async = true;\n    if (options.integrity) {\n      script.integrity = options.integrity;\n    }\n    if (options.crossOrigin) {\n      script.crossOrigin = options.crossOrigin;\n    }\n    script.onload = () => {\n      const loaded = globalThis.window?.AutoScript;\n      if (isAutoScriptApi(loaded)) {\n        resolve(loaded);\n        return;\n      }\n      reject(\n        new AutoFirmaError(\n          `${url} se cargó pero window.AutoScript no es la API de AutoScript.`,\n          \"AUTOSCRIPT_UNAVAILABLE\",\n        ),\n      );\n    };\n    script.onerror = () => {\n      reject(\n        new AutoFirmaError(\n          `No se pudo cargar ${url}.`,\n          \"AUTOSCRIPT_UNAVAILABLE\",\n        ),\n      );\n    };\n    target.head.appendChild(script);\n  });\n}\n"],"mappings":"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","names":["parameters"]}