@poe-platform/safe-bash 0.1.813 → 0.1.815

package/dist/safe-bash/command-chunks/{chunk-4Y34ZG4T.js → chunk-KUOCGGEU.js}

@@ -11,7 +11,7 @@ import {
 import {
   SnapshotCleanupError,
   createSnapshotEngine
-} from "./chunk-WYBCSJFG.js";
+} from "./chunk-FWCUEZ3K.js";
 import {
   SnapshotReferenceError
 } from "./chunk-WR4AO2LL.js";
@@ -31,6 +31,9 @@ import {
 import {
   parsePlaywrightSessionConfiguration
 } from "./chunk-DMOWQSKN.js";
+import {
+  formatPlaywrightHelp
+} from "./chunk-IRSV37JN.js";
 import {
   updatePlaywrightHighlight
 } from "./chunk-J5AYTMPX.js";
@@ -48,16 +51,13 @@ import {
 import {
   generatedPlaywrightLocator
 } from "./chunk-XXPRSZ6H.js";
-import {
-  formatPlaywrightHelp
-} from "./chunk-IRSV37JN.js";
 import {
   PlaywrightCheckpointError,
   PlaywrightStorageReadError
 } from "./chunk-YTYMDDBB.js";
 import {
   registerPlaywrightAbilities
-} from "./chunk-K5COUQAQ.js";
+} from "./chunk-3VGQTLO6.js";
 import {
   flushPlaywrightTrace,
   preparePlaywrightTraceRelease
@@ -71,12 +71,6 @@ import {
   observePlaywrightModals,
   onPlaywrightModal
 } from "./chunk-EBLCDQHV.js";
-import {
-  executePlaywrightAbility
-} from "./chunk-2KMNVJB7.js";
-import {
-  createPlaywrightCommandBudget
-} from "./chunk-GYGORRXA.js";
 import {
   flushPlaywrightConsole,
   getPlaywrightMainFrameNavigation,
@@ -99,6 +93,12 @@ import {
   playwrightLocatorSelector,
   setPlaywrightTestIdAttribute
 } from "./chunk-SSIG3FO3.js";
+import {
+  executePlaywrightAbility
+} from "./chunk-2KMNVJB7.js";
+import {
+  createPlaywrightCommandBudget
+} from "./chunk-GYGORRXA.js";
 import {
   PlaywrightResourceLimitError,
   PlaywrightSnapshotLimitError,

package/dist/safe-bash/command-chunks/{chunk-ML5R5JML.js → chunk-KY4LCHUF.js}

@@ -1,6 +1,6 @@
 import {
   UnsupportedEditError
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 
 // packages/safe-bash-docx-engine/src/table-rows.ts
 var w15 = "http://schemas.microsoft.com/office/word/2012/wordml";

package/dist/safe-bash/command-chunks/{chunk-KBUBSMCQ.js → chunk-LDW3RF7Y.js}

@@ -1,41 +1,41 @@
 import {
   remapCopiedXml
-} from "./chunk-QM2HZJSJ.js";
+} from "./chunk-F762XDNG.js";
 import {
   prepareCommentImport
-} from "./chunk-C5QDEB3I.js";
+} from "./chunk-6LPSKLLD.js";
 import {
   writePackageArchive
-} from "./chunk-HKOMXGJS.js";
+} from "./chunk-KBAQHE5Y.js";
 import {
   diagramContentTypes,
   diagramRelationshipKinds
-} from "./chunk-O675URF4.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   readPackage
-} from "./chunk-PVGZMLC6.js";
+} from "./chunk-IWHNRYER.js";
 import {
   readBinary
-} from "./chunk-LD7BONZY.js";
+} from "./chunk-NFII726L.js";
 import {
   validatePresentation
-} from "./chunk-GVWVRPG6.js";
+} from "./chunk-3GRMU7TM.js";
 import {
   parseXmlPart
-} from "./chunk-7PRL6RJ6.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   parseContentTypes
-} from "./chunk-VQOINPVF.js";
+} from "./chunk-ZQM37BGE.js";
 import {
   readRelationshipGraph
-} from "./chunk-TODWFDYB.js";
+} from "./chunk-LNTEV56A.js";
 import {
   asciiKey,
   relativePartReference
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/slide-import.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-U27XPNLP.js → chunk-LEO4VRIN.js}

