facturas 0.6.0 → 0.7.0

package/dist/chunk-PKE4Z4GE.mjs

@@ -0,0 +1,702 @@
+import {
+  classifyArcaAuthenticationError,
+  classifyArcaAuthenticationIssues,
+  createArcaAuthenticationErrorFromEvidence,
+  createArcaAuthenticationEvidence,
+  executeWithAuthenticationRecovery
+} from "./chunk-IOKZX6CA.mjs";
+import {
+  ArcaInputError,
+  ArcaInvalidSoapResponseError,
+  ArcaServiceError,
+  ArcaSoapFaultError,
+  ArcaTransportError
+} from "./chunk-MBWOFO67.mjs";
+
+// src/services/wsmtxca.ts
+function createWsmtxcaService(options) {
+  async function executeWsmtxcaAuthenticatedOperation(operation, input, body = {}, retries) {
+    const auth = await options.auth.login("wsmtxca", {
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceRefresh
+    });
+    const response = await options.soap.execute({
+      service: "wsmtxca",
+      operation,
+      ...retries === void 0 ? {} : { retries },
+      bodyElementName: `${operation}Request`,
+      bodyElementNamespaceMode: "prefix",
+      body: {
+        ...body,
+        authRequest: createWsmtxcaAuth(
+          input.representedTaxId ?? options.config.taxId,
+          auth.token,
+          auth.sign
+        )
+      }
+    });
+    return unwrapWsmtxcaOperationResponse(response.result, operation);
+  }
+  async function executeWsmtxcaAuthorization({
+    representedTaxId,
+    data,
+    forceRefresh
+  }) {
+    if (Object.hasOwn(data, "authRequest")) {
+      throw new ArcaInputError(
+        'WSMTXCA authorization data cannot include the reserved top-level field "authRequest".',
+        {
+          code: "ARCA_INPUT_RESERVED_FIELD",
+          field: "data.authRequest",
+          expected: "omitted because facturas manages authentication fields"
+        }
+      );
+    }
+    try {
+      const raw = await executeWsmtxcaAuthenticatedOperation(
+        "autorizarComprobante",
+        { representedTaxId, forceRefresh },
+        data,
+        0
+      );
+      return { outcome: classifyWsmtxcaAuthorization(raw) };
+    } catch (error) {
+      return {
+        outcome: createWsmtxcaIndeterminateOutcome(error),
+        error
+      };
+    }
+  }
+  async function authorizeVoucherOutcome(input) {
+    return (await executeWsmtxcaAuthorization(input)).outcome;
+  }
+  function authorizeVoucher(input) {
+    return executeWithAuthenticationRecovery({
+      service: "wsmtxca",
+      operation: "autorizarComprobante",
+      forceRefresh: input.forceRefresh,
+      execute: (forceRefresh) => authorizeVoucherOnce({ ...input, forceRefresh })
+    });
+  }
+  async function authorizeVoucherOnce(input) {
+    const execution = await executeWsmtxcaAuthorization(input);
+    if (execution.error) {
+      throw execution.error;
+    }
+    if (execution.outcome.kind !== "authorized") {
+      throw createWsmtxcaOutcomeError(execution.outcome);
+    }
+    const { outcome } = execution;
+    return {
+      cae: outcome.cae,
+      ...outcome.caeExpiry === void 0 ? {} : { caeExpiry: outcome.caeExpiry },
+      voucherNumber: outcome.voucherNumber,
+      messages: formatWsmtxcaIssues([
+        ...outcome.errors,
+        ...outcome.observations
+      ]),
+      raw: outcome.raw ?? {}
+    };
+  }
+  function getLastAuthorizedVoucher({
+    representedTaxId,
+    voucherType,
+    salesPoint,
+    forceRefresh
+  }) {
+    return executeWithAuthenticationRecovery({
+      service: "wsmtxca",
+      operation: "consultarUltimoComprobanteAutorizado",
+      forceRefresh,
+      execute: (attemptForceRefresh) => getLastAuthorizedVoucherOnce({
+        representedTaxId,
+        voucherType,
+        salesPoint,
+        forceRefresh: attemptForceRefresh
+      })
+    });
+  }
+  async function getLastAuthorizedVoucherOnce({
+    representedTaxId,
+    voucherType,
+    salesPoint,
+    forceRefresh
+  }) {
+    const operation = "consultarUltimoComprobanteAutorizado";
+    const raw = await executeWsmtxcaAuthenticatedOperation(
+      operation,
+      { representedTaxId, forceRefresh },
+      {
+        consultaUltimoComprobanteAutorizadoRequest: {
+          codigoTipoComprobante: voucherType,
+          numeroPuntoVenta: salesPoint
+        }
+      }
+    );
+    const errors = extractWsmtxcaIssues(raw, operation, "error");
+    if (errors.length > 0 && errors.every((issue) => issue.code === "1502")) {
+      return { voucherNumber: 0, raw };
+    }
+    if (errors.length > 0) {
+      throw createWsmtxcaServiceError(operation, errors);
+    }
+    return {
+      voucherNumber: parseWsmtxcaVoucherNumber(
+        raw.numeroComprobante ?? raw.cbteNro ?? raw.nroComprobante,
+        "WSMTXCA did not return the last authorized voucher number",
+        true
+      ),
+      raw
+    };
+  }
+  function getSalesPoints({
+    representedTaxId,
+    forceRefresh
+  }) {
+    return executeWithAuthenticationRecovery({
+      service: "wsmtxca",
+      operation: "consultarPuntosVenta",
+      forceRefresh,
+      execute: (attemptForceRefresh) => getSalesPointsOnce({
+        representedTaxId,
+        forceRefresh: attemptForceRefresh
+      })
+    });
+  }
+  async function getSalesPointsOnce({
+    representedTaxId,
+    forceRefresh
+  }) {
+    const operation = "consultarPuntosVenta";
+    const raw = await executeWsmtxcaAuthenticatedOperation(operation, {
+      representedTaxId,
+      forceRefresh
+    });
+    throwForWsmtxcaOperationErrors(operation, raw);
+    const rawSalesPoints = toRecord(raw.arrayPuntosVenta)?.puntoVenta;
+    const entries = Array.isArray(rawSalesPoints) ? rawSalesPoints : rawSalesPoints ? [rawSalesPoints] : [];
+    const salesPoints = entries.flatMap((entry) => {
+      const record = toRecord(entry);
+      const number = parseOptionalPositiveInteger(record?.numeroPuntoVenta);
+      if (number === void 0) {
+        return [];
+      }
+      const deletedAt = normalizeWsmtxcaResponseDate(record?.fechaBaja);
+      return [
+        {
+          number,
+          blocked: String(record?.bloqueado ?? "N").toUpperCase() === "S",
+          ...deletedAt === void 0 ? {} : { deletedAt }
+        }
+      ];
+    });
+    return { salesPoints, raw };
+  }
+  function lookupVoucher({
+    representedTaxId,
+    voucherType,
+    salesPoint,
+    voucherNumber,
+    forceRefresh
+  }) {
+    return executeWithAuthenticationRecovery({
+      service: "wsmtxca",
+      operation: "consultarComprobante",
+      forceRefresh,
+      execute: (attemptForceRefresh) => lookupVoucherOnce({
+        representedTaxId,
+        voucherType,
+        salesPoint,
+        voucherNumber,
+        forceRefresh: attemptForceRefresh
+      })
+    });
+  }
+  async function lookupVoucherOnce({
+    representedTaxId,
+    voucherType,
+    salesPoint,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const operation = "consultarComprobante";
+    const raw = await executeWsmtxcaAuthenticatedOperation(
+      operation,
+      { representedTaxId, forceRefresh },
+      {
+        consultaComprobanteRequest: {
+          codigoTipoComprobante: voucherType,
+          numeroPuntoVenta: salesPoint,
+          numeroComprobante: voucherNumber
+        }
+      }
+    );
+    const errors = extractWsmtxcaIssues(raw, operation, "error");
+    const observations = extractWsmtxcaIssues(raw, operation, "observation");
+    if (errors.length > 0 && errors.every((issue) => issue.code === "1503")) {
+      return {
+        kind: "not_found",
+        service: "wsmtxca",
+        operation,
+        errors,
+        observations,
+        raw
+      };
+    }
+    if (errors.length > 0) {
+      throw createWsmtxcaServiceError(operation, errors);
+    }
+    const voucher = extractWsmtxcaVoucherPayload(raw);
+    if (voucher === raw && !toRecord(raw.comprobante)) {
+      throw new ArcaServiceError(
+        "WSMTXCA did not return the voucher issue date",
+        {
+          service: "wsmtxca",
+          operation,
+          issues: observations
+        }
+      );
+    }
+    return {
+      kind: "found",
+      service: "wsmtxca",
+      operation,
+      voucher: mapWsmtxcaVoucherInfo(voucher),
+      observations,
+      raw
+    };
+  }
+  async function getVoucher(input) {
+    const lookup = await lookupVoucher(input);
+    if (lookup.kind === "not_found") {
+      throw createWsmtxcaServiceError(lookup.operation, lookup.errors);
+    }
+    const invoiceDate = lookup.voucher.invoiceDate;
+    if (!invoiceDate) {
+      throw new ArcaServiceError(
+        formatWsmtxcaIssues(lookup.observations)[0] ?? "WSMTXCA did not return the voucher issue date",
+        {
+          service: "wsmtxca",
+          operation: lookup.operation,
+          issues: lookup.observations
+        }
+      );
+    }
+    return {
+      invoiceDate,
+      voucher: lookup.voucher.raw,
+      messages: formatWsmtxcaIssues(lookup.observations),
+      raw: lookup.raw
+    };
+  }
+  return {
+    authorizeVoucherOutcome,
+    authorizeVoucher,
+    getLastAuthorizedVoucher,
+    getSalesPoints,
+    lookupVoucher,
+    getVoucher
+  };
+}
+function createWsmtxcaAuth(representedTaxId, token, sign) {
+  return {
+    token,
+    sign,
+    cuitRepresentada: Number.parseInt(String(representedTaxId), 10)
+  };
+}
+function toRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function unwrapWsmtxcaOperationResponse(response, operation) {
+  const responseRecord = toRecord(response) ?? {};
+  if (operation === "autorizarComprobante") {
+    return toRecord(responseRecord.autorizarComprobanteResponse) ?? toRecord(responseRecord.autorizarComprobanteResult) ?? toRecord(responseRecord.comprobanteCAEResponse) ?? toRecord(responseRecord.comprobanteCAEReponse) ?? responseRecord;
+  }
+  if (operation === "consultarComprobante") {
+    return toRecord(responseRecord.consultarComprobanteResponse) ?? toRecord(responseRecord.consultaComprobanteResponse) ?? toRecord(responseRecord.consultarComprobanteResult) ?? responseRecord;
+  }
+  if (operation === "consultarPuntosVenta") {
+    return toRecord(responseRecord.consultarPuntosVentaResponse) ?? toRecord(responseRecord.consultarPuntosVentaResult) ?? responseRecord;
+  }
+  return toRecord(responseRecord.consultarUltimoComprobanteAutorizadoResponse) ?? toRecord(responseRecord.consultaUltimoComprobanteAutorizadoResponse) ?? toRecord(responseRecord.consultarUltimoComprobanteAutorizadoResult) ?? responseRecord;
+}
+function extractWsmtxcaAuthorizationPayload(raw) {
+  return toRecord(raw.comprobanteResponse) ?? toRecord(raw.comprobanteCAEResponse) ?? toRecord(raw.comprobanteCAEReponse) ?? raw;
+}
+function extractWsmtxcaVoucherPayload(raw) {
+  return toRecord(raw.comprobanteResponse) ?? toRecord(raw.comprobante) ?? toRecord(raw.cmp) ?? raw;
+}
+function classifyWsmtxcaAuthorization(raw) {
+  const operation = "autorizarComprobante";
+  const payload = extractWsmtxcaAuthorizationPayload(raw);
+  const result = normalizeWsmtxcaResult(raw.resultado ?? payload.resultado);
+  const cae = normalizeWsmtxcaString(
+    payload.CAE ?? payload.codigoAutorizacion ?? raw.codigoAutorizacion
+  );
+  const caeExpiry = normalizeWsmtxcaResponseDate(
+    payload.fechaVencimientoCAE ?? payload.fechaVencimiento ?? raw.fechaVencimiento
+  );
+  const voucherNumber = parseOptionalPositiveInteger(
+    payload.numeroComprobante ?? raw.numeroComprobante
+  );
+  const errors = extractWsmtxcaIssues(raw, operation, "error");
+  const observations = extractWsmtxcaIssues(raw, operation, "observation");
+  const base = {
+    service: "wsmtxca",
+    operation,
+    results: createWsmtxcaResults(result),
+    errors,
+    observations,
+    raw
+  };
+  const authenticationOutcome = createWsmtxcaAuthenticationOutcome({
+    base,
+    result,
+    cae,
+    voucherNumber
+  });
+  if (authenticationOutcome) {
+    return authenticationOutcome;
+  }
+  if ((result === "A" || result === "O") && cae && voucherNumber !== void 0 && errors.length === 0) {
+    return {
+      ...base,
+      kind: "authorized",
+      result,
+      resultLevel: "operation",
+      cae,
+      ...caeExpiry === void 0 ? {} : { caeExpiry },
+      voucherNumber
+    };
+  }
+  if (result === "R" && !cae && errors.length > 0) {
+    return {
+      ...base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "operation"
+    };
+  }
+  const outcome = {
+    ...base,
+    kind: "indeterminate",
+    reason: result === "R" && Boolean(cae) || (result === "A" || result === "O") && Boolean(errors.length) ? "contradictory_response" : "incomplete_response",
+    ...result === void 0 ? {} : { result },
+    ...result === void 0 ? {} : { resultLevel: "operation" }
+  };
+  assignWsmtxcaValue(outcome, "cae", cae);
+  assignWsmtxcaValue(outcome, "caeExpiry", caeExpiry);
+  assignWsmtxcaValue(outcome, "voucherNumber", voucherNumber);
+  return outcome;
+}
+function createWsmtxcaAuthenticationOutcome({
+  base,
+  result,
+  cae,
+  voucherNumber
+}) {
+  const authenticationError = classifyArcaAuthenticationIssues(base.errors, {
+    service: base.service,
+    operation: base.operation
+  });
+  if (!authenticationError || result === "A" || result === "O" || cae || voucherNumber !== void 0) {
+    return void 0;
+  }
+  return {
+    ...base,
+    kind: "indeterminate",
+    reason: "authentication_rejected",
+    authentication: createArcaAuthenticationEvidence(authenticationError),
+    ...result === void 0 ? {} : { result },
+    ...result === void 0 ? {} : { resultLevel: "operation" }
+  };
+}
+function createWsmtxcaIndeterminateOutcome(error) {
+  const authenticationError = classifyArcaAuthenticationError(error, {
+    service: "wsmtxca",
+    operation: "autorizarComprobante"
+  });
+  return {
+    kind: "indeterminate",
+    service: "wsmtxca",
+    operation: "autorizarComprobante",
+    results: {},
+    reason: authenticationError ? "authentication_rejected" : getWsmtxcaIndeterminateReason(error),
+    ...authenticationError ? {
+      authentication: createArcaAuthenticationEvidence(authenticationError)
+    } : {},
+    errors: [],
+    observations: []
+  };
+}
+function getWsmtxcaIndeterminateReason(error) {
+  if (error instanceof ArcaTransportError) {
+    return "transport_error";
+  }
+  if (error instanceof ArcaSoapFaultError) {
+    return "soap_fault";
+  }
+  if (error instanceof ArcaInvalidSoapResponseError) {
+    return "invalid_response";
+  }
+  return "unexpected_error";
+}
+function createWsmtxcaOutcomeError(outcome) {
+  if (outcome.kind === "indeterminate" && outcome.authentication) {
+    return createArcaAuthenticationErrorFromEvidence(outcome.authentication, {
+      service: "wsmtxca",
+      operation: outcome.operation
+    });
+  }
+  const issues = [...outcome.errors, ...outcome.observations];
+  const messages = formatWsmtxcaIssues(issues);
+  const firstIssue = issues[0];
+  return new ArcaServiceError(
+    messages.join(" | ") || (outcome.kind === "rejected" ? "WSMTXCA rejected the voucher authorization" : "WSMTXCA did not return conclusive voucher authorization data"),
+    {
+      service: "wsmtxca",
+      operation: outcome.operation,
+      ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+      ...outcome.result === void 0 ? {} : { result: outcome.result },
+      ...outcome.resultLevel === void 0 ? {} : { resultLevel: outcome.resultLevel },
+      results: outcome.results,
+      ...outcome.kind === "indeterminate" && outcome.cae ? { cae: outcome.cae } : {},
+      issues
+    }
+  );
+}
+function createWsmtxcaResults(operationResult) {
+  const results = {};
+  assignWsmtxcaValue(results, "operation", operationResult);
+  return results;
+}
+function createWsmtxcaServiceError(operation, issues) {
+  const authenticationError = classifyArcaAuthenticationIssues(issues, {
+    service: "wsmtxca",
+    operation
+  });
+  if (authenticationError) {
+    return authenticationError;
+  }
+  const firstIssue = issues[0];
+  return new ArcaServiceError(
+    formatWsmtxcaIssues(issues).join(" | ") || "WSMTXCA returned a service error",
+    {
+      service: "wsmtxca",
+      operation,
+      ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+      issues
+    }
+  );
+}
+function throwForWsmtxcaOperationErrors(operation, raw) {
+  const errors = extractWsmtxcaIssues(raw, operation, "error");
+  if (errors.length > 0) {
+    throw createWsmtxcaServiceError(operation, errors);
+  }
+}
+function extractWsmtxcaIssues(raw, operation, source) {
+  const container = toRecord(
+    source === "error" ? raw.arrayErrores : raw.arrayObservaciones
+  );
+  return normalizeWsmtxcaIssueEntries(container?.codigoDescripcion).map(
+    (entry) => ({
+      service: "wsmtxca",
+      operation,
+      source,
+      category: source === "observation" ? "observation" : operation === "autorizarComprobante" ? "business" : "unknown",
+      ...entry.code === void 0 ? {} : { code: entry.code },
+      message: entry.message,
+      ...operation === "autorizarComprobante" ? { resultLevel: "operation" } : {}
+    })
+  );
+}
+function normalizeWsmtxcaIssueEntries(value) {
+  const entries = Array.isArray(value) ? value : value ? [value] : [];
+  return entries.map((entry) => {
+    const record = toRecord(entry) ?? {};
+    const code = record.codigo;
+    const description = record.descripcion;
+    return {
+      ...code === void 0 || code === null ? {} : { code: String(code) },
+      message: description === void 0 || description === null ? "Unknown WSMTXCA issue" : String(description)
+    };
+  });
+}
+function formatWsmtxcaIssues(issues) {
+  return issues.map((issue) => {
+    const prefix = issue.source === "error" ? "Error" : "Obs";
+    return `${prefix}${issue.code ? ` ${issue.code}` : ""}: ${issue.message}`;
+  });
+}
+function mapWsmtxcaVoucherInfo(raw) {
+  const voucher = { raw };
+  const invoiceDate = normalizeWsmtxcaResponseDate(
+    raw.fechaEmision ?? raw.fecha ?? raw.CbteFch
+  );
+  const cae = normalizeWsmtxcaString(raw.codigoAutorizacion ?? raw.CAE);
+  const caeExpiry = normalizeWsmtxcaResponseDate(
+    raw.fechaVencimiento ?? raw.fechaVencimientoCAE
+  );
+  const vatAmount = sumWsmtxcaVatAmounts(raw.arraySubtotalesIVA);
+  assignWsmtxcaValue(
+    voucher,
+    "voucherNumber",
+    parseOptionalPositiveInteger(raw.numeroComprobante)
+  );
+  assignWsmtxcaValue(voucher, "invoiceDate", invoiceDate);
+  assignWsmtxcaValue(
+    voucher,
+    "salesPoint",
+    parseOptionalPositiveInteger(raw.numeroPuntoVenta)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "voucherType",
+    parseOptionalPositiveInteger(raw.codigoTipoComprobante)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "concept",
+    parseOptionalNumber(raw.codigoConcepto)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "documentType",
+    parseOptionalNumber(raw.codigoTipoDocumento)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "documentNumber",
+    normalizeWsmtxcaString(raw.numeroDocumento)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "receiverVatConditionId",
+    parseOptionalNumber(raw.condicionIVAReceptor)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "totalAmount",
+    parseOptionalNumber(raw.importeTotal)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "subtotalAmount",
+    parseOptionalNumber(raw.importeSubtotal)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "taxableAmount",
+    parseOptionalNumber(raw.importeGravado)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "nonTaxableAmount",
+    parseOptionalNumber(raw.importeNoGravado)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "exemptAmount",
+    parseOptionalNumber(raw.importeExento)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "taxAmount",
+    parseOptionalNumber(raw.importeOtrosTributos)
+  );
+  assignWsmtxcaValue(voucher, "vatAmount", vatAmount);
+  assignWsmtxcaValue(
+    voucher,
+    "currencyId",
+    normalizeWsmtxcaString(raw.codigoMoneda)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "exchangeRate",
+    parseOptionalNumber(raw.cotizacionMoneda)
+  );
+  assignWsmtxcaValue(voucher, "cae", cae);
+  assignWsmtxcaValue(voucher, "caeExpiry", caeExpiry);
+  return voucher;
+}
+function sumWsmtxcaVatAmounts(value) {
+  const subtotals = toRecord(value)?.subtotalIVA;
+  const entries = Array.isArray(subtotals) ? subtotals : subtotals ? [subtotals] : [];
+  const amounts = entries.map((entry) => parseOptionalNumber(toRecord(entry)?.importe)).filter((amount) => amount !== void 0);
+  return amounts.length > 0 ? amounts.reduce((total, amount) => total + amount, 0) : void 0;
+}
+function parseWsmtxcaVoucherNumber(value, message, allowZero = false) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (!Number.isFinite(parsed) || (allowZero ? parsed < 0 : parsed <= 0)) {
+    throw new ArcaServiceError(message, {
+      service: "wsmtxca"
+    });
+  }
+  return parsed;
+}
+function parseOptionalPositiveInteger(value) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function parseOptionalNumber(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeWsmtxcaResult(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toUpperCase();
+  return normalized || void 0;
+}
+function normalizeWsmtxcaString(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalized = String(value).trim();
+  return normalized || void 0;
+}
+function assignWsmtxcaValue(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function normalizeWsmtxcaResponseDate(value) {
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return formatCompactDateToIso(value);
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (/^\d{8}$/.test(trimmed)) {
+    return formatCompactDateToIso(Number.parseInt(trimmed, 10));
+  }
+  if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+    return trimmed.slice(0, 10);
+  }
+  return void 0;
+}
+function formatCompactDateToIso(dateValue) {
+  if (!dateValue) {
+    return void 0;
+  }
+  const raw = String(dateValue);
+  if (raw.length !== 8) {
+    return void 0;
+  }
+  return `${raw.slice(0, 4)}-${raw.slice(4, 6)}-${raw.slice(6, 8)}`;
+}
+
+export {
+  createWsmtxcaService
+};
+//# sourceMappingURL=chunk-PKE4Z4GE.mjs.map