@inneranimalmedia/agentsam-sdk 2.6.4 → 2.6.5

package/packages/connectors/cloudflare/src/families/pages.js

@@ -0,0 +1,151 @@
+/** Cloudflare Pages — /accounts/{id}/pages/projects/... */
+import { receipt } from '../api-client.js';
+
+const CAP = 'cloudflare.pages';
+
+export async function pagesStatus(client) {
+  client.requireAccount('pages.status');
+  try {
+    const res = await client.request('GET', client.accountPath('/pages/projects'), {
+      capabilityId: CAP,
+      operation: 'pages.list',
+      query: { per_page: 1 },
+    });
+    return receipt(CAP, 'status', {
+      ok: true,
+      availability: 'available',
+      authorized: true,
+      account_id: client.accountId,
+      auth: client.authMeta(),
+      project_sample: Array.isArray(res.result) ? res.result.length : null,
+    });
+  } catch (err) {
+    if (err.code === 'cloudflare_permission_denied') {
+      return receipt(CAP, 'status', { ok: false, authorized: false, ...err.toJSON() });
+    }
+    throw err;
+  }
+}
+
+export async function pagesList(client, query = {}) {
+  client.requireAccount('pages.list');
+  const res = await client.request('GET', client.accountPath('/pages/projects'), {
+    capabilityId: CAP,
+    operation: 'pages.list',
+    query,
+  });
+  return receipt(CAP, 'list', {
+    ok: true,
+    projects: res.result || [],
+    result_info: res.result_info,
+    auth: client.authMeta(),
+  });
+}
+
+export async function pagesInspect(client, projectName) {
+  client.requireAccount('pages.inspect');
+  const res = await client.request('GET', client.accountPath(`/pages/projects/${encodeURIComponent(projectName)}`), {
+    capabilityId: CAP,
+    operation: 'pages.inspect',
+  });
+  return receipt(CAP, 'inspect', { ok: true, project: res.result, auth: client.authMeta() });
+}
+
+export async function pagesDeployments(client, projectName, query = {}) {
+  client.requireAccount('pages.deployments');
+  const res = await client.request(
+    'GET',
+    client.accountPath(`/pages/projects/${encodeURIComponent(projectName)}/deployments`),
+    { capabilityId: CAP, operation: 'pages.deployments', query },
+  );
+  return receipt(CAP, 'deployments', {
+    ok: true,
+    project: projectName,
+    deployments: res.result || [],
+    result_info: res.result_info,
+  });
+}
+
+export async function pagesDeployment(client, projectName, deploymentId) {
+  client.requireAccount('pages.deployment');
+  const res = await client.request(
+    'GET',
+    client.accountPath(
+      `/pages/projects/${encodeURIComponent(projectName)}/deployments/${encodeURIComponent(deploymentId)}`,
+    ),
+    { capabilityId: CAP, operation: 'pages.deployment' },
+  );
+  return receipt(CAP, 'deployment', { ok: true, project: projectName, deployment: res.result });
+}
+
+export async function pagesDeploymentLogs(client, projectName, deploymentId) {
+  client.requireAccount('pages.logs');
+  const res = await client.request(
+    'GET',
+    client.accountPath(
+      `/pages/projects/${encodeURIComponent(projectName)}/deployments/${encodeURIComponent(deploymentId)}/history/logs`,
+    ),
+    { capabilityId: CAP, operation: 'pages.logs' },
+  );
+  return receipt(CAP, 'logs', { ok: true, project: projectName, deployment_id: deploymentId, logs: res.result });
+}
+
+export async function pagesDomains(client, projectName) {
+  client.requireAccount('pages.domains');
+  const res = await client.request(
+    'GET',
+    client.accountPath(`/pages/projects/${encodeURIComponent(projectName)}/domains`),
+    { capabilityId: CAP, operation: 'pages.domains' },
+  );
+  return receipt(CAP, 'domains', { ok: true, project: projectName, domains: res.result || [] });
+}
+
+export async function pagesUploadToken(client, projectName) {
+  client.requireAccount('pages.upload_token');
+  const res = await client.request(
+    'GET',
+    client.accountPath(`/pages/projects/${encodeURIComponent(projectName)}/upload-token`),
+    { capabilityId: CAP, operation: 'pages.upload_token' },
+  );
+  // JWT is short-lived operational secret — do not echo in human receipts by default
+  return receipt(CAP, 'upload_token', {
+    ok: true,
+    project: projectName,
+    has_jwt: Boolean(res.result?.jwt),
+    // Only include jwt when caller opts in via client flag later; omit by default
+  });
+}
+
+export async function pagesPurgeBuildCache(client, projectName) {
+  client.requireAccount('pages.purge');
+  const res = await client.request(
+    'POST',
+    client.accountPath(`/pages/projects/${encodeURIComponent(projectName)}/purge_build_cache`),
+    { capabilityId: CAP, operation: 'pages.purge_build_cache' },
+  );
+  return receipt(CAP, 'purge_build_cache', { ok: true, project: projectName, result: res.result });
+}
+
+export async function pagesRetryDeployment(client, projectName, deploymentId) {
+  client.requireAccount('pages.retry');
+  const res = await client.request(
+    'POST',
+    client.accountPath(
+      `/pages/projects/${encodeURIComponent(projectName)}/deployments/${encodeURIComponent(deploymentId)}/retry`,
+    ),
+    { capabilityId: CAP, operation: 'pages.retry' },
+  );
+  return receipt(CAP, 'retry', { ok: true, project: projectName, deployment: res.result });
+}
+
+export async function pagesRollbackDeployment(client, projectName, deploymentId) {
+  client.requireAccount('pages.rollback');
+  const res = await client.request(
+    'POST',
+    client.accountPath(
+      `/pages/projects/${encodeURIComponent(projectName)}/deployments/${encodeURIComponent(deploymentId)}/rollback`,
+    ),
+    { capabilityId: CAP, operation: 'pages.rollback' },
+  );
+  return receipt(CAP, 'rollback', { ok: true, project: projectName, deployment: res.result });
+}

