tasmota-esp-web-tools 9.0.2 → 10.0.0

package/js/modules/wasm/littlefs/littlefs.js

@@ -0,0 +1,505 @@
+export default (() => {
+  var _scriptName = globalThis.document?.currentScript?.src;
+  return async function (moduleArg = {}) {
+    var moduleRtn;
+    var Module = moduleArg;
+    var ENVIRONMENT_IS_WEB = !!globalThis.window;
+    var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+    var ENVIRONMENT_IS_NODE =
+      globalThis.process?.versions?.node &&
+      globalThis.process?.type != "renderer";
+    var arguments_ = [];
+    var thisProgram = "./this.program";
+    var quit_ = (status, toThrow) => {
+      throw toThrow;
+    };
+    if (ENVIRONMENT_IS_WORKER) {
+      _scriptName = self.location.href;
+    }
+    var scriptDirectory = "";
+    function locateFile(path) {
+      if (Module["locateFile"]) {
+        return Module["locateFile"](path, scriptDirectory);
+      }
+      return scriptDirectory + path;
+    }
+    var readAsync, readBinary;
+    if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+      try {
+        scriptDirectory = new URL(".", _scriptName).href;
+      } catch {}
+      {
+        if (ENVIRONMENT_IS_WORKER) {
+          readBinary = (url) => {
+            var xhr = new XMLHttpRequest();
+            xhr.open("GET", url, false);
+            xhr.responseType = "arraybuffer";
+            xhr.send(null);
+            return new Uint8Array(xhr.response);
+          };
+        }
+        readAsync = async (url) => {
+          var response = await fetch(url, { credentials: "same-origin" });
+          if (response.ok) {
+            return response.arrayBuffer();
+          }
+          throw new Error(response.status + " : " + response.url);
+        };
+      }
+    } else {
+    }
+    var out = console.log.bind(console);
+    var err = console.error.bind(console);
+    var wasmBinary;
+    var ABORT = false;
+    var EXITSTATUS;
+    var readyPromiseResolve, readyPromiseReject;
+    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+    var HEAP64, HEAPU64;
+    var runtimeInitialized = false;
+    function updateMemoryViews() {
+      var b = wasmMemory.buffer;
+      HEAP8 = new Int8Array(b);
+      HEAP16 = new Int16Array(b);
+      Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+      HEAPU16 = new Uint16Array(b);
+      Module["HEAP32"] = HEAP32 = new Int32Array(b);
+      Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+      HEAPF32 = new Float32Array(b);
+      HEAPF64 = new Float64Array(b);
+      HEAP64 = new BigInt64Array(b);
+      HEAPU64 = new BigUint64Array(b);
+    }
+    function preRun() {
+      if (Module["preRun"]) {
+        if (typeof Module["preRun"] == "function")
+          Module["preRun"] = [Module["preRun"]];
+        while (Module["preRun"].length) {
+          addOnPreRun(Module["preRun"].shift());
+        }
+      }
+      callRuntimeCallbacks(onPreRuns);
+    }
+    function initRuntime() {
+      runtimeInitialized = true;
+      wasmExports["i"]();
+    }
+    function postRun() {
+      if (Module["postRun"]) {
+        if (typeof Module["postRun"] == "function")
+          Module["postRun"] = [Module["postRun"]];
+        while (Module["postRun"].length) {
+          addOnPostRun(Module["postRun"].shift());
+        }
+      }
+      callRuntimeCallbacks(onPostRuns);
+    }
+    function abort(what) {
+      Module["onAbort"]?.(what);
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject?.(e);
+      throw e;
+    }
+    var wasmBinaryFile;
+    function findWasmBinary() {
+      return locateFile("littlefs.wasm");
+    }
+    function getBinarySync(file) {
+      if (file == wasmBinaryFile && wasmBinary) {
+        return new Uint8Array(wasmBinary);
+      }
+      if (readBinary) {
+        return readBinary(file);
+      }
+      throw "both async and sync fetching of the wasm failed";
+    }
+    async function getWasmBinary(binaryFile) {
+      if (!wasmBinary) {
+        try {
+          var response = await readAsync(binaryFile);
+          return new Uint8Array(response);
+        } catch {}
+      }
+      return getBinarySync(binaryFile);
+    }
+    async function instantiateArrayBuffer(binaryFile, imports) {
+      try {
+        var binary = await getWasmBinary(binaryFile);
+        var instance = await WebAssembly.instantiate(binary, imports);
+        return instance;
+      } catch (reason) {
+        err(`failed to asynchronously prepare wasm: ${reason}`);
+        abort(reason);
+      }
+    }
+    async function instantiateAsync(binary, binaryFile, imports) {
+      if (!binary) {
+        try {
+          var response = fetch(binaryFile, { credentials: "same-origin" });
+          var instantiationResult = await WebAssembly.instantiateStreaming(
+            response,
+            imports,
+          );
+          return instantiationResult;
+        } catch (reason) {
+          err(`wasm streaming compile failed: ${reason}`);
+          err("falling back to ArrayBuffer instantiation");
+        }
+      }
+      return instantiateArrayBuffer(binaryFile, imports);
+    }
+    function getWasmImports() {
+      var imports = { a: wasmImports };
+      return imports;
+    }
+    async function createWasm() {
+      function receiveInstance(instance, module) {
+        wasmExports = instance.exports;
+        assignWasmExports(wasmExports);
+        updateMemoryViews();
+        return wasmExports;
+      }
+      function receiveInstantiationResult(result) {
+        return receiveInstance(result["instance"]);
+      }
+      var info = getWasmImports();
+      if (Module["instantiateWasm"]) {
+        return new Promise((resolve, reject) => {
+          Module["instantiateWasm"](info, (inst, mod) => {
+            resolve(receiveInstance(inst, mod));
+          });
+        });
+      }
+      wasmBinaryFile ??= findWasmBinary();
+      var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+      var exports = receiveInstantiationResult(result);
+      return exports;
+    }
+    class ExitStatus {
+      name = "ExitStatus";
+      constructor(status) {
+        this.message = `Program terminated with exit(${status})`;
+        this.status = status;
+      }
+    }
+    var callRuntimeCallbacks = (callbacks) => {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module);
+      }
+    };
+    var onPostRuns = [];
+    var addOnPostRun = (cb) => onPostRuns.push(cb);
+    var onPreRuns = [];
+    var addOnPreRun = (cb) => onPreRuns.push(cb);
+    var noExitRuntime = true;
+    var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
+    var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+      var maxIdx = idx + maxBytesToRead;
+      if (ignoreNul) return maxIdx;
+      while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
+      return idx;
+    };
+    var UTF8ArrayToString = (
+      heapOrArray,
+      idx = 0,
+      maxBytesToRead,
+      ignoreNul,
+    ) => {
+      var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+      }
+      var str = "";
+      while (idx < endPtr) {
+        var u0 = heapOrArray[idx++];
+        if (!(u0 & 128)) {
+          str += String.fromCharCode(u0);
+          continue;
+        }
+        var u1 = heapOrArray[idx++] & 63;
+        if ((u0 & 224) == 192) {
+          str += String.fromCharCode(((u0 & 31) << 6) | u1);
+          continue;
+        }
+        var u2 = heapOrArray[idx++] & 63;
+        if ((u0 & 240) == 224) {
+          u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+        } else {
+          u0 =
+            ((u0 & 7) << 18) |
+            (u1 << 12) |
+            (u2 << 6) |
+            (heapOrArray[idx++] & 63);
+        }
+        if (u0 < 65536) {
+          str += String.fromCharCode(u0);
+        } else {
+          var ch = u0 - 65536;
+          str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+        }
+      }
+      return str;
+    };
+    var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) =>
+      ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
+    var ___assert_fail = (condition, filename, line, func) =>
+      abort(
+        `Assertion failed: ${UTF8ToString(condition)}, at: ` +
+          [
+            filename ? UTF8ToString(filename) : "unknown filename",
+            line,
+            func ? UTF8ToString(func) : "unknown function",
+          ],
+      );
+    var __abort_js = () => abort("");
+    var runtimeKeepaliveCounter = 0;
+    var __emscripten_runtime_keepalive_clear = () => {
+      noExitRuntime = false;
+      runtimeKeepaliveCounter = 0;
+    };
+    var timers = {};
+    var handleException = (e) => {
+      if (e instanceof ExitStatus || e == "unwind") {
+        return EXITSTATUS;
+      }
+      quit_(1, e);
+    };
+    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+    var _proc_exit = (code) => {
+      EXITSTATUS = code;
+      if (!keepRuntimeAlive()) {
+        Module["onExit"]?.(code);
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    };
+    var exitJS = (status, implicit) => {
+      EXITSTATUS = status;
+      _proc_exit(status);
+    };
+    var _exit = exitJS;
+    var maybeExit = () => {
+      if (!keepRuntimeAlive()) {
+        try {
+          _exit(EXITSTATUS);
+        } catch (e) {
+          handleException(e);
+        }
+      }
+    };
+    var callUserCallback = (func) => {
+      if (ABORT) {
+        return;
+      }
+      try {
+        func();
+        maybeExit();
+      } catch (e) {
+        handleException(e);
+      }
+    };
+    var _emscripten_get_now = () => performance.now();
+    var __setitimer_js = (which, timeout_ms) => {
+      if (timers[which]) {
+        clearTimeout(timers[which].id);
+        delete timers[which];
+      }
+      if (!timeout_ms) return 0;
+      var id = setTimeout(() => {
+        delete timers[which];
+        callUserCallback(() =>
+          __emscripten_timeout(which, _emscripten_get_now()),
+        );
+      }, timeout_ms);
+      timers[which] = { id, timeout_ms };
+      return 0;
+    };
+    var getHeapMax = () => 67108864;
+    var alignMemory = (size, alignment) =>
+      Math.ceil(size / alignment) * alignment;
+    var growMemory = (size) => {
+      var oldHeapSize = wasmMemory.buffer.byteLength;
+      var pages = ((size - oldHeapSize + 65535) / 65536) | 0;
+      try {
+        wasmMemory.grow(pages);
+        updateMemoryViews();
+        return 1;
+      } catch (e) {}
+    };
+    var _emscripten_resize_heap = (requestedSize) => {
+      var oldSize = HEAPU8.length;
+      requestedSize >>>= 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        return false;
+      }
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+        overGrownHeapSize = Math.min(
+          overGrownHeapSize,
+          requestedSize + 100663296,
+        );
+        var newSize = Math.min(
+          maxHeapSize,
+          alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536),
+        );
+        var replacement = growMemory(newSize);
+        if (replacement) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var printCharBuffers = [null, [], []];
+    var printChar = (stream, curr) => {
+      var buffer = printCharBuffers[stream];
+      if (curr === 0 || curr === 10) {
+        (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
+        buffer.length = 0;
+      } else {
+        buffer.push(curr);
+      }
+    };
+    var _fd_write = (fd, iov, iovcnt, pnum) => {
+      var num = 0;
+      for (var i = 0; i < iovcnt; i++) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[(iov + 4) >> 2];
+        iov += 8;
+        for (var j = 0; j < len; j++) {
+          printChar(fd, HEAPU8[ptr + j]);
+        }
+        num += len;
+      }
+      HEAPU32[pnum >> 2] = num;
+      return 0;
+    };
+    {
+      if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
+      if (Module["print"]) out = Module["print"];
+      if (Module["printErr"]) err = Module["printErr"];
+      if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+      if (Module["arguments"]) arguments_ = Module["arguments"];
+      if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+      if (Module["preInit"]) {
+        if (typeof Module["preInit"] == "function")
+          Module["preInit"] = [Module["preInit"]];
+        while (Module["preInit"].length > 0) {
+          Module["preInit"].shift()();
+        }
+      }
+    }
+    var _lfs_wasm_set_disk_version,
+      _lfs_wasm_get_disk_version,
+      _lfs_wasm_init,
+      _free,
+      _malloc,
+      _lfs_wasm_init_from_image,
+      _lfs_wasm_get_fs_info,
+      _lfs_wasm_mount,
+      _lfs_wasm_unmount,
+      _lfs_wasm_format,
+      _lfs_wasm_mkdir,
+      _lfs_wasm_remove,
+      _lfs_wasm_rename,
+      _lfs_wasm_stat,
+      _lfs_wasm_dir_open,
+      _lfs_wasm_dir_read,
+      _lfs_wasm_dir_close,
+      _lfs_wasm_write_file,
+      _lfs_wasm_read_file,
+      _lfs_wasm_file_size,
+      _lfs_wasm_get_image,
+      _lfs_wasm_get_image_size,
+      _lfs_wasm_fs_stat,
+      _lfs_wasm_cleanup,
+      __emscripten_timeout,
+      memory,
+      __indirect_function_table,
+      wasmMemory;
+    function assignWasmExports(wasmExports) {
+      _lfs_wasm_set_disk_version = Module["_lfs_wasm_set_disk_version"] =
+        wasmExports["j"];
+      _lfs_wasm_get_disk_version = Module["_lfs_wasm_get_disk_version"] =
+        wasmExports["k"];
+      _lfs_wasm_init = Module["_lfs_wasm_init"] = wasmExports["l"];
+      _free = Module["_free"] = wasmExports["m"];
+      _malloc = Module["_malloc"] = wasmExports["n"];
+      _lfs_wasm_init_from_image = Module["_lfs_wasm_init_from_image"] =
+        wasmExports["o"];
+      _lfs_wasm_get_fs_info = Module["_lfs_wasm_get_fs_info"] =
+        wasmExports["p"];
+      _lfs_wasm_mount = Module["_lfs_wasm_mount"] = wasmExports["q"];
+      _lfs_wasm_unmount = Module["_lfs_wasm_unmount"] = wasmExports["r"];
+      _lfs_wasm_format = Module["_lfs_wasm_format"] = wasmExports["s"];
+      _lfs_wasm_mkdir = Module["_lfs_wasm_mkdir"] = wasmExports["t"];
+      _lfs_wasm_remove = Module["_lfs_wasm_remove"] = wasmExports["u"];
+      _lfs_wasm_rename = Module["_lfs_wasm_rename"] = wasmExports["v"];
+      _lfs_wasm_stat = Module["_lfs_wasm_stat"] = wasmExports["w"];
+      _lfs_wasm_dir_open = Module["_lfs_wasm_dir_open"] = wasmExports["x"];
+      _lfs_wasm_dir_read = Module["_lfs_wasm_dir_read"] = wasmExports["y"];
+      _lfs_wasm_dir_close = Module["_lfs_wasm_dir_close"] = wasmExports["z"];
+      _lfs_wasm_write_file = Module["_lfs_wasm_write_file"] = wasmExports["A"];
+      _lfs_wasm_read_file = Module["_lfs_wasm_read_file"] = wasmExports["B"];
+      _lfs_wasm_file_size = Module["_lfs_wasm_file_size"] = wasmExports["C"];
+      _lfs_wasm_get_image = Module["_lfs_wasm_get_image"] = wasmExports["D"];
+      _lfs_wasm_get_image_size = Module["_lfs_wasm_get_image_size"] =
+        wasmExports["E"];
+      _lfs_wasm_fs_stat = Module["_lfs_wasm_fs_stat"] = wasmExports["F"];
+      _lfs_wasm_cleanup = Module["_lfs_wasm_cleanup"] = wasmExports["G"];
+      __emscripten_timeout = wasmExports["H"];
+      memory = wasmMemory = wasmExports["h"];
+      __indirect_function_table = wasmExports["__indirect_function_table"];
+    }
+    var wasmImports = {
+      a: ___assert_fail,
+      d: __abort_js,
+      c: __emscripten_runtime_keepalive_clear,
+      e: __setitimer_js,
+      f: _emscripten_resize_heap,
+      g: _fd_write,
+      b: _proc_exit,
+    };
+    function run() {
+      preRun();
+      function doRun() {
+        Module["calledRun"] = true;
+        if (ABORT) return;
+        initRuntime();
+        readyPromiseResolve?.(Module);
+        Module["onRuntimeInitialized"]?.();
+        postRun();
+      }
+      if (Module["setStatus"]) {
+        Module["setStatus"]("Running...");
+        setTimeout(() => {
+          setTimeout(() => Module["setStatus"](""), 1);
+          doRun();
+        }, 1);
+      } else {
+        doRun();
+      }
+    }
+    var wasmExports;
+    wasmExports = await createWasm();
+    run();
+    if (runtimeInitialized) {
+      moduleRtn = Module;
+    } else {
+      moduleRtn = new Promise((resolve, reject) => {
+        readyPromiseResolve = resolve;
+        readyPromiseReject = reject;
+      });
+    }
+    return moduleRtn;
+  };
+})();
+if (typeof exports === "object" && typeof module === "object") {
+  module.exports = createLittleFS;
+  module.exports.default = createLittleFS;
+} else if (typeof define === "function" && define["amd"])
+  define([], () => createLittleFS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tasmota-esp-web-tools",
-  "version": "9.0.2",
+  "version": "10.0.0",
   "description": "Web tools for ESP devices",
   "main": "dist/install-button.js",
   "repository": {
@@ -10,7 +10,8 @@
   "author": "ESPHome maintainers & Jason2866",
   "license": "Apache-2.0",
   "scripts": {
-    "prepublishOnly": "script/build"
+    "prepublishOnly": "script/build",
+    "develop": "script/develop"
   },
   "devDependencies": {
     "@babel/plugin-proposal-class-properties": "^7.18.6",

package/.devcontainer/Dockerfile

@@ -1,16 +0,0 @@
-# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.177.0/containers/typescript-node/.devcontainer/base.Dockerfile
-
-# [Choice] Node.js version: 16, 14, 12
-ARG VARIANT="20-buster"
-FROM mcr.microsoft.com/vscode/devcontainers/typescript-node:0-${VARIANT}
-
-# [Optional] Uncomment this section to install additional OS packages.
-# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-#     && apt-get -y install --no-install-recommends <your-package-list-here>
-
-# [Optional] Uncomment if you want to install an additional version of node using nvm
-# ARG EXTRA_NODE_VERSION=10
-# RUN su node -c "source /usr/local/share/nvm/nvm.sh && nvm install ${EXTRA_NODE_VERSION}"
-
-# [Optional] Uncomment if you want to install more global node packages
-# RUN su node -c "npm install -g <your-package-list -here>"

package/.devcontainer/devcontainer.json

@@ -1,21 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
-// https://github.com/microsoft/vscode-dev-containers/tree/v0.177.0/containers/typescript-node
-{
-  "name": "Node.js & TypeScript",
-  "build": {
-    "dockerfile": "Dockerfile",
-    // Update 'VARIANT' to pick a Node version: 12, 14, 16, 20
-    "args": {
-      "VARIANT": "20"
-    }
-  },
-
-  // Use 'forwardPorts' to make a list of ports inside the container available locally.
-  "forwardPorts": [5000],
-
-  // Use 'postCreateCommand' to run commands after the container is created.
-  "postCreateCommand": "npm install",
-
-  // Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-  "remoteUser": "node"
-}

package/.github/dependabot.yml

@@ -1,10 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: weekly
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "weekly"

package/.github/workflows/build_upload.yml

@@ -1,78 +0,0 @@
-name: Build and upload
-
-on:
-  push:
-  workflow_dispatch:
-
-# Allow one concurrent deployment
-concurrency:
-  group: environment-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      id-token: write  # required to use OIDC
-    steps:
-      - uses: actions/checkout@v6
-      - name: Remove old files and folders
-        run: |
-          rm -rf yarn.lock
-          rm -rf package-lock.json
-          rm -rf dist
-          rm -rf js/modules
-          mkdir js/modules
-      - name: install node v22
-        uses: actions/setup-node@v6
-        with:
-          node-version: 22
-          registry-url: 'https://registry.npmjs.org'
-      - name: Update npm to latest
-        run: npm install -g npm@latest
-      - name: Check npm version
-        run: npm --version
-      - name: Install NPM
-        run: npm install
-      - name: Prettier
-        run: npm exec -- prettier --write src
-      - name: Compile TypeScript
-        run: |
-          set -e
-          rm -rf dist
-          NODE_ENV=production npm exec -- tsc
-          NODE_ENV=production npm exec -- rollup -c
-      - name: Copy build artifact
-        run: |
-          cp dist/web/*.js js/modules/
-      - name: Commit Distribution Files
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: "Github Action: Updated dist files"
-      - name: Publish to NPM registry (OIDC Trusted Publishing)
-        uses: JS-DevTools/npm-publish@v4
-        with:
-          registry: https://registry.npmjs.org/
-          strategy: all
-      - name: Setup Pages
-        uses: actions/configure-pages@v5
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v4
-        with:
-          path: "."
-
-  deploy:
-    needs: build
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pages: write
-      id-token: write
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

package/.github/workflows/ci.yml

@@ -1,24 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: CI
-
-on:
-  push:
-    branches: [v815]
-  pull_request:
-    branches: [v815]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm install
-      - run: script/build
-      - run: npm exec -- prettier --check src

package/.prettierignore

@@ -1 +0,0 @@
-src/vendor