@adeu/core 1.8.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adeu/core",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/comments.ts

@@ -33,27 +33,27 @@ export class CommentsManager {
 
   constructor(public doc: DocumentObject) {}
 
-  public get commentsPart() {
+  public get commentsPart(): Part {
     if (!this._commentsPart) {
       this._commentsPart = this._getOrCreateCommentsPart();
       this._ensureNamespaces();
     }
-    return this._commentsPart;
+    return this._commentsPart!;
   }
 
-  public get extendedPart() {
+  public get extendedPart(): Part {
     if (!this._extendedPart) this._extendedPart = this._getOrCreateExtendedPart();
-    return this._extendedPart;
+    return this._extendedPart!;
   }
 
-  public get idsPart() {
+  public get idsPart(): Part {
     if (!this._idsPart) this._idsPart = this._getOrCreateIdsPart();
-    return this._idsPart;
+    return this._idsPart!;
   }
 
-  public get extensiblePart() {
+  public get extensiblePart(): Part {
     if (!this._extensiblePart) this._extensiblePart = this._getOrCreateExtensiblePart();
-    return this._extensiblePart;
+    return this._extensiblePart!;
   }
 
   public get nextId(): number {
@@ -124,9 +124,28 @@ export class CommentsManager {
   }
 
   private _ensureNamespaces() {
-    // In TS we use full xml reconstruction if attributes are missing, but xmldom generally tolerates
-    // runtime attributes if the namespace is declared. For absolute safety, if it's completely missing,
-    // we would rebuild. Assuming the parser caught them if they existed.
+    // When the comments part already existed (e.g. a legacy or pandoc-produced
+    // document) its root <w:comments> may omit the namespaces we rely on —
+    // most importantly w14, which qualifies the w14:paraId / w14:textId
+    // attributes we write on each comment paragraph. Without the declaration
+    // the serialised XML is invalid ("Namespace prefix w14 ... is not defined").
+    // Declare any missing namespace prefixes on the existing root element.
+    const root = this._commentsPart?._element;
+    if (!root) return;
+
+    const required: [string, string][] = [
+      ['xmlns:w', NS.w],
+      ['xmlns:w14', NS.w14],
+      ['xmlns:w15', NS.w15],
+      ['xmlns:w16cid', NS.w16cid],
+      ['xmlns:w16cex', NS.w16cex],
+      ['xmlns:mc', NS.mc],
+    ];
+    for (const [attr, uri] of required) {
+      if (!root.getAttribute(attr)) {
+        root.setAttribute(attr, uri);
+      }
+    }
   }
 
   private _getNextCommentId(): number {
@@ -273,10 +292,10 @@ export class CommentsManager {
   }
 
   public deleteComment(commentId: string) {
-    if (!this._commentsPart) return;
+    if (!this.commentsPart) return;
 
     let commentEl: Element | null = null;
-    for (const c of findAllDescendants(this._commentsPart._element, 'w:comment')) {
+    for (const c of findAllDescendants(this.commentsPart._element, 'w:comment')) {
       if (c.getAttribute('w:id') === commentId) {
         commentEl = c;
         break;
@@ -304,7 +323,7 @@ export class CommentsManager {
           if (child.getAttribute('w15:paraIdParent') === paraId) {
             const childParaId = child.getAttribute('w15:paraId');
             if (childParaId) {
-              for (const c of findAllDescendants(this._commentsPart._element, 'w:comment')) {
+              for (const c of findAllDescendants(this.commentsPart._element, 'w:comment')) {
                 for (const p of findAllDescendants(c, 'w:p')) {
                   if (p.getAttribute('w14:paraId') === childParaId) {
                     const cid = c.getAttribute('w:id');

package/src/consistency.test.ts

@@ -8,12 +8,13 @@ import {
 } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 
 import { DocumentObject } from "./docx/bridge.js";
 import { RedlineEngine } from "./engine.js";
 import { extractTextFromBuffer } from "./ingest.js";
+import { serializeXml } from "./docx/dom.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -28,10 +29,62 @@ const PYTHON_ABSTRACT_CMD = resolve(
 );
 const PYTHON_DIR = resolve(__dirname, "../../../../python");
 
+const CT_COMMENTS =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
+
 function normalizeMdTimestamps(mdText: string): string {
   return mdText.replace(/@ \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/g, "@ DATE");
 }
 
+function xmllintCheck(xmlContent: string, label: string): void {
+  // Cross-platform lookup: `which` on POSIX, `where` on Windows.
+  const locator = process.platform === "win32" ? "where" : "which";
+  let xmllintBin: string | null = null;
+  try {
+    xmllintBin =
+      execSync(`${locator} xmllint`, { encoding: "utf-8" })
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter(Boolean)[0] || null;
+  } catch {
+    /* not found */
+  }
+  if (!xmllintBin) {
+    // Optional external XML validation: skip when xmllint is unavailable
+    // (common on Windows). The in-code namespace assertion still runs.
+    return;
+  }
+  const tmpFile = resolve(tmpdir(), `adeu_consistency_${Date.now()}_${label}`);
+  try {
+    writeFileSync(tmpFile, xmlContent, "utf-8");
+    execFileSync(xmllintBin, ["--noout", tmpFile]);
+  } catch (err: any) {
+    throw new Error(
+      `xmllint validation failed for ${label}:\n${err.stderr ?? err.message}`,
+    );
+  } finally {
+    if (existsSync(tmpFile)) unlinkSync(tmpFile);
+  }
+}
+
+async function validateCommentsXmlNamespaces(
+  outBuffer: Buffer,
+  folder: string,
+): Promise<void> {
+  const doc = await DocumentObject.load(outBuffer);
+  const commentsPart = doc.pkg.parts.find((p) => p.contentType === CT_COMMENTS);
+  if (!commentsPart) return;
+
+  const commentsXml = serializeXml(
+    commentsPart._element.ownerDocument ?? commentsPart._element,
+  );
+
+  expect(commentsXml).toContain(
+    'xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"',
+  );
+  xmllintCheck(commentsXml, `${folder}_comments.xml`);
+}
+
 describe("Polyglot Consistency Framework (TS vs Python)", () => {
   if (!existsSync(CORPUS_DIR)) {
     it.skip("Cross-platform test corpus not found", () => {});
@@ -72,7 +125,12 @@ describe("Polyglot Consistency Framework (TS vs Python)", () => {
           engine.process_batch(testConfig.changes || []);
           outBuffer = await doc.save();
 
-          // 2. Assert XML Structure Parity (via Python Bridge)
+          // 2. Validate comments XML namespaces when requested by test.json
+          if (testConfig.validate_comments_xml_namespaces) {
+            await validateCommentsXmlNamespaces(outBuffer, folder);
+          }
+
+          // 3. Assert XML Structure Parity (via Python Bridge)
           const goldenXmlPath = resolve(testDir, "golden_abstract.xml");
           if (existsSync(goldenXmlPath)) {
             const expectedXml = readFileSync(goldenXmlPath, "utf-8");
@@ -103,7 +161,7 @@ describe("Polyglot Consistency Framework (TS vs Python)", () => {
           }
         }
 
-        // 3. Assert Markdown Extraction Parity (Raw View)
+        // 4. Assert Markdown Extraction Parity (Raw View)
         const rawMdPath = resolve(testDir, "golden_raw.md");
         if (existsSync(rawMdPath)) {
           const expectedRaw = readFileSync(rawMdPath, "utf-8").replace(
@@ -116,7 +174,7 @@ describe("Polyglot Consistency Framework (TS vs Python)", () => {
           expect(actualRaw).toBe(expectedRaw);
         }
 
-        // 4. Assert Markdown Extraction Parity (Clean View)
+        // 5. Assert Markdown Extraction Parity (Clean View)
         const cleanMdPath = resolve(testDir, "golden_clean.md");
         if (existsSync(cleanMdPath)) {
           const expectedClean = readFileSync(cleanMdPath, "utf-8").replace(

package/src/diff.ts

@@ -1,6 +1,34 @@
 import diff_match_patch from "diff-match-patch";
 import { ModifyText } from "./models.js";
 
+function _count_standalone_underscores(s: string): number {
+  let count = 0;
+  let i = 0;
+  const n = s.length;
+  const isAlnum = (char: string) => /[a-zA-Z0-9]/.test(char);
+  while (i < n) {
+    if (s[i] === "_") {
+      // Is it part of "__"?
+      let is_double = false;
+      if ((i > 0 && s[i - 1] === "_") || (i < n - 1 && s[i + 1] === "_")) {
+        is_double = true;
+      }
+
+      // Is it intra-word?
+      let is_intra = false;
+      if (i > 0 && isAlnum(s[i - 1]) && i < n - 1 && isAlnum(s[i + 1])) {
+        is_intra = true;
+      }
+
+      if (!is_double && !is_intra) {
+        count++;
+      }
+    }
+    i++;
+  }
+  return count;
+}
+
 export function trim_common_context(
   target: string,
   new_val: string,
@@ -44,7 +72,7 @@ export function trim_common_context(
     const left = target.substring(0, prefix_len);
     const b_count = (left.match(/\*\*/g) || []).length;
     const u2_count = (left.match(/__/g) || []).length;
-    const u1_count = (left.replace(/__/g, "").match(/_/g) || []).length;
+    const u1_count = _count_standalone_underscores(left);
 
     if (b_count % 2 !== 0) {
       prefix_len = left.lastIndexOf("**");
@@ -56,14 +84,18 @@ export function trim_common_context(
     }
     if (u1_count % 2 !== 0) {
       let idx = left.length - 1;
+      const isAlnum = (char: string) => /[a-zA-Z0-9]/.test(char);
       while (idx >= 0) {
         if (
           left[idx] === "_" &&
           (idx === 0 || left[idx - 1] !== "_") &&
           (idx === left.length - 1 || left[idx + 1] !== "_")
         ) {
-          prefix_len = idx;
-          break;
+          const is_intra = idx > 0 && isAlnum(left[idx - 1]) && idx < left.length - 1 && isAlnum(left[idx + 1]);
+          if (!is_intra) {
+            prefix_len = idx;
+            break;
+          }
         }
         idx--;
       }
@@ -140,7 +172,7 @@ export function trim_common_context(
     const right = target.substring(target.length - suffix_len);
     const b_count = (right.match(/\*\*/g) || []).length;
     const u2_count = (right.match(/__/g) || []).length;
-    const u1_count = (right.replace(/__/g, "").match(/_/g) || []).length;
+    const u1_count = _count_standalone_underscores(right);
 
     if (b_count % 2 !== 0) {
       suffix_len -= right.indexOf("**") + 2;
@@ -152,14 +184,18 @@ export function trim_common_context(
     }
     if (u1_count % 2 !== 0) {
       let idx_in_right = 0;
+      const isAlnum = (char: string) => /[a-zA-Z0-9]/.test(char);
       while (idx_in_right < right.length) {
         if (
           right[idx_in_right] === "_" &&
           (idx_in_right === 0 || right[idx_in_right - 1] !== "_") &&
           (idx_in_right === right.length - 1 || right[idx_in_right + 1] !== "_")
         ) {
-          suffix_len -= idx_in_right + 1;
-          break;
+          const is_intra = idx_in_right > 0 && isAlnum(right[idx_in_right - 1]) && idx_in_right < right.length - 1 && isAlnum(right[idx_in_right + 1]);
+          if (!is_intra) {
+            suffix_len -= idx_in_right + 1;
+            break;
+          }
         }
         idx_in_right++;
       }

package/src/docx/dom.ts

@@ -49,7 +49,11 @@ export function findAllDescendants(
  * Parses raw XML strings into xmldom Documents.
  */
 export function parseXml(xmlString: string): Document {
-  return new DOMParser().parseFromString(xmlString, "text/xml");
+  // Strip UTF-8 BOM if present
+  if (xmlString.startsWith("\uFEFF")) {
+    xmlString = xmlString.slice(1);
+  }
+  return new DOMParser().parseFromString(xmlString, "text/xml") as unknown as Document;
 }
 
 /**
@@ -57,7 +61,7 @@ export function parseXml(xmlString: string): Document {
  * enforcing deterministic attribute ordering on the root element.
  */
 export function serializeXml(node: Node): string {
-  let xml = new XMLSerializer().serializeToString(node);
+  let xml = new XMLSerializer().serializeToString(node as any);
 
   // BUG-11: Deterministic namespace ordering on root elements.
   const rootTagRegex = /<([a-zA-Z0-9_:]+)(\s+[^>]+?)(>|\/>)/;

package/src/engine.bugs.test.ts

@@ -134,6 +134,12 @@ describe("Resolved Bugs Core Engine Verification", () => {
     // Direct string equality so Vitest prints the exact diff if they mismatch!
     expect(serialized).toBe(expected);
   });
+
+  it("BUG-BOM-1: parseXml successfully strips leading UTF-8 BOM (\\uFEFF)", () => {
+    const rawXml = `\uFEFF<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"></w:document>`;
+    const docXml = parseXml(rawXml);
+    expect(docXml.documentElement.tagName).toBe("w:document");
+  });
   it("BUG-11b: Sweeps orphaned comment anchors when accepting tracked changes", async () => {
     const doc = await createTestDocument();
     addParagraph(doc, "Confidential Information");
@@ -235,7 +241,7 @@ describe("Resolved Bugs Core Engine Verification", () => {
       "",
       null,
       "123",
-      doc.element.ownerDocument!
+      doc.element.ownerDocument!,
     );
     expect(ins).toBeNull();
   });
@@ -245,7 +251,7 @@ describe("Resolved Bugs Core Engine Verification", () => {
     const p = addParagraph(doc, "Short heading");
 
     const fakeCache = {
-      "CustomHeading": { name: "Custom Heading", outline_level: 2, bold: true }
+      CustomHeading: { name: "Custom Heading", outline_level: 2, bold: true },
     };
     (doc.pkg as any)._adeu_style_cache = [fakeCache, "Normal"];
 
@@ -259,7 +265,7 @@ describe("Resolved Bugs Core Engine Verification", () => {
     const buf = await doc.save();
     const body = await extractTextFromBuffer(buf, false);
     const pages = paginate(body, "");
-    
+
     const outlineNodes = extract_outline(
       doc,
       body,
@@ -295,7 +301,7 @@ describe("Resolved Bugs Core Engine Verification", () => {
     const end = xmlDoc.createElement("w:commentRangeEnd");
     end.setAttribute("w:id", c_id);
     p.appendChild(end);
-    
+
     const ref_run = xmlDoc.createElement("w:r");
     const ref = xmlDoc.createElement("w:commentReference");
     ref.setAttribute("w:id", c_id);
@@ -428,10 +434,18 @@ describe("Resolved Bugs Core Engine Verification", () => {
 
     // Author B tries to modify Author A's pending insertion
     const engineB = new RedlineEngine(doc, "Author B");
-    
+
     expect(() => {
-      engineB.process_batch([{ type: "modify", target_text: "Inserted by A.", new_text: "Modified by B." }]);
-    }).toThrowError(/Accept that change first or scope your edit outside of it/);
+      engineB.process_batch([
+        {
+          type: "modify",
+          target_text: "Inserted by A.",
+          new_text: "Modified by B.",
+        },
+      ]);
+    }).toThrowError(
+      /Accept that change first or scope your edit outside of it/,
+    );
   });
 
   it("BUG-CROSS-PARA-1: Cross-paragraph modify coalesces paragraphs and tracks para-mark deletion", async () => {
@@ -452,7 +466,7 @@ describe("Resolved Bugs Core Engine Verification", () => {
 
     const buf = await doc.save();
     const cleanText = await extractTextFromBuffer(buf, true);
-    
+
     expect(cleanText).not.toContain("ends here.\n\n");
     expect(cleanText).toContain("Clause 1 ends here. MERGED here.");
   });
@@ -467,15 +481,54 @@ describe("Resolved Bugs Core Engine Verification", () => {
     engine.process_batch([
       {
         type: "modify",
-        target_text: "ends here.\n\nParagraph 2 is in the middle.\n\nParagraph 3 begins",
+        target_text:
+          "ends here.\n\nParagraph 2 is in the middle.\n\nParagraph 3 begins",
         new_text: "ends here. MERGED",
       },
     ]);
 
     engine.accept_all_revisions();
     const cleanText = await extractTextFromBuffer(await doc.save(), true);
-    
+
     expect(cleanText).not.toContain("Paragraph 2");
     expect(cleanText).toContain("Paragraph 1 ends here. MERGED here.");
   });
+
+  it("BUG-REPRO: accept_all_revisions leaks comments and in-body comment anchors", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "This is the original text of the agreement.");
+    const engine = new RedlineEngine(doc, "Reviewer AI");
+
+    // Add a tracked change with a comment attached
+    engine.process_batch([
+      {
+        type: "modify",
+        target_text: "original text",
+        new_text: "updated text",
+        comment: "Should this be updated or kept as original?",
+      },
+    ]);
+
+    // Pre-condition check: comment parts exist
+    const original_comment_parts = doc.pkg.parts.filter(p => p.contentType.includes("comments"));
+    expect(original_comment_parts.length).toBeGreaterThan(0);
+
+    const original_xml = doc.element.toString();
+    expect(original_xml).toContain("w:commentRangeStart");
+    expect(original_xml).toContain("w:commentReference");
+
+    // Accept all
+    engine.accept_all_revisions();
+
+    // Verify comment removal
+    const final_xml = doc.element.toString();
+    
+    // Assert NO in-body comment anchors survive (anchors must be completely gone)
+    expect(final_xml).not.toContain("w:commentRangeStart");
+    expect(final_xml).not.toContain("w:commentRangeEnd");
+    expect(final_xml).not.toContain("w:commentReference");
+
+    const final_comment_parts = doc.pkg.parts.filter(p => p.contentType.includes("comments"));
+    expect(final_comment_parts.length).toBe(0);
+  });
 });

package/src/engine.feedback.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+import { RedlineEngine } from "./engine.js";
+import { extractTextFromBuffer } from "./ingest.js";
+
+describe("Feedback Layer & Dry Run Verification", () => {
+  it("process_batch returns detailed edit reports", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "The quick brown fox jumps over the lazy dog.");
+    const engine = new RedlineEngine(doc, "Reviewer TS");
+
+    const stats = (engine as any).process_batch([
+      { type: "modify", target_text: "quick brown fox", new_text: "fast red fox" }
+    ]);
+
+    expect(stats.edits).toBeDefined();
+    expect(stats.edits.length).toBe(1);
+
+    const report = stats.edits[0];
+    expect(report.status).toBe("applied");
+    expect(report.target_text).toBe("quick brown fox");
+    expect(report.new_text).toBe("fast red fox");
+
+    // Previews with context window
+    expect(report.critic_markup).toContain("{--quick brown--}{++fast red++} fox");
+    expect(report.critic_markup).toContain("The ");
+    expect(report.critic_markup).toContain(" jumps over");
+
+    expect(report.clean_text).toContain("The fast red fox jumps over");
+    expect(stats.engine).toBe("node");
+    expect(stats.version).toBeDefined();
+  });
+
+  it("punctuation anchor triggers warning", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Refer to sample_term_name in Section 4.");
+    const engine = new RedlineEngine(doc, "Reviewer TS");
+
+    const stats = (engine as any).process_batch([
+      { type: "modify", target_text: "sample_term_name", new_text: "validated_term_name" }
+    ]);
+
+    const report = stats.edits[0];
+    expect(report.warning).not.toBeNull();
+    expect(report.warning.toLowerCase()).toContain("punctuation");
+    expect(report.warning).toContain("sample_term_name");
+  });
+
+  it("dry_run does not mutate and reports safely", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Baseline text.");
+    const engine = new RedlineEngine(doc, "Reviewer TS");
+
+    // 1. Valid Dry Run
+    const stats = (engine as any).process_batch([
+      { type: "modify", target_text: "Baseline", new_text: "Modified Preview" }
+    ], true);
+
+    expect(stats.edits_applied).toBe(1);
+    expect(stats.edits[0].status).toBe("applied");
+    expect(stats.edits[0].clean_text).toContain("Modified Preview");
+
+    // Verify original document remains pristine
+    const buf = await doc.save();
+    const cleanText = await extractTextFromBuffer(buf, true);
+    expect(cleanText).not.toContain("Modified Preview");
+    expect(cleanText).toContain("Baseline text");
+
+    // 2. Invalid Dry Run should not throw and instead report the failure safely
+    const statsInvalid = (engine as any).process_batch([
+      { type: "modify", target_text: "NON_EXISTENT", new_text: "fail" }
+    ], true);
+
+    expect(statsInvalid.edits_skipped).toBe(1);
+    expect(statsInvalid.edits[0].status).toBe("failed");
+    expect(statsInvalid.edits[0].error).not.toBeNull();
+    expect(statsInvalid.edits[0].error.toLowerCase()).toContain("not found");
+  });
+
+  it("preview self-consistency on underscore terms", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "ANCHOR_LINE governs the interpretation of this Agreement.");
+    const engine = new RedlineEngine(doc, "Reviewer TS");
+
+    const stats = (engine as any).process_batch([
+      {
+        type: "modify",
+        target_text: "ANCHOR_LINE governs the interpretation of this Agreement.",
+        new_text: "NEW_PARA inserted before.\n\nANCHOR_LINE governs the interpretation of this Agreement.",
+      }
+    ]);
+
+    const buf = await doc.save();
+    const cleanDocText = await extractTextFromBuffer(buf, true);
+
+    const report = stats.edits[0];
+
+    expect(report.clean_text).not.toBeNull();
+    const cleanPreview = report.clean_text.replace(/^\.+|\.+$/g, "");
+    expect(cleanDocText).toContain(cleanPreview);
+  });
+
+  it("preview does not contain duplicate garbling", async () => {
+     const doc = await createTestDocument();
+     
+     addParagraph(doc, "Payment Terms");
+ 
+     const xmlDoc = doc.element.ownerDocument!;
+     const p2 = xmlDoc.createElement("w:p");
+     const del = xmlDoc.createElement("w:del");
+     del.setAttribute("w:id", "900");
+     del.setAttribute("w:author", "Reviewer");
+     del.setAttribute("w:date", "2026-06-01T00:00:00Z");
+     const r = xmlDoc.createElement("w:r");
+     const t = xmlDoc.createElement("w:delText");
+     t.setAttribute("xml:space", "preserve");
+     t.textContent = "DUP_PHRASE shall be paid within thirty days of invoice.";
+     r.appendChild(t);
+     del.appendChild(r);
+     p2.appendChild(del);
+    const firstP = doc.element.getElementsByTagName("w:p")[0];
+    firstP.parentNode!.appendChild(p2);
+ 
+     addParagraph(doc, "DUP_PHRASE shall be paid within thirty days of invoice.");
+     addParagraph(doc, "Late payments accrue interest at the statutory rate.");
+ 
+     const engine = new RedlineEngine(doc, "Reviewer TS");
+     const stats = (engine as any).process_batch([
+       {
+         type: "modify",
+         target_text: "DUP_PHRASE shall be paid within thirty days of invoice.",
+         new_text: "DUP_PHRASE shall be paid within sixty days of invoice.",
+       }
+     ]);
+
+    const buf = await doc.save();
+    const cleanDocText = await extractTextFromBuffer(buf, true);
+    
+    const report = stats.edits[0];
+    expect(report.clean_text).not.toBeNull();
+    const cleanPreview = report.clean_text.replace(/^\.+|\.+$/g, "");
+    expect(cleanDocText).toContain(cleanPreview);
+   });
+ });