package/packages/connectors/cloudflare/src/families/scanner.js

@@ -0,0 +1,123 @@
+/** Cloudflare URL Scanner v2 — real API. */
+import { receipt } from '../api-client.js';
+
+const CAP = 'cloudflare.url_scanner';
+
+export async function scannerStatus(client) {
+  client.requireAccount('scanner.status');
+  try {
+    // Lightweight authorized probe: empty search
+    await client.request('GET', client.accountPath('/urlscanner/v2/search'), {
+      capabilityId: CAP,
+      operation: 'scanner.search',
+      query: { q: 'page.domain:example.com', size: 1 },
+    });
+    return receipt(CAP, 'status', {
+      ok: true,
+      availability: 'available',
+      authorized: true,
+      account_id: client.accountId,
+      permission: 'Account → URL Scanner → Edit',
+    });
+  } catch (err) {
+    if (err.code === 'cloudflare_permission_denied') {
+      return receipt(CAP, 'status', {
+        ok: false,
+        availability: 'available',
+        authorized: false,
+        ...err.toJSON(),
+      });
+    }
+    // Search may 400 on query — still proves auth if not 401/403
+    if (err.httpStatus && err.httpStatus !== 401 && err.httpStatus !== 403) {
+      return receipt(CAP, 'status', {
+        ok: true,
+        availability: 'available',
+        authorized: true,
+        account_id: client.accountId,
+        note: 'probe_non_auth_error',
+      });
+    }
+    throw err;
+  }
+}
+
+export async function scannerScan(client, url, options = {}) {
+  client.requireAccount('scanner.scan');
+  const body = { url, ...options };
+  const res = await client.request('POST', client.accountPath('/urlscanner/v2/scan'), {
+    capabilityId: CAP,
+    operation: 'scanner.scan',
+    body,
+  });
+  return receipt(CAP, 'scan', { ok: true, scan: res.result });
+}
+
+export async function scannerBulk(client, urls = []) {
+  client.requireAccount('scanner.bulk');
+  const body = (urls || []).map((u) => (typeof u === 'string' ? { url: u } : u));
+  const res = await client.request('POST', client.accountPath('/urlscanner/v2/bulk'), {
+    capabilityId: CAP,
+    operation: 'scanner.bulk',
+    body,
+  });
+  return receipt(CAP, 'bulk', { ok: true, scans: res.result });
+}
+
+export async function scannerResult(client, scanId) {
+  client.requireAccount('scanner.result');
+  const res = await client.request('GET', client.accountPath(`/urlscanner/v2/result/${encodeURIComponent(scanId)}`), {
+    capabilityId: CAP,
+    operation: 'scanner.result',
+  });
+  return receipt(CAP, 'result', { ok: true, scan_id: scanId, result: res.result });
+}
+
+export async function scannerSearch(client, query = {}) {
+  client.requireAccount('scanner.search');
+  const res = await client.request('GET', client.accountPath('/urlscanner/v2/search'), {
+    capabilityId: CAP,
+    operation: 'scanner.search',
+    query,
+  });
+  return receipt(CAP, 'search', { ok: true, results: res.result, result_info: res.result_info });
+}
+
+export async function scannerHar(client, scanId) {
+  client.requireAccount('scanner.har');
+  const res = await client.request('GET', client.accountPath(`/urlscanner/v2/har/${encodeURIComponent(scanId)}`), {
+    capabilityId: CAP,
+    operation: 'scanner.har',
+  });
+  return receipt(CAP, 'har', { ok: true, scan_id: scanId, har: res.result });
+}
+
+export async function scannerDom(client, scanId) {
+  client.requireAccount('scanner.dom');
+  const res = await client.request('GET', client.accountPath(`/urlscanner/v2/dom/${encodeURIComponent(scanId)}`), {
+    capabilityId: CAP,
+    operation: 'scanner.dom',
+    raw: true,
+  });
+  return receipt(CAP, 'dom', {
+    ok: true,
+    scan_id: scanId,
+    dom: Buffer.isBuffer(res.body) ? res.body.toString('utf8') : res.body,
+  });
+}
+
+export async function scannerScreenshot(client, scanId) {
+  client.requireAccount('scanner.screenshot');
+  const res = await client.request(
+    'GET',
+    client.accountPath(`/urlscanner/v2/screenshots/${encodeURIComponent(scanId)}.png`),
+    { capabilityId: CAP, operation: 'scanner.screenshot', raw: true },
+  );
+  return receipt(CAP, 'screenshot', {
+    ok: true,
+    scan_id: scanId,
+    content_type: 'image/png',
+    bytes: res.body?.length || 0,
+    png_base64: Buffer.isBuffer(res.body) ? res.body.toString('base64') : null,
+  });
+}