@@ -1,7 +1,7 @@
 import {
   bareAutolink,
   filterGfmHtml
-} from "./chunk-IK6K2HCG.js";
+} from "./chunk-JWORWL72.js";
 import {
   unicodePunctuation,
   unicodeWhitespace
@@ -18,7 +18,7 @@ import {
   readLabel,
   readTitle,
   whitespace
-} from "./chunk-7ZWACKCG.js";
+} from "./chunk-T6OXG7QQ.js";
 
 // packages/safe-bash-markdown-engine/src/commonmark-inlines.ts
 function attr() {

package/dist/safe-bash/command-chunks/{chunk-GZ3VIWNN.js → chunk-LKGTH2Q7.js}

@@ -1,20 +1,20 @@
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   pathContains,
   tableGridCount
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DZH54L3F.js";
 import {
   tableRows
-} from "./chunk-ML5R5JML.js";
+} from "./chunk-KY4LCHUF.js";
 import {
   UnsupportedEditError
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   MarkupCompatibility,
   documentCompatibilityProfile

package/dist/safe-bash/command-chunks/{chunk-TODWFDYB.js → chunk-LNTEV56A.js}

@@ -4,11 +4,11 @@ import {
   partName,
   relativePartReference,
   resolvePartReference
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError,
   resolveOfficeResources
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/relationship-owner.ts
 function relationshipOwner(name) {

package/dist/safe-bash/command-chunks/{chunk-DVGXLBUW.js → chunk-LZ2JFMKT.js}

@@ -4,27 +4,27 @@ import {
   openControlInventory,
   prepareControlPlaceholder,
   prepareControlValue
-} from "./chunk-SLQWQKXP.js";
+} from "./chunk-WWHMI4S3.js";
 import {
   assertOutsideFields,
   parseFields
-} from "./chunk-ATI464W3.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-AG2SNMP5.js";
 import {
   characterizeRasterHeader
-} from "./chunk-4Y6O2K35.js";
+} from "./chunk-GLAF45M7.js";
 import {
   pathContains
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DZH54L3F.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   tableRows
-} from "./chunk-ML5R5JML.js";
+} from "./chunk-KY4LCHUF.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
@@ -35,7 +35,7 @@ import {
   assertOutsideRevisionRanges,
   containsRevision,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   storedIntegerIdentity,
   trimXmlWhitespace

package/dist/safe-bash/command-chunks/{chunk-6D2BMAF4.js → chunk-MEM2ZPMI.js}

@@ -1,7 +1,7 @@
 import {
   assertOutsideFields,
   parseFields
-} from "./chunk-ATI464W3.js";
+} from "./chunk-AG2SNMP5.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
@@ -14,7 +14,7 @@ import {
   revisionInfo,
   splitNativeTextRunXml,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   normalizePropertyDate,
   parseStoredDateTime,

package/dist/safe-bash/command-chunks/{chunk-GNXTMSYN.js → chunk-MGMTRGKM.js}

@@ -1,17 +1,17 @@
 import {
   readImages,
   validateImageSelectionOptions
-} from "./chunk-57DDYKE5.js";
+} from "./chunk-GYM5ICK4.js";
 import {
   readPackage
-} from "./chunk-PVGZMLC6.js";
+} from "./chunk-IWHNRYER.js";
 import {
   readBinary
-} from "./chunk-LD7BONZY.js";
+} from "./chunk-NFII726L.js";
 import {
   OfficeError,
   resolveOfficeResources
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/image-extraction.ts
 var extensions = /* @__PURE__ */ new Map([

package/dist/safe-bash/command-chunks/{chunk-B3NLITWP.js → chunk-MKK6FM5H.js}

@@ -1,30 +1,30 @@
 import {
   chartDefinitionParts,
   decodeChartContent
-} from "./chunk-F3GP3EXE.js";
+} from "./chunk-RGDOYWOD.js";
 import {
   collectDiagramObservations,
   diagramPartRoles
-} from "./chunk-3ZDANXIC.js";
+} from "./chunk-HELAVGZH.js";
 import {
   DocumentLocations,
   docxLocationBudgets
-} from "./chunk-UZL7G57V.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   embeddedFontContentTypes,
   fontResourceRole,
   readFontResources
-} from "./chunk-6NATRKUJ.js";
+} from "./chunk-JW6WVNTM.js";
 import {
   LocationIndex
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
 import {
   activeControlLocks,
   activeSettingsProtection
 } from "./chunk-TBAH4XGI.js";
 import {
   validateDocumentArchive
-} from "./chunk-JQPNA77Y.js";
+} from "./chunk-NHNZYWPW.js";
 import {
   documentPartRole,
   signatureContentTypes,
@@ -35,7 +35,7 @@ import {
 } from "./chunk-5BUL25DF.js";
 import {
   revisionInfo
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   readPropertyParts,
   storedBooleanValue

package/dist/safe-bash/command-chunks/{chunk-BK7ISUJL.js → chunk-MKOIPOXX.js}

@@ -3,13 +3,13 @@ import {
   child,
   invalid,
   loadShared
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   SelectionError
-} from "./chunk-O675URF4.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/transitions.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/chunk-MLOYUXUV.js

@@ -0,0 +1,244 @@
+import {
+  htmlSpace
+} from "./chunk-DFI7QF3M.js";
+
+// packages/safe-bash-command-html-to-markdown/dist/chunk-GRPJ3TNF.js
+var empty = { left: 0, right: 0, data: 0, bytes: 0, length: 0, height: 0, points: 0 };
+var TextStore = class {
+  constructor(storage, cooperate) {
+    this.storage = storage;
+    this.cooperate = cooperate;
+  }
+  storage;
+  cooperate;
+  encoder = new TextEncoder();
+  decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+  async info(root) {
+    if (!root) return empty;
+    const bytes = await this.storage.read(root, 56);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return {
+      left: view.getFloat64(0, true),
+      right: view.getFloat64(8, true),
+      data: view.getFloat64(16, true),
+      bytes: view.getFloat64(24, true),
+      length: view.getFloat64(32, true),
+      height: view.getFloat64(40, true),
+      points: view.getFloat64(48, true)
+    };
+  }
+  node(node) {
+    if (!Number.isSafeInteger(node.length) || !Number.isSafeInteger(node.bytes)) throw new RangeError("HTML text size overflow");
+    const bytes = new Uint8Array(56), view = new DataView(bytes.buffer);
+    for (const [index, value] of [node.left, node.right, node.data, node.bytes, node.length, node.height, node.points].entries()) view.setFloat64(index * 8, value, true);
+    return this.storage.append(bytes);
+  }
+  async branch(left, right) {
+    if (!left || !right) return left || right;
+    const a = await this.info(left), b = await this.info(right);
+    return this.node({ left, right, data: 0, bytes: a.bytes + b.bytes, length: a.length + b.length, height: Math.max(a.height, b.height) + 1, points: a.points + b.points });
+  }
+  /** Persistent AVL join shares operands rather than copying their text. */
+  async concat(left, right) {
+    if (!left || !right) return left || right;
+    const a = await this.info(left), b = await this.info(right);
+    if (a.height > b.height + 1) return this.balance(a.left, await this.concat(a.right, right));
+    if (b.height > a.height + 1) return this.balance(await this.concat(left, b.left), b.right);
+    return this.branch(left, right);
+  }
+  async balance(left, right) {
+    const a = await this.info(left), b = await this.info(right);
+    if (a.height > b.height + 1) {
+      const outer = await this.info(a.left), inner = await this.info(a.right);
+      if (outer.height >= inner.height) return this.branch(a.left, await this.branch(a.right, right));
+      return this.branch(await this.branch(a.left, inner.left), await this.branch(inner.right, right));
+    }
+    if (b.height > a.height + 1) {
+      const inner = await this.info(b.left), outer = await this.info(b.right);
+      if (outer.height >= inner.height) return this.branch(await this.branch(left, b.left), b.right);
+      return this.branch(await this.branch(left, inner.left), await this.branch(inner.right, b.right));
+    }
+    return this.branch(left, right);
+  }
+  async from(text) {
+    let root = 0;
+    for (let offset = 0; offset < text.length; ) {
+      let end = Math.min(offset + 2048, text.length);
+      const last = text.charCodeAt(end - 1);
+      if (end < text.length && last >= 55296 && last <= 56319) end--;
+      const chunk = text.slice(offset, end), bytes = this.encoder.encode(chunk);
+      await this.cooperate?.(chunk.length);
+      const data = await this.storage.append(bytes);
+      root = await this.concat(root, await this.node({ left: 0, right: 0, data, bytes: bytes.length, length: chunk.length, height: 1, points: Array.from(chunk).length }));
+      offset = end;
+    }
+    return root;
+  }
+  async *chunks(root, reverse = false) {
+    const pending = root ? [root] : [];
+    while (pending.length) {
+      const node = await this.info(pending.pop());
+      if (node.data) {
+        await this.cooperate?.(node.length);
+        yield this.decoder.decode(await this.storage.read(node.data, node.bytes));
+      } else if (reverse) pending.push(node.left, node.right);
+      else pending.push(node.right, node.left);
+    }
+  }
+  async *characters(root) {
+    for await (const chunk of this.chunks(root)) yield* chunk;
+  }
+  async at(root, index) {
+    const original = await this.info(root);
+    if (index < 0) index += original.length;
+    if (index < 0 || index >= original.length) return void 0;
+    while (root) {
+      const node = await this.info(root);
+      if (node.data) return this.decoder.decode(await this.storage.read(node.data, node.bytes))[index];
+      const left = await this.info(node.left);
+      if (index < left.length) root = node.left;
+      else {
+        index -= left.length;
+        root = node.right;
+      }
+    }
+    return void 0;
+  }
+  /** Locate a Unicode scalar by rank without materializing preceding text. */
+  async pointOffset(root, index) {
+    const original = await this.info(root);
+    if (!Number.isSafeInteger(index) || index < 0 || index > original.points) throw new RangeError("Invalid scalar offset");
+    let offset = 0;
+    while (root) {
+      const node = await this.info(root);
+      if (index === node.points) return offset + node.length;
+      if (node.data) {
+        for (const character of this.decoder.decode(await this.storage.read(node.data, node.bytes))) {
+          if (index-- === 0) break;
+          offset += character.length;
+        }
+        return offset;
+      }
+      const left = await this.info(node.left);
+      if (index < left.points) root = node.left;
+      else {
+        offset += left.length;
+        index -= left.points;
+        root = node.right;
+      }
+    }
+    return offset;
+  }
+  async slice(root, start, end = Number.MAX_SAFE_INTEGER) {
+    const node = await this.info(root);
+    start = Math.max(0, Math.min(start, node.length));
+    end = Math.max(start, Math.min(end, node.length));
+    if (start === end) return 0;
+    if (start === 0 && end === node.length) return root;
+    if (node.data) return this.from(this.decoder.decode(await this.storage.read(node.data, node.bytes)).slice(start, end));
+    const left = await this.info(node.left);
+    return this.concat(await this.slice(node.left, start, end), await this.slice(node.right, Math.max(0, start - left.length), Math.max(0, end - left.length)));
+  }
+  async repeat(root, count) {
+    if (!Number.isSafeInteger(count) || count < 0) throw new RangeError("Invalid HTML text repetition");
+    let result = 0;
+    while (count > 0) {
+      if (count % 2) result = await this.concat(result, root);
+      count = Math.floor(count / 2);
+      if (count) root = await this.concat(root, root);
+    }
+    return result;
+  }
+  async trim(root) {
+    let first = 0, last = (await this.info(root)).length;
+    outer: for await (const chunk of this.chunks(root)) for (const character of chunk) {
+      if (!htmlSpace(character)) break outer;
+      first++;
+    }
+    if (first === last) return 0;
+    outer: for await (const chunk of this.chunks(root, true)) for (let index = chunk.length - 1; index >= 0; index--) {
+      if (!htmlSpace(chunk[index])) break outer;
+      last--;
+    }
+    return this.slice(root, first, last);
+  }
+  async normalize(root, mode) {
+    const result = this.builder();
+    let space = false, carriage = false;
+    for await (const chunk of this.chunks(root)) {
+      let output = "";
+      for (const character of chunk) {
+        if (mode === "lines" && carriage && character === "\n") {
+          carriage = false;
+          continue;
+        }
+        carriage = false;
+        if (mode === "space" && htmlSpace(character)) {
+          if (!space) output += " ";
+          space = true;
+        } else {
+          space = false;
+          if (mode === "lines" && character === "\r") {
+            output += "\n";
+            carriage = true;
+          } else output += mode === "inline" && character === "\n" ? " " : character;
+        }
+      }
+      await result.write(output);
+    }
+    return result.finish();
+  }
+  async includes(root, needle) {
+    if (!needle) return true;
+    let tail = "";
+    for await (const chunk of this.chunks(root)) {
+      const text = tail + chunk;
+      if (text.includes(needle)) return true;
+      tail = text.slice(-Math.max(0, needle.length - 1));
+      if (needle.length === 1) tail = "";
+    }
+    return false;
+  }
+  async write(root, sink) {
+    for await (const chunk of this.chunks(root)) await sink.write(this.encoder.encode(chunk));
+  }
+  builder() {
+    return new TextBuilder(this);
+  }
+};
+var TextBuilder = class {
+  constructor(text) {
+    this.text = text;
+  }
+  text;
+  root = 0;
+  pending = "";
+  async write(value) {
+    for (let offset = 0; offset < value.length; ) {
+      const count = Math.min(2048 - this.pending.length, value.length - offset);
+      this.pending += value.slice(offset, offset + count);
+      offset += count;
+      if (this.pending.length === 2048) {
+        const last = this.pending.charCodeAt(2047), keep = last >= 55296 && last <= 56319;
+        this.root = await this.text.concat(this.root, await this.text.from(keep ? this.pending.slice(0, -1) : this.pending));
+        this.pending = keep ? this.pending.at(-1) : "";
+      }
+    }
+  }
+  async append(root) {
+    if (!root) return;
+    this.root = await this.text.concat(await this.finish(), root);
+  }
+  async finish() {
+    if (this.pending) {
+      this.root = await this.text.concat(this.root, await this.text.from(this.pending));
+      this.pending = "";
+    }
+    return this.root;
+  }
+};
+
+export {
+  TextStore,
+  TextBuilder
+};

package/dist/safe-bash/command-chunks/{chunk-CBNKHBLD.js → chunk-MNK3DDH6.js}

@@ -4,10 +4,10 @@ import {
 import {
   SourceError,
   validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-DZH54L3F.js";
 import {
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   PublicationError,
   asPermissionError

package/dist/safe-bash/command-chunks/{chunk-JVGUVHWI.js → chunk-MPXMRTMY.js}

@@ -1,38 +1,38 @@
 import {
   noteAttribute,
   openNotes
-} from "./chunk-7ZE3VIAN.js";
+} from "./chunk-IB5QP4LF.js";
 import {
   assertOutsideFields,
   parseFields
-} from "./chunk-ATI464W3.js";
+} from "./chunk-AG2SNMP5.js";
 import {
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   paragraphTextRun,
   replaceParagraphContent
-} from "./chunk-CU4DLVME.js";
+} from "./chunk-BLIFGBIO.js";
 import {
   findRelationshipPart
 } from "./chunk-UIX3CASN.js";
 import {
   LocationIndex
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DZH54L3F.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   DocumentXmlEditor,
   UnsupportedEditError,
   activeXmlChildren,
   removeNoteBodyXml,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   compatibilityContainers
 } from "./chunk-JWO7BP4K.js";

package/dist/safe-bash/command-chunks/{chunk-EJTNVXWF.js → chunk-MVLVIMJ6.js}

@@ -3,25 +3,25 @@ import {
   createShapeXml,
   readShape,
   validateShapeOptions
-} from "./chunk-HVW53ARH.js";
+} from "./chunk-TKCUGMRZ.js";
 import {
   ShapeIdAllocator
-} from "./chunk-BBAB7LC4.js";
+} from "./chunk-XMTR7QGL.js";
 import {
   readShapeGeometry
-} from "./chunk-3Y4XZB24.js";
+} from "./chunk-RTNI47C5.js";
 import {
   attr,
   child,
   loadShared,
   required
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   SelectionError
-} from "./chunk-O675URF4.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/shape-operations.ts
 function validateSelection(options, action) {