package/packages/connectors/cloudflare/src/families/snippets.js

@@ -0,0 +1,207 @@
+/**
+ * Cloudflare Snippets — zone-scoped tiny edge logic.
+ *
+ * CRITICAL: PUT /snippets/snippet_rules replaces the zone's entire rules collection.
+ * Always: read → reconcile (preserve foreign rules) → plan → approve → PUT → verify.
+ *
+ * OAuth scope: Cloudflare documents Snippets Read/Write as API permissions.
+ * Scope string is NOT invented here — if oauthScopes is empty, capability is token_required
+ * until the OAuth app catalog exposes a verified identifier.
+ */
+import { receipt } from '../api-client.js';
+import crypto from 'node:crypto';
+
+const CAP = 'cloudflare.snippets';
+const AGENTSAM_RULE_PREFIX = '[AgentSam]';
+
+function hashText(value) {
+  return crypto.createHash('sha256').update(String(value || '')).digest('hex').slice(0, 16);
+}
+
+export async function snippetsStatus(client, zoneId) {
+  try {
+    const res = await client.request('GET', client.zonePath(zoneId, '/snippets'), {
+      capabilityId: CAP,
+      operation: 'snippets.list',
+    });
+    return receipt(CAP, 'status', {
+      ok: true,
+      availability: 'available',
+      authorized: true,
+      zone_id: zoneId,
+      snippet_count: Array.isArray(res.result) ? res.result.length : null,
+      auth: client.authMeta(),
+      limits_note: 'Snippets: ~5ms CPU, 2MB memory, 32KB package; Pro+; proxied DNS required.',
+    });
+  } catch (err) {
+    if (err.code === 'cloudflare_permission_denied') {
+      return receipt(CAP, 'status', {
+        ok: false,
+        zone_id: zoneId,
+        authorized: false,
+        status: 'token_required_or_unauthorized',
+        permission: 'Snippets Read / Snippets Write',
+        note: 'OAuth scope string not assumed — use CLOUDFLARE_API_TOKEN with Snippets Write if OAuth catalog lacks it.',
+        ...err.toJSON(),
+      });
+    }
+    if (err.httpStatus === 404 || /plan|not.?entitled|pro/i.test(err.message)) {
+      return receipt(CAP, 'status', {
+        ok: false,
+        availability: 'unavailable_on_plan',
+        zone_id: zoneId,
+        message: err.message,
+        learn: 'Cloudflare → Rules → Snippets (Pro / Business / Enterprise)',
+      });
+    }
+    throw err;
+  }
+}
+
+export async function snippetsList(client, zoneId) {
+  const res = await client.request('GET', client.zonePath(zoneId, '/snippets'), {
+    capabilityId: CAP,
+    operation: 'snippets.list',
+  });
+  return receipt(CAP, 'list', { ok: true, zone_id: zoneId, snippets: res.result || [] });
+}
+
+export async function snippetsInspect(client, zoneId, name) {
+  const res = await client.request('GET', client.zonePath(zoneId, `/snippets/${encodeURIComponent(name)}`), {
+    capabilityId: CAP,
+    operation: 'snippets.inspect',
+  });
+  return receipt(CAP, 'inspect', { ok: true, zone_id: zoneId, snippet: res.result });
+}
+
+export async function snippetsContent(client, zoneId, name) {
+  const res = await client.request(
+    'GET',
+    client.zonePath(zoneId, `/snippets/${encodeURIComponent(name)}/content`),
+    { capabilityId: CAP, operation: 'snippets.content', raw: true },
+  );
+  const text = Buffer.isBuffer(res.body) ? res.body.toString('utf8') : String(res.body || '');
+  return receipt(CAP, 'content', {
+    ok: true,
+    zone_id: zoneId,
+    snippet_name: name,
+    content_sha256_16: hashText(text),
+    bytes: text.length,
+    // Include content only in structured result for tooling — still redacted from default human format
+    content: text,
+  });
+}
+
+export async function snippetsPut(client, zoneId, name, body, { yes = false } = {}) {
+  if (!yes) {
+    return receipt(CAP, 'plan', {
+      ok: true,
+      planned: true,
+      zone_id: zoneId,
+      snippet_name: name,
+      operation: 'PUT /snippets/{name}',
+      note: 'Pass --yes to apply. Re-fetch after apply for verification.',
+      body_preview: typeof body === 'string' ? { content_sha256_16: hashText(body) } : body,
+    });
+  }
+  const res = await client.request('PUT', client.zonePath(zoneId, `/snippets/${encodeURIComponent(name)}`), {
+    capabilityId: CAP,
+    operation: 'snippets.put',
+    body,
+  });
+  const verify = await snippetsInspect(client, zoneId, name);
+  return receipt(CAP, 'apply', {
+    ok: true,
+    zone_id: zoneId,
+    snippet_name: name,
+    result: res.result,
+    verification: verify.snippet || null,
+    auth: client.authMeta(),
+  });
+}
+
+export async function snippetsDelete(client, zoneId, name, { yes = false } = {}) {
+  if (!yes) {
+    return receipt(CAP, 'plan', {
+      ok: true,
+      planned: true,
+      zone_id: zoneId,
+      snippet_name: name,
+      operation: 'DELETE',
+    });
+  }
+  const res = await client.request('DELETE', client.zonePath(zoneId, `/snippets/${encodeURIComponent(name)}`), {
+    capabilityId: CAP,
+    operation: 'snippets.delete',
+  });
+  return receipt(CAP, 'delete', { ok: true, zone_id: zoneId, snippet_name: name, result: res.result });
+}
+
+export async function snippetsRulesList(client, zoneId) {
+  const res = await client.request('GET', client.zonePath(zoneId, '/snippets/snippet_rules'), {
+    capabilityId: CAP,
+    operation: 'snippets.rules.list',
+  });
+  return receipt(CAP, 'rules.list', { ok: true, zone_id: zoneId, rules: res.result || [] });
+}
+
+/**
+ * Plan a rules collection write that PRESERVES non-AgentSam rules.
+ * desiredRules: AgentSam-owned rules to upsert (matched by description prefix + snippet name).
+ */
+export function reconcileSnippetRules(existingRules = [], desiredAgentSamRules = []) {
+  const foreign = (existingRules || []).filter((r) => {
+    const desc = String(r.description || r.rule?.description || '');
+    return !desc.startsWith(AGENTSAM_RULE_PREFIX);
+  });
+  const owned = (desiredAgentSamRules || []).map((r) => ({
+    ...r,
+    description: String(r.description || '').startsWith(AGENTSAM_RULE_PREFIX)
+      ? r.description
+      : `${AGENTSAM_RULE_PREFIX} ${r.description || r.snippet || 'edge'}`.trim(),
+  }));
+  const next = [...foreign, ...owned];
+  return {
+    existing_count: (existingRules || []).length,
+    foreign_preserved: foreign.length,
+    agentsam_rules: owned.length,
+    next_count: next.length,
+    rules: next,
+    dropped_agentsam_replaced: (existingRules || []).length - foreign.length,
+  };
+}
+
+export async function snippetsRulesPlan(client, zoneId, desiredAgentSamRules = []) {
+  const current = await snippetsRulesList(client, zoneId);
+  const plan = reconcileSnippetRules(current.rules, desiredAgentSamRules);
+  return receipt(CAP, 'rules.plan', {
+    ok: true,
+    zone_id: zoneId,
+    planned: true,
+    ...plan,
+    warning: 'PUT replaces the entire snippet_rules collection — foreign rules are preserved by reconcile.',
+  });
+}
+
+export async function snippetsRulesApply(client, zoneId, desiredAgentSamRules = [], { yes = false } = {}) {
+  const plan = await snippetsRulesPlan(client, zoneId, desiredAgentSamRules);
+  if (!yes) return plan;
+  const res = await client.request('PUT', client.zonePath(zoneId, '/snippets/snippet_rules'), {
+    capabilityId: CAP,
+    operation: 'snippets.rules.apply',
+    body: { rules: plan.rules },
+  });
+  const after = await snippetsRulesList(client, zoneId);
+  return receipt(CAP, 'rules.apply', {
+    ok: true,
+    zone_id: zoneId,
+    result: res.result,
+    before_count: plan.existing_count,
+    after_count: (after.rules || []).length,
+    foreign_preserved: plan.foreign_preserved,
+    verification: after.rules,
+    auth: client.authMeta(),
+  });
+}
+
+export { AGENTSAM_RULE_PREFIX };

package/packages/connectors/cloudflare/src/families/tag-gateway.js

@@ -0,0 +1,46 @@
+/** Google Tag Gateway — zone setting API. */
+import { receipt } from '../api-client.js';
+
+const CAP = 'cloudflare.tag_gateway';
+
+export async function tagGatewayStatus(client, zoneId) {
+  const res = await client.request('GET', client.zonePath(zoneId, '/settings/google-tag-gateway/config'), {
+    capabilityId: CAP,
+    operation: 'tag_gateway.status',
+  });
+  return receipt(CAP, 'status', {
+    ok: true,
+    zone_id: zoneId,
+    config: res.result,
+    availability: 'available',
+  });
+}
+
+export async function tagGatewayConfigure(client, zoneId, config = {}) {
+  const body = {
+    enabled: config.enabled !== false,
+    measurementId: config.measurementId || config.measurement_id,
+    endpoint: config.endpoint || '/metrics',
+    hideOriginalIp: config.hideOriginalIp ?? config.hide_original_ip ?? true,
+    setUpTag: config.setUpTag ?? config.set_up_tag ?? true,
+  };
+  const res = await client.request('PUT', client.zonePath(zoneId, '/settings/google-tag-gateway/config'), {
+    capabilityId: CAP,
+    operation: 'tag_gateway.configure',
+    body,
+  });
+  return receipt(CAP, 'configure', { ok: true, zone_id: zoneId, config: res.result });
+}
+
+export async function tagGatewayDisable(client, zoneId) {
+  const current = await tagGatewayStatus(client, zoneId);
+  const prev = current.config || {};
+  return tagGatewayConfigure(client, zoneId, {
+    ...prev,
+    enabled: false,
+    measurementId: prev.measurementId,
+    endpoint: prev.endpoint || '/metrics',
+    hideOriginalIp: prev.hideOriginalIp,
+    setUpTag: prev.setUpTag,
+  });
+}

package/packages/connectors/cloudflare/src/families/tags.js

@@ -0,0 +1,124 @@
+/** Cloudflare account resource tags — Enterprise tagging API. */
+import { receipt } from '../api-client.js';
+
+const CAP = 'cloudflare.resource_tags';
+
+export async function tagsStatus(client) {
+  client.requireAccount('tags.status');
+  try {
+    await client.request('GET', client.accountPath('/tags/keys'), {
+      capabilityId: CAP,
+      operation: 'tags.keys',
+    });
+    return receipt(CAP, 'status', {
+      ok: true,
+      availability: 'available',
+      authorized: true,
+      plan_note: 'Account resource tagging is Enterprise (beta) per Cloudflare OpenAPI.',
+      account_id: client.accountId,
+    });
+  } catch (err) {
+    if (err.code === 'cloudflare_permission_denied' || err.httpStatus === 403) {
+      return receipt(CAP, 'status', {
+        ok: false,
+        availability: 'enterprise',
+        authorized: false,
+        ...err.toJSON(),
+      });
+    }
+    // 404 / plan errors
+    if (err.httpStatus === 404 || /enterprise|not.?entitled|not.?found/i.test(err.message)) {
+      return receipt(CAP, 'status', {
+        ok: false,
+        availability: 'unavailable',
+        authorized: false,
+        plan: 'enterprise_required',
+        message: err.message,
+        learn: 'Cloudflare → Account → Resource Tagging (Enterprise)',
+      });
+    }
+    throw err;
+  }
+}
+
+export async function tagsKeys(client) {
+  client.requireAccount('tags.keys');
+  const res = await client.request('GET', client.accountPath('/tags/keys'), {
+    capabilityId: CAP,
+    operation: 'tags.keys',
+  });
+  return receipt(CAP, 'keys', { ok: true, keys: res.result });
+}
+
+export async function tagsValues(client, tagKey) {
+  client.requireAccount('tags.values');
+  const res = await client.request('GET', client.accountPath(`/tags/values/${encodeURIComponent(tagKey)}`), {
+    capabilityId: CAP,
+    operation: 'tags.values',
+  });
+  return receipt(CAP, 'values', { ok: true, key: tagKey, values: res.result });
+}
+
+export async function tagsSummary(client) {
+  client.requireAccount('tags.summary');
+  const res = await client.request('GET', client.accountPath('/tags/summary'), {
+    capabilityId: CAP,
+    operation: 'tags.summary',
+  });
+  return receipt(CAP, 'summary', { ok: true, summary: res.result });
+}
+
+export async function tagsResources(client, query = {}) {
+  client.requireAccount('tags.resources');
+  const res = await client.request('GET', client.accountPath('/tags/resources'), {
+    capabilityId: CAP,
+    operation: 'tags.resources',
+    query,
+  });
+  return receipt(CAP, 'resources', { ok: true, resources: res.result, result_info: res.result_info });
+}
+
+export async function tagsGet(client, resource) {
+  client.requireAccount('tags.get');
+  const res = await client.request('GET', client.accountPath('/tags'), {
+    capabilityId: CAP,
+    operation: 'tags.get',
+    query: { resource },
+  });
+  return receipt(CAP, 'list', { ok: true, resource, tags: res.result });
+}
+
+export async function tagsPut(client, body, { ifMatch } = {}) {
+  client.requireAccount('tags.put');
+  const headersQuery = {};
+  // If-Match is a header — pass via custom request
+  const res = await client.request('PUT', client.accountPath('/tags'), {
+    capabilityId: CAP,
+    operation: 'tags.set',
+    body,
+  });
+  void ifMatch;
+  void headersQuery;
+  return receipt(CAP, 'set', { ok: true, result: res.result });
+}
+
+export async function tagsDelete(client, body) {
+  client.requireAccount('tags.delete');
+  const res = await client.request('DELETE', client.accountPath('/tags'), {
+    capabilityId: CAP,
+    operation: 'tags.delete',
+    body,
+  });
+  return receipt(CAP, 'delete', { ok: true, result: res.result ?? null, http_status: res.http_status });
+}
+
+/** AgentSam-owned tag vocabulary (provider-native keys). */
+export const AGENTSAM_TAG_VOCABULARY = Object.freeze([
+  'agentsam.product',
+  'agentsam.system',
+  'agentsam.environment',
+  'agentsam.lifecycle',
+  'agentsam.repository',
+  'agentsam.runtime',
+  'customer',
+]);