🆙 Add cms i using 🆙

Optimized Atomcms daily updated/node_modules/-/README.md

@@ -0,0 +1,7 @@
+# `-`
+
+> Created using https://github.com/parzh/create-package-typescript
+
+```
+npm i -
+```

Optimized Atomcms daily updated/node_modules/-/dist/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = null;

Optimized Atomcms daily updated/node_modules/-/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "-",
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "keywords": [],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node --require ts-node/register src",
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@types/node": "13.9.0",
+    "ts-node": "8.6.2",
+    "typescript": "3.8.3"
+  }
+}

Optimized Atomcms daily updated/node_modules/.bin/autoprefixer

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+let mode = process.argv[2]
+if (mode === '--info') {
+  process.stdout.write(require('../')().info() + '\n')
+} else if (mode === '--version') {
+  process.stdout.write(
+    'autoprefixer ' + require('../package.json').version + '\n'
+  )
+} else {
+  process.stdout.write(
+    'autoprefix\n' +
+      '\n' +
+      'Options:\n' +
+      '  --info    Show target browsers and used prefixes\n' +
+      '  --version Show version number\n' +
+      '  --help    Show help\n' +
+      '\n' +
+      'Usage:\n' +
+      '  autoprefixer --info\n'
+  )
+}

Optimized Atomcms daily updated/node_modules/.bin/blade-formatter

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const cli = require('../dist/cli-bundle');
+cli.default();

Optimized Atomcms daily updated/node_modules/.bin/browserslist

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+var fs = require('fs')
+var updateDb = require('update-browserslist-db')
+
+var browserslist = require('./')
+var pkg = require('./package.json')
+
+var args = process.argv.slice(2)
+
+var USAGE =
+  'Usage:\n' +
+  '  npx browserslist\n' +
+  '  npx browserslist "QUERIES"\n' +
+  '  npx browserslist --json "QUERIES"\n' +
+  '  npx browserslist --config="path/to/browserlist/file"\n' +
+  '  npx browserslist --coverage "QUERIES"\n' +
+  '  npx browserslist --coverage=US "QUERIES"\n' +
+  '  npx browserslist --coverage=US,RU,global "QUERIES"\n' +
+  '  npx browserslist --env="environment name defined in config"\n' +
+  '  npx browserslist --stats="path/to/browserlist/stats/file"\n' +
+  '  npx browserslist --mobile-to-desktop\n' +
+  '  npx browserslist --ignore-unknown-versions\n'
+
+function isArg(arg) {
+  return args.some(function (str) {
+    return str === arg || str.indexOf(arg + '=') === 0
+  })
+}
+
+function error(msg) {
+  process.stderr.write('browserslist: ' + msg + '\n')
+  process.exit(1)
+}
+
+if (isArg('--help') || isArg('-h')) {
+  process.stdout.write(pkg.description + '.\n\n' + USAGE + '\n')
+} else if (isArg('--version') || isArg('-v')) {
+  process.stdout.write('browserslist ' + pkg.version + '\n')
+} else if (isArg('--update-db')) {
+  /* c8 ignore next 8 */
+  process.stdout.write(
+    'The --update-db command is deprecated.\n' +
+      'Please use npx update-browserslist-db@latest instead.\n'
+  )
+  process.stdout.write('Browserslist DB update will still be made.\n')
+  updateDb(function (str) {
+    process.stdout.write(str)
+  })
+} else {
+  var mode = 'browsers'
+  var opts = {}
+  var queries
+  var areas
+
+  for (var i = 0; i < args.length; i++) {
+    if (args[i][0] !== '-') {
+      queries = args[i].replace(/^["']|["']$/g, '')
+      continue
+    }
+
+    var arg = args[i].split('=')
+    var name = arg[0]
+    var value = arg[1]
+
+    if (value) value = value.replace(/^["']|["']$/g, '')
+
+    if (name === '--config' || name === '-b') {
+      opts.config = value
+    } else if (name === '--env' || name === '-e') {
+      opts.env = value
+    } else if (name === '--stats' || name === '-s') {
+      opts.stats = value
+    } else if (name === '--coverage' || name === '-c') {
+      if (mode !== 'json') mode = 'coverage'
+      if (value) {
+        areas = value.split(',')
+      } else {
+        areas = ['global']
+      }
+    } else if (name === '--json') {
+      mode = 'json'
+    } else if (name === '--mobile-to-desktop') {
+      /* c8 ignore next */
+      opts.mobileToDesktop = true
+    } else if (name === '--ignore-unknown-versions') {
+      /* c8 ignore next */
+      opts.ignoreUnknownVersions = true
+    } else {
+      error('Unknown arguments ' + args[i] + '.\n\n' + USAGE)
+    }
+  }
+
+  var browsers
+  try {
+    browsers = browserslist(queries, opts)
+  } catch (e) {
+    if (e.name === 'BrowserslistError') {
+      error(e.message)
+    } /* c8 ignore start */ else {
+      throw e
+    } /* c8 ignore end */
+  }
+
+  var coverage
+  if (mode === 'browsers') {
+    browsers.forEach(function (browser) {
+      process.stdout.write(browser + '\n')
+    })
+  } else if (areas) {
+    coverage = areas.map(function (area) {
+      var stats
+      if (area !== 'global') {
+        stats = area
+      } else if (opts.stats) {
+        stats = JSON.parse(fs.readFileSync(opts.stats))
+      }
+      var result = browserslist.coverage(browsers, stats)
+      var round = Math.round(result * 100) / 100.0
+
+      return [area, round]
+    })
+
+    if (mode === 'coverage') {
+      var prefix = 'These browsers account for '
+      process.stdout.write(prefix)
+      coverage.forEach(function (data, index) {
+        var area = data[0]
+        var round = data[1]
+        var end = 'globally'
+        if (area && area !== 'global') {
+          end = 'in the ' + area.toUpperCase()
+        } else if (opts.stats) {
+          end = 'in custom statistics'
+        }
+
+        if (index !== 0) {
+          process.stdout.write(prefix.replace(/./g, ' '))
+        }
+
+        process.stdout.write(round + '% of all users ' + end + '\n')
+      })
+    }
+  }
+
+  if (mode === 'json') {
+    var data = { browsers: browsers }
+    if (coverage) {
+      data.coverage = coverage.reduce(function (object, j) {
+        object[j[0]] = j[1]
+        return object
+      }, {})
+    }
+    process.stdout.write(JSON.stringify(data, null, '  ') + '\n')
+  }
+}

Optimized Atomcms daily updated/node_modules/.bin/clean-orphaned-assets

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import { readFileSync, readdirSync, unlinkSync, existsSync } from 'fs'
+import { dirname } from 'path'
+
+/*
+ * Argv helpers.
+ */
+
+const argument = (name) => {
+    const index = process.argv.findIndex(argument => argument.startsWith(`--${name}=`))
+
+    return index === -1
+        ? undefined
+        : process.argv[index].substring(`--${name}=`.length)
+}
+
+const option = (name) => process.argv.includes(`--${name}`)
+
+/*
+ * Helpers.
+ */
+const info = option(`quiet`) ? (() => undefined) : console.log
+const error = option(`quiet`) ? (() => undefined) : console.error
+
+/*
+ * Clean.
+ */
+
+const main = () => {
+    const manifestPaths = argument(`manifest`) ? [argument(`manifest`)] : (option(`ssr`)
+        ? [`./bootstrap/ssr/ssr-manifest.json`, `./bootstrap/ssr/manifest.json`]
+        : [`./public/build/manifest.json`])
+
+    const foundManifestPath = manifestPaths.find(existsSync)
+
+    if (! foundManifestPath) {
+        error(`Unable to find manifest file.`)
+
+        process.exit(1)
+    }
+
+    info(`Reading manifest [${foundManifestPath}].`)
+
+    const manifest = JSON.parse(readFileSync(foundManifestPath).toString())
+
+    const manifestFiles = Object.keys(manifest)
+
+    const isSsr = Array.isArray(manifest[manifestFiles[0]])
+
+    isSsr
+        ? info(`SSR manifest found.`)
+        : info(`Non-SSR manifest found.`)
+
+    const manifestAssets = isSsr
+        ? manifestFiles.flatMap(key => manifest[key])
+        : manifestFiles.flatMap(key => [
+            ...manifest[key].css ?? [],
+            manifest[key].file,
+        ])
+
+    const assetsPath = argument('assets') ?? dirname(foundManifestPath)+'/assets'
+
+    info(`Verify assets in [${assetsPath}].`)
+
+    const existingAssets = readdirSync(assetsPath, { withFileTypes: true })
+
+    const orphanedAssets = existingAssets.filter(file => file.isFile())
+        .filter(file => manifestAssets.findIndex(asset => asset.endsWith(`/${file.name}`)) === -1)
+
+    if (orphanedAssets.length === 0) {
+        info(`No ophaned assets found.`)
+    } else {
+        orphanedAssets.length === 1
+            ? info(`[${orphanedAssets.length}] orphaned asset found.`)
+            : info(`[${orphanedAssets.length}] orphaned assets found.`)
+
+        orphanedAssets.forEach(asset => {
+            const path = `${assetsPath}/${asset.name}`
+
+            option(`dry-run`)
+                ? info(`Orphaned asset [${path}] would be removed.`)
+                : info(`Removing orphaned asset [${path}].`)
+
+            if (! option(`dry-run`)) {
+                unlinkSync(path)
+            }
+        })
+    }
+}
+
+main()

Optimized Atomcms daily updated/node_modules/.bin/css-beautify

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+var cli = require('../lib/cli'); cli.interpret();
+
+

Optimized Atomcms daily updated/node_modules/.bin/cssesc

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const cssesc = require('../cssesc.js');
+const strings = process.argv.splice(2);
+const stdin = process.stdin;
+const options = {};
+const log = console.log;
+
+const main = function() {
+	const option = strings[0];
+
+	if (/^(?:-h|--help|undefined)$/.test(option)) {
+		log(
+			'cssesc v%s - https://mths.be/cssesc',
+			cssesc.version
+		);
+		log([
+			'\nUsage:\n',
+			'\tcssesc [string]',
+			'\tcssesc [-i | --identifier] [string]',
+			'\tcssesc [-s | --single-quotes] [string]',
+			'\tcssesc [-d | --double-quotes] [string]',
+			'\tcssesc [-w | --wrap] [string]',
+			'\tcssesc [-e | --escape-everything] [string]',
+			'\tcssesc [-v | --version]',
+			'\tcssesc [-h | --help]',
+			'\nExamples:\n',
+			'\tcssesc \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+			'\tcssesc --identifier \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+			'\tcssesc --escape-everything \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+			'\tcssesc --double-quotes --wrap \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+			'\techo \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\' | cssesc'
+		].join('\n'));
+		return process.exit(1);
+	}
+
+	if (/^(?:-v|--version)$/.test(option)) {
+		log('v%s', cssesc.version);
+		return process.exit(1);
+	}
+
+	strings.forEach(function(string) {
+		// Process options
+		if (/^(?:-i|--identifier)$/.test(string)) {
+			options.isIdentifier = true;
+			return;
+		}
+		if (/^(?:-s|--single-quotes)$/.test(string)) {
+			options.quotes = 'single';
+			return;
+		}
+		if (/^(?:-d|--double-quotes)$/.test(string)) {
+			options.quotes = 'double';
+			return;
+		}
+		if (/^(?:-w|--wrap)$/.test(string)) {
+			options.wrap = true;
+			return;
+		}
+		if (/^(?:-e|--escape-everything)$/.test(string)) {
+			options.escapeEverything = true;
+			return;
+		}
+
+		// Process string(s)
+		let result;
+		try {
+			result = cssesc(string, options);
+			log(result);
+		} catch (exception) {
+			log(exception.message + '\n');
+			log('Error: failed to escape.');
+			log('If you think this is a bug in cssesc, please report it:');
+			log('https://github.com/mathiasbynens/cssesc/issues/new');
+			log(
+				'\nStack trace using cssesc@%s:\n',
+				cssesc.version
+			);
+			log(exception.stack);
+			return process.exit(1);
+		}
+	});
+	// Return with exit status 0 outside of the `forEach` loop, in case
+	// multiple strings were passed in.
+	return process.exit(0);
+
+};
+
+if (stdin.isTTY) {
+	// handle shell arguments
+	main();
+} else {
+	let timeout;
+	// Either the script is called from within a non-TTY context, or `stdin`
+	// content is being piped in.
+	if (!process.stdout.isTTY) {
+		// The script was called from a non-TTY context. This is a rather uncommon
+		// use case we don’t actively support. However, we don’t want the script
+		// to wait forever in such cases, so…
+		timeout = setTimeout(function() {
+			// …if no piped data arrived after a whole minute, handle shell
+			// arguments instead.
+			main();
+		}, 60000);
+	}
+	let data = '';
+	stdin.on('data', function(chunk) {
+		clearTimeout(timeout);
+		data += chunk;
+	});
+	stdin.on('end', function() {
+		strings.push(data.trim());
+		main();
+	});
+	stdin.resume();
+}

Optimized Atomcms daily updated/node_modules/.bin/detect-libc

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var spawnSync = require('child_process').spawnSync;
+var libc = require('../');
+
+var spawnOptions = {
+  env: process.env,
+  shell: true,
+  stdio: 'inherit'
+};
+
+if (libc.isNonGlibcLinux) {
+  spawnOptions.env.LIBC = process.env.LIBC || libc.family;
+}
+
+process.exit(spawnSync(process.argv[2], process.argv.slice(3), spawnOptions).status);

Optimized Atomcms daily updated/node_modules/.bin/editorconfig

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+var cli = require('../src/cli')
+cli.default(process.argv)

Optimized Atomcms daily updated/node_modules/.bin/esbuild

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
+var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
+var packageDarwin_arm64 = "@esbuild/darwin-arm64";
+var packageDarwin_x64 = "@esbuild/darwin-x64";
+var knownWindowsPackages = {
+  "win32 arm64 LE": "@esbuild/win32-arm64",
+  "win32 ia32 LE": "@esbuild/win32-ia32",
+  "win32 x64 LE": "@esbuild/win32-x64"
+};
+var knownUnixlikePackages = {
+  "aix ppc64 BE": "@esbuild/aix-ppc64",
+  "android arm64 LE": "@esbuild/android-arm64",
+  "darwin arm64 LE": "@esbuild/darwin-arm64",
+  "darwin x64 LE": "@esbuild/darwin-x64",
+  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
+  "freebsd x64 LE": "@esbuild/freebsd-x64",
+  "linux arm LE": "@esbuild/linux-arm",
+  "linux arm64 LE": "@esbuild/linux-arm64",
+  "linux ia32 LE": "@esbuild/linux-ia32",
+  "linux mips64el LE": "@esbuild/linux-mips64el",
+  "linux ppc64 LE": "@esbuild/linux-ppc64",
+  "linux riscv64 LE": "@esbuild/linux-riscv64",
+  "linux s390x BE": "@esbuild/linux-s390x",
+  "linux x64 LE": "@esbuild/linux-x64",
+  "linux loong64 LE": "@esbuild/linux-loong64",
+  "netbsd arm64 LE": "@esbuild/netbsd-arm64",
+  "netbsd x64 LE": "@esbuild/netbsd-x64",
+  "openbsd arm64 LE": "@esbuild/openbsd-arm64",
+  "openbsd x64 LE": "@esbuild/openbsd-x64",
+  "sunos x64 LE": "@esbuild/sunos-x64"
+};
+var knownWebAssemblyFallbackPackages = {
+  "android arm LE": "@esbuild/android-arm",
+  "android x64 LE": "@esbuild/android-x64",
+  "openharmony arm64 LE": "@esbuild/openharmony-arm64"
+};
+function pkgAndSubpathForCurrentPlatform() {
+  let pkg;
+  let subpath;
+  let isWASM2 = false;
+  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  if (platformKey in knownWindowsPackages) {
+    pkg = knownWindowsPackages[platformKey];
+    subpath = "esbuild.exe";
+  } else if (platformKey in knownUnixlikePackages) {
+    pkg = knownUnixlikePackages[platformKey];
+    subpath = "bin/esbuild";
+  } else if (platformKey in knownWebAssemblyFallbackPackages) {
+    pkg = knownWebAssemblyFallbackPackages[platformKey];
+    subpath = "bin/esbuild";
+    isWASM2 = true;
+  } else {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  return { pkg, subpath, isWASM: isWASM2 };
+}
+function pkgForSomeOtherPlatform() {
+  const libMainJS = require.resolve("esbuild");
+  const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
+  if (path.basename(nodeModulesDirectory) === "node_modules") {
+    for (const unixKey in knownUnixlikePackages) {
+      try {
+        const pkg = knownUnixlikePackages[unixKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+    for (const windowsKey in knownWindowsPackages) {
+      try {
+        const pkg = knownWindowsPackages[windowsKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function downloadedBinPath(pkg, subpath) {
+  const esbuildLibDir = path.dirname(require.resolve("esbuild"));
+  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+function generateBinPath() {
+  if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
+    if (!fs.existsSync(ESBUILD_BINARY_PATH)) {
+      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
+    } else {
+      return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
+    }
+  }
+  const { pkg, subpath, isWASM: isWASM2 } = pkgAndSubpathForCurrentPlatform();
+  let binPath2;
+  try {
+    binPath2 = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    binPath2 = downloadedBinPath(pkg, subpath);
+    if (!fs.existsSync(binPath2)) {
+      try {
+        require.resolve(pkg);
+      } catch {
+        const otherPkg = pkgForSomeOtherPlatform();
+        if (otherPkg) {
+          let suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild on Windows or macOS and copying "node_modules"
+into a Docker image that runs Linux, or by copying "node_modules" between
+Windows and WSL environments.
+
+If you are installing with npm, you can try not copying the "node_modules"
+directory when you copy the files over, and running "npm ci" or "npm install"
+on the destination platform after the copy. Or you could consider using yarn
+instead of npm which has built-in support for installing a package on multiple
+platforms simultaneously.
+
+If you are installing with yarn, you can try listing both this platform and the
+other platform in your ".yarnrc.yml" file using the "supportedArchitectures"
+feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          if (pkg === packageDarwin_x64 && otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 && otherPkg === packageDarwin_x64) {
+            suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild with npm running inside of Rosetta 2 and then
+trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta
+2 is Apple's on-the-fly x86_64-to-arm64 translation service).
+
+If you are installing with npm, you can try ensuring that both npm and node are
+not running under Rosetta 2 and then reinstalling esbuild. This likely involves
+changing how you installed npm and/or node. For example, installing node with
+the universal installer here should work: https://nodejs.org/en/download/. Or
+you could consider using yarn instead of npm which has built-in support for
+installing a package on multiple platforms simultaneously.
+
+If you are installing with yarn, you can try listing both "arm64" and "x64"
+in your ".yarnrc.yml" file using the "supportedArchitectures" feature:
+https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          }
+          throw new Error(`
+You installed esbuild for another platform than the one you're currently using.
+This won't work because esbuild is written with native code and needs to
+install a platform-specific binary executable.
+${suggestions}
+Another alternative is to use the "esbuild-wasm" package instead, which works
+the same way on all platforms. But it comes with a heavy performance cost and
+can sometimes be 10x slower than the "esbuild" package, so you may also not
+want to do that.
+`);
+        }
+        throw new Error(`The package "${pkg}" could not be found, and is needed by esbuild.
+
+If you are installing esbuild with npm, make sure that you don't specify the
+"--no-optional" or "--omit=optional" flags. The "optionalDependencies" feature
+of "package.json" is used by esbuild to install the correct binary executable
+for your current platform.`);
+      }
+      throw e;
+    }
+  }
+  if (/\.zip\//.test(binPath2)) {
+    let pnpapi;
+    try {
+      pnpapi = require("pnpapi");
+    } catch (e) {
+    }
+    if (pnpapi) {
+      const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
+      const binTargetPath = path.join(
+        root,
+        "node_modules",
+        ".cache",
+        "esbuild",
+        `pnpapi-${pkg.replace("/", "-")}-${"0.25.10"}-${path.basename(subpath)}`
+      );
+      if (!fs.existsSync(binTargetPath)) {
+        fs.mkdirSync(path.dirname(binTargetPath), { recursive: true });
+        fs.copyFileSync(binPath2, binTargetPath);
+        fs.chmodSync(binTargetPath, 493);
+      }
+      return { binPath: binTargetPath, isWASM: isWASM2 };
+    }
+  }
+  return { binPath: binPath2, isWASM: isWASM2 };
+}
+
+// lib/npm/node-shim.ts
+var { binPath, isWASM } = generateBinPath();
+if (isWASM) {
+  require("child_process").execFileSync("node", [binPath].concat(process.argv.slice(2)), { stdio: "inherit" });
+} else {
+  require("child_process").execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+}

Optimized Atomcms daily updated/node_modules/.bin/html-beautify

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+var cli = require('../lib/cli'); cli.interpret();
+
+

Optimized Atomcms daily updated/node_modules/.bin/is-docker

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+'use strict';
+const isDocker = require('.');
+
+process.exitCode = isDocker() ? 0 : 2;

Optimized Atomcms daily updated/node_modules/.bin/is-inside-container

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import isInsideContainer from './index.js';
+
+process.exitCode = isInsideContainer() ? 0 : 2;

Optimized Atomcms daily updated/node_modules/.bin/jiti

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const { resolve } = require("node:path");
+
+const script = process.argv.splice(2, 1)[0];
+
+if (!script) {
+   
+  console.error("Usage: jiti <path> [...arguments]");
+  process.exit(1);
+}
+
+const pwd = process.cwd();
+const jiti = require("..")(pwd);
+const resolved = (process.argv[1] = jiti.resolve(resolve(pwd, script)));
+jiti(resolved);

Optimized Atomcms daily updated/node_modules/.bin/js-beautify

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+var cli = require('../lib/cli');
+cli.interpret();

Optimized Atomcms daily updated/node_modules/.bin/json5

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const pkg = require('../package.json')
+const JSON5 = require('./')
+
+const argv = parseArgs()
+
+if (argv.version) {
+    version()
+} else if (argv.help) {
+    usage()
+} else {
+    const inFilename = argv.defaults[0]
+
+    let readStream
+    if (inFilename) {
+        readStream = fs.createReadStream(inFilename)
+    } else {
+        readStream = process.stdin
+    }
+
+    let json5 = ''
+    readStream.on('data', data => {
+        json5 += data
+    })
+
+    readStream.on('end', () => {
+        let space
+        if (argv.space === 't' || argv.space === 'tab') {
+            space = '\t'
+        } else {
+            space = Number(argv.space)
+        }
+
+        let value
+        try {
+            value = JSON5.parse(json5)
+            if (!argv.validate) {
+                const json = JSON.stringify(value, null, space)
+
+                let writeStream
+
+                // --convert is for backward compatibility with v0.5.1. If
+                // specified with <file> and not --out-file, then a file with
+                // the same name but with a .json extension will be written.
+                if (argv.convert && inFilename && !argv.outFile) {
+                    const parsedFilename = path.parse(inFilename)
+                    const outFilename = path.format(
+                        Object.assign(
+                            parsedFilename,
+                            {base: path.basename(parsedFilename.base, parsedFilename.ext) + '.json'}
+                        )
+                    )
+
+                    writeStream = fs.createWriteStream(outFilename)
+                } else if (argv.outFile) {
+                    writeStream = fs.createWriteStream(argv.outFile)
+                } else {
+                    writeStream = process.stdout
+                }
+
+                writeStream.write(json)
+            }
+        } catch (err) {
+            console.error(err.message)
+            process.exit(1)
+        }
+    })
+}
+
+function parseArgs () {
+    let convert
+    let space
+    let validate
+    let outFile
+    let version
+    let help
+    const defaults = []
+
+    const args = process.argv.slice(2)
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i]
+        switch (arg) {
+        case '--convert':
+        case '-c':
+            convert = true
+            break
+
+        case '--space':
+        case '-s':
+            space = args[++i]
+            break
+
+        case '--validate':
+        case '-v':
+            validate = true
+            break
+
+        case '--out-file':
+        case '-o':
+            outFile = args[++i]
+            break
+
+        case '--version':
+        case '-V':
+            version = true
+            break
+
+        case '--help':
+        case '-h':
+            help = true
+            break
+
+        default:
+            defaults.push(arg)
+            break
+        }
+    }
+
+    return {
+        convert,
+        space,
+        validate,
+        outFile,
+        version,
+        help,
+        defaults,
+    }
+}
+
+function version () {
+    console.log(pkg.version)
+}
+
+function usage () {
+    console.log(
+        `
+  Usage: json5 [options] <file>
+
+  If <file> is not provided, then STDIN is used.
+
+  Options:
+
+    -s, --space              The number of spaces to indent or 't' for tabs
+    -o, --out-file [file]    Output to the specified file, otherwise STDOUT
+    -v, --validate           Validate JSON5 but do not output JSON
+    -V, --version            Output the version number
+    -h, --help               Output usage information`
+    )
+}

Optimized Atomcms daily updated/node_modules/.bin/mini-svg-data-uri

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+let help = `
+Usage: mini-svg-data-uri <source> [dest]
+
+Options:
+-v, --version  Output the version number
+-h, --help     Display help for command
+
+Examples:
+  mini-svg-data-uri file.svg           Write to stdout
+  mini-svg-data-uri icon.svg icon.uri  Write to file
+`;
+
+let [source, dest] = process.argv.slice(2);
+
+switch (source) {
+  case '-h':
+  case '--help':
+  case undefined:
+    console.log(help);
+    process.exit();
+
+  case '-v':
+  case '--version':
+    console.log(require('./package').version);
+    process.exit();
+}
+
+const fs = require('fs');
+const svgToMiniDataURI = require('.');
+
+fs.readFile(source, 'utf8', (err, data) => {
+  if (err) {
+    console.error(err.message);
+    console.log(help);
+    process.exit(1);
+  }
+  const out = svgToMiniDataURI(data);
+  dest ? fs.writeFileSync(dest, out) : console.log(out);
+});

Optimized Atomcms daily updated/node_modules/.bin/nanoid

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+let { nanoid, customAlphabet } = require('..')
+
+function print(msg) {
+  process.stdout.write(msg + '\n')
+}
+
+function error(msg) {
+  process.stderr.write(msg + '\n')
+  process.exit(1)
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  print(`
+  Usage
+    $ nanoid [options]
+
+  Options
+    -s, --size       Generated ID size
+    -a, --alphabet   Alphabet to use
+    -h, --help       Show this help
+
+  Examples
+    $ nanoid --s 15
+    S9sBF77U6sDB8Yg
+
+    $ nanoid --size 10 --alphabet abc
+    bcabababca`)
+  process.exit()
+}
+
+let alphabet, size
+for (let i = 2; i < process.argv.length; i++) {
+  let arg = process.argv[i]
+  if (arg === '--size' || arg === '-s') {
+    size = Number(process.argv[i + 1])
+    i += 1
+    if (Number.isNaN(size) || size <= 0) {
+      error('Size must be positive integer')
+    }
+  } else if (arg === '--alphabet' || arg === '-a') {
+    alphabet = process.argv[i + 1]
+    i += 1
+  } else {
+    error('Unknown argument ' + arg)
+  }
+}
+
+if (alphabet) {
+  let customNanoid = customAlphabet(alphabet, size)
+  print(customNanoid())
+} else {
+  print(nanoid(size))
+}

Optimized Atomcms daily updated/node_modules/.bin/node-which

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+var which = require("../")
+if (process.argv.length < 3)
+  usage()
+
+function usage () {
+  console.error('usage: which [-as] program ...')
+  process.exit(1)
+}
+
+var all = false
+var silent = false
+var dashdash = false
+var args = process.argv.slice(2).filter(function (arg) {
+  if (dashdash || !/^-/.test(arg))
+    return true
+
+  if (arg === '--') {
+    dashdash = true
+    return false
+  }
+
+  var flags = arg.substr(1).split('')
+  for (var f = 0; f < flags.length; f++) {
+    var flag = flags[f]
+    switch (flag) {
+      case 's':
+        silent = true
+        break
+      case 'a':
+        all = true
+        break
+      default:
+        console.error('which: illegal option -- ' + flag)
+        usage()
+    }
+  }
+  return false
+})
+
+process.exit(args.reduce(function (pv, current) {
+  try {
+    var f = which.sync(current, { all: all })
+    if (all)
+      f = f.join('\n')
+    if (!silent)
+      console.log(f)
+    return pv;
+  } catch (e) {
+    return 1;
+  }
+}, 0))

Optimized Atomcms daily updated/node_modules/.bin/nopt

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+var nopt = require('../lib/nopt')
+var path = require('path')
+var types = { num: Number,
+  bool: Boolean,
+  help: Boolean,
+  list: Array,
+  'num-list': [Number, Array],
+  'str-list': [String, Array],
+  'bool-list': [Boolean, Array],
+  str: String,
+  clear: Boolean,
+  config: Boolean,
+  length: Number,
+  file: path,
+}
+var shorthands = { s: ['--str', 'astring'],
+  b: ['--bool'],
+  nb: ['--no-bool'],
+  tft: ['--bool-list', '--no-bool-list', '--bool-list', 'true'],
+  '?': ['--help'],
+  h: ['--help'],
+  H: ['--help'],
+  n: ['--num', '125'],
+  c: ['--config'],
+  l: ['--length'],
+  f: ['--file'],
+}
+var parsed = nopt(types
+  , shorthands
+  , process.argv
+  , 2)
+
+console.log('parsed', parsed)
+
+if (parsed.help) {
+  console.log('')
+  console.log('nopt cli tester')
+  console.log('')
+  console.log('types')
+  console.log(Object.keys(types).map(function M (t) {
+    var type = types[t]
+    if (Array.isArray(type)) {
+      return [t, type.map(function (mappedType) {
+        return mappedType.name
+      })]
+    }
+    return [t, type && type.name]
+  }).reduce(function (s, i) {
+    s[i[0]] = i[1]
+    return s
+  }, {}))
+  console.log('')
+  console.log('shorthands')
+  console.log(shorthands)
+}

Optimized Atomcms daily updated/node_modules/.bin/prettier

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = function(cb, mod) {
+  return function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+};
+
+// node_modules/semver-compare/index.js
+var require_semver_compare = __commonJS({
+  "node_modules/semver-compare/index.js": function(exports2, module2) {
+    module2.exports = function cmp(a, b) {
+      var pa = a.split(".");
+      var pb = b.split(".");
+      for (var i = 0; i < 3; i++) {
+        var na = Number(pa[i]);
+        var nb = Number(pb[i]);
+        if (na > nb)
+          return 1;
+        if (nb > na)
+          return -1;
+        if (!isNaN(na) && isNaN(nb))
+          return 1;
+        if (isNaN(na) && !isNaN(nb))
+          return -1;
+      }
+      return 0;
+    };
+  }
+});
+
+// node_modules/please-upgrade-node/index.js
+var require_please_upgrade_node = __commonJS({
+  "node_modules/please-upgrade-node/index.js": function(exports2, module2) {
+    var semverCompare = require_semver_compare();
+    module2.exports = function pleaseUpgradeNode2(pkg, opts) {
+      var opts = opts || {};
+      var requiredVersion = pkg.engines.node.replace(">=", "");
+      var currentVersion = process.version.replace("v", "");
+      if (semverCompare(currentVersion, requiredVersion) === -1) {
+        if (opts.message) {
+          console.error(opts.message(requiredVersion));
+        } else {
+          console.error(
+            pkg.name + " requires at least version " + requiredVersion + " of Node, please upgrade"
+          );
+        }
+        if (opts.hasOwnProperty("exitCode")) {
+          process.exit(opts.exitCode);
+        } else {
+          process.exit(1);
+        }
+      }
+    };
+  }
+});
+
+// bin/prettier.js
+var pleaseUpgradeNode = require_please_upgrade_node();
+var packageJson = require("./package.json");
+pleaseUpgradeNode(packageJson);
+var cli = require("./cli.js");
+module.exports = cli.run(process.argv.slice(2));

Optimized Atomcms daily updated/node_modules/.bin/resolve

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+
+if (
+    String(process.env.npm_lifecycle_script).slice(0, 8) !== 'resolve '
+    && (
+        !process.argv
+        || process.argv.length < 2
+        || (process.argv[1] !== __filename && fs.statSync(process.argv[1]).ino !== fs.statSync(__filename).ino)
+        || (process.env._ && path.resolve(process.env._) !== __filename)
+    )
+) {
+    console.error('Error: `resolve` must be run directly as an executable');
+    process.exit(1);
+}
+
+var supportsPreserveSymlinkFlag = require('supports-preserve-symlinks-flag');
+
+var preserveSymlinks = false;
+for (var i = 2; i < process.argv.length; i += 1) {
+    if (process.argv[i].slice(0, 2) === '--') {
+        if (supportsPreserveSymlinkFlag && process.argv[i] === '--preserve-symlinks') {
+            preserveSymlinks = true;
+        } else if (process.argv[i].length > 2) {
+            console.error('Unknown argument ' + process.argv[i].replace(/[=].*$/, ''));
+            process.exit(2);
+        }
+        process.argv.splice(i, 1);
+        i -= 1;
+        if (process.argv[i] === '--') { break; } // eslint-disable-line no-restricted-syntax
+    }
+}
+
+if (process.argv.length < 3) {
+    console.error('Error: `resolve` expects a specifier');
+    process.exit(2);
+}
+
+var resolve = require('../');
+
+var result = resolve.sync(process.argv[2], {
+    basedir: process.cwd(),
+    preserveSymlinks: preserveSymlinks
+});
+
+console.log(result);

Optimized Atomcms daily updated/node_modules/.bin/sass

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+require('./sass.dart.js');
+var library = globalThis._cliPkgExports.pop();
+if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports;
+
+library.load({
+  readline: require("readline"),
+  chokidar: require("chokidar"),
+  parcel_watcher: (function(i){let r;return function parcel_watcher(){if(void 0!==r)return r;try{r=require(i)}catch(e){if('MODULE_NOT_FOUND'!==e.code)console.error(e);r=null}return r}})("@parcel/watcher"),
+  util: require("util"),
+  stream: require("stream"),
+  nodeModule: require("module"),
+  fs: require("fs"),
+  immutable: require("immutable"),
+});
+
+library.cli_pkg_main_0_(process.argv.slice(2));

Optimized Atomcms daily updated/node_modules/.bin/semver

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+var argv = process.argv.slice(2)
+
+var versions = []
+
+var range = []
+
+var inc = null
+
+var version = require('../package.json').version
+
+var loose = false
+
+var includePrerelease = false
+
+var coerce = false
+
+var identifier
+
+var semver = require('../semver')
+
+var reverse = false
+
+var options = {}
+
+main()
+
+function main () {
+  if (!argv.length) return help()
+  while (argv.length) {
+    var a = argv.shift()
+    var indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(a.slice(indexOfEqualSign + 1))
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  var options = { loose: loose, includePrerelease: includePrerelease }
+
+  versions = versions.map(function (v) {
+    return coerce ? (semver.coerce(v) || { version: v }).version : v
+  }).filter(function (v) {
+    return semver.valid(v)
+  })
+  if (!versions.length) return fail()
+  if (inc && (versions.length !== 1 || range.length)) { return failInc() }
+
+  for (var i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter(function (v) {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) return fail()
+  }
+  return success(versions)
+}
+
+function failInc () {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+function fail () { process.exit(1) }
+
+function success () {
+  var compare = reverse ? 'rcompare' : 'compare'
+  versions.sort(function (a, b) {
+    return semver[compare](a, b, options)
+  }).map(function (v) {
+    return semver.clean(v, options)
+  }).map(function (v) {
+    return inc ? semver.inc(v, inc, options, identifier) : v
+  }).forEach(function (v, i, _) { console.log(v) })
+}
+
+function help () {
+  console.log(['SemVer ' + version,
+    '',
+    'A JavaScript implementation of the https://semver.org/ specification',
+    'Copyright Isaac Z. Schlueter',
+    '',
+    'Usage: semver [options] <version> [<version> [...]]',
+    'Prints valid versions sorted by SemVer precedence',
+    '',
+    'Options:',
+    '-r --range <range>',
+    '        Print versions that match the specified range.',
+    '',
+    '-i --increment [<level>]',
+    '        Increment a version by the specified level.  Level can',
+    '        be one of: major, minor, patch, premajor, preminor,',
+    "        prepatch, or prerelease.  Default level is 'patch'.",
+    '        Only one version may be specified.',
+    '',
+    '--preid <identifier>',
+    '        Identifier to be used to prefix premajor, preminor,',
+    '        prepatch or prerelease version increments.',
+    '',
+    '-l --loose',
+    '        Interpret versions and ranges loosely',
+    '',
+    '-p --include-prerelease',
+    '        Always include prerelease versions in range matching',
+    '',
+    '-c --coerce',
+    '        Coerce a string into SemVer if possible',
+    '        (does not imply --loose)',
+    '',
+    'Program exits successfully if any valid version satisfies',
+    'all supplied ranges, and prints all satisfying versions.',
+    '',
+    'If no satisfying versions are found, then exits failure.',
+    '',
+    'Versions are printed in ascending order, so supplying',
+    'multiple versions to the utility will just sort them.'
+  ].join('\n'))
+}

Optimized Atomcms daily updated/node_modules/.bin/sucrase

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../dist/cli").default();

Optimized Atomcms daily updated/node_modules/.bin/sucrase-node

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+const Module = require("module");
+const {resolve} = require("path");
+
+/*
+ * Simple wrapper around node that first registers Sucrase with default settings.
+ *
+ * This is meant for simple use cases, and doesn't support custom Node/V8 args,
+ * executing a code snippet, a REPL, or other things that you might find in
+ * node, babel-node, or ts-node. For more advanced use cases, you can use
+ * `node -r sucrase/register` or register a require hook programmatically from
+ * your own code.
+ */
+require("../register");
+
+process.argv.splice(1, 1);
+process.argv[1] = resolve(process.argv[1]);
+Module.runMain();

Optimized Atomcms daily updated/node_modules/.bin/tailwind

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+if (false) {
+    module.exports = require("./oxide/cli");
+} else {
+    module.exports = require("./cli/index");
+}

Optimized Atomcms daily updated/node_modules/.bin/tailwindcss

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+if (false) {
+    module.exports = require("./oxide/cli");
+} else {
+    module.exports = require("./cli/index");
+}

Optimized Atomcms daily updated/node_modules/.bin/update-browserslist-db

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+let { readFileSync } = require('fs')
+let { join } = require('path')
+
+require('./check-npm-version')
+let updateDb = require('./')
+
+const ROOT = __dirname
+
+function getPackage() {
+  return JSON.parse(readFileSync(join(ROOT, 'package.json')))
+}
+
+let args = process.argv.slice(2)
+
+let USAGE = 'Usage:\n  npx update-browserslist-db\n'
+
+function isArg(arg) {
+  return args.some(i => i === arg)
+}
+
+function error(msg) {
+  process.stderr.write('update-browserslist-db: ' + msg + '\n')
+  process.exit(1)
+}
+
+if (isArg('--help') || isArg('-h')) {
+  process.stdout.write(getPackage().description + '.\n\n' + USAGE + '\n')
+} else if (isArg('--version') || isArg('-v')) {
+  process.stdout.write('browserslist-lint ' + getPackage().version + '\n')
+} else {
+  try {
+    updateDb()
+  } catch (e) {
+    if (e.name === 'BrowserslistUpdateError') {
+      error(e.message)
+    } else {
+      throw e
+    }
+  }
+}

Optimized Atomcms daily updated/node_modules/.bin/vite

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { performance } from 'node:perf_hooks'
+import module from 'node:module'
+
+if (!import.meta.url.includes('node_modules')) {
+  try {
+    // only available as dev dependency
+    await import('source-map-support').then((r) => r.default.install())
+  } catch {}
+
+  process.on('unhandledRejection', (err) => {
+    throw new Error('UNHANDLED PROMISE REJECTION', { cause: err })
+  })
+}
+
+global.__vite_start_time = performance.now()
+
+// check debug mode first before requiring the CLI.
+const debugIndex = process.argv.findIndex((arg) => /^(?:-d|--debug)$/.test(arg))
+const filterIndex = process.argv.findIndex((arg) =>
+  /^(?:-f|--filter)$/.test(arg),
+)
+const profileIndex = process.argv.indexOf('--profile')
+
+if (debugIndex > 0) {
+  let value = process.argv[debugIndex + 1]
+  if (!value || value.startsWith('-')) {
+    value = 'vite:*'
+  } else {
+    // support debugging multiple flags with comma-separated list
+    value = value
+      .split(',')
+      .map((v) => `vite:${v}`)
+      .join(',')
+  }
+  process.env.DEBUG = `${
+    process.env.DEBUG ? process.env.DEBUG + ',' : ''
+  }${value}`
+
+  if (filterIndex > 0) {
+    const filter = process.argv[filterIndex + 1]
+    if (filter && !filter.startsWith('-')) {
+      process.env.VITE_DEBUG_FILTER = filter
+    }
+  }
+}
+
+function start() {
+  try {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.8.0+ and only called if it exists
+    module.enableCompileCache?.()
+    // flush the cache after 10s because the cache is not flushed until process end
+    // for dev server, the cache is never flushed unless manually flushed because the process.exit is called
+    // also flushing the cache in SIGINT handler seems to cause the process to hang
+    setTimeout(() => {
+      try {
+        // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.12.0+ and only called if it exists
+        module.flushCompileCache?.()
+      } catch {}
+    }, 10 * 1000).unref()
+  } catch {}
+  return import('../dist/node/cli.js')
+}
+
+if (profileIndex > 0) {
+  process.argv.splice(profileIndex, 1)
+  const next = process.argv[profileIndex]
+  if (next && !next.startsWith('-')) {
+    process.argv.splice(profileIndex, 1)
+  }
+  const inspector = await import('node:inspector').then((r) => r.default)
+  const session = (global.__vite_profile_session = new inspector.Session())
+  session.connect()
+  session.post('Profiler.enable', () => {
+    session.post('Profiler.start', start)
+  })
+} else {
+  start()
+}

Optimized Atomcms daily updated/node_modules/.bin/yaml

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { UserError, cli, help } from './dist/cli.mjs'
+
+cli(process.stdin, error => {
+  if (error instanceof UserError) {
+    if (error.code === UserError.ARGS) console.error(`${help}\n`)
+    console.error(error.message)
+    process.exitCode = error.code
+  } else if (error) throw error
+})

Optimized Atomcms daily updated/node_modules/.yarn-integrity

@@ -0,0 +1,419 @@
+{
+  "systemParams": "linux-x64-137",
+  "modulesFolders": [
+    "node_modules"
+  ],
+  "flags": [],
+  "linkedModules": [],
+  "topLevelPatterns": [
+    "-@^0.0.1",
+    "@alpinejs/focus@^3.10.3",
+    "@prettier/plugin-php@^0.19.3",
+    "@shufo/prettier-plugin-blade@^1.8.6",
+    "@tailwindcss/forms@^0.5.2",
+    "@tailwindcss/typography@^0.5.9",
+    "alpinejs@^3.10.3",
+    "autoprefixer@^10.4.7",
+    "axios@^1.6.2",
+    "bootstrap@^5.3.3",
+    "jquery@^3.5",
+    "laravel-vite-plugin@^1.3.0",
+    "lodash@^4.17.19",
+    "popper.js@^1.16",
+    "postcss-import@^14.1.0",
+    "postcss@^8.4.14",
+    "sass-loader@^10.1.1",
+    "sass@^1.89.0",
+    "swiper@^8.4.7",
+    "tailwindcss@^3.1.6",
+    "turbolinks@^5.2.0",
+    "vite@^6.3.6"
+  ],
+  "lockfileEntries": {
+    "-@^0.0.1": "https://registry.npmjs.org/-/-/--0.0.1.tgz",
+    "@alloc/quick-lru@^5.2.0": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
+    "@alpinejs/focus@^3.10.3": "https://registry.npmjs.org/@alpinejs/focus/-/focus-3.12.2.tgz",
+    "@babel/runtime-corejs3@^7.16.5": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.28.4.tgz",
+    "@esbuild/aix-ppc64@0.25.10": "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.25.10.tgz#ee6b7163a13528e099ecf562b972f2bcebe0aa97",
+    "@esbuild/android-arm64@0.25.10": "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.25.10.tgz#115fc76631e82dd06811bfaf2db0d4979c16e2cb",
+    "@esbuild/android-arm@0.25.10": "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.25.10.tgz#8d5811912da77f615398611e5bbc1333fe321aa9",
+    "@esbuild/android-x64@0.25.10": "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.25.10.tgz#e3e96516b2d50d74105bb92594c473e30ddc16b1",
+    "@esbuild/darwin-arm64@0.25.10": "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.25.10.tgz#6af6bb1d05887dac515de1b162b59dc71212ed76",
+    "@esbuild/darwin-x64@0.25.10": "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.25.10.tgz#99ae82347fbd336fc2d28ffd4f05694e6e5b723d",
+    "@esbuild/freebsd-arm64@0.25.10": "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.10.tgz#0c6d5558a6322b0bdb17f7025c19bd7d2359437d",
+    "@esbuild/freebsd-x64@0.25.10": "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.25.10.tgz#8c35873fab8c0857a75300a3dcce4324ca0b9844",
+    "@esbuild/linux-arm64@0.25.10": "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.25.10.tgz#3edc2f87b889a15b4cedaf65f498c2bed7b16b90",
+    "@esbuild/linux-arm@0.25.10": "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.25.10.tgz#86501cfdfb3d110176d80c41b27ed4611471cde7",
+    "@esbuild/linux-ia32@0.25.10": "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.25.10.tgz#e6589877876142537c6864680cd5d26a622b9d97",
+    "@esbuild/linux-loong64@0.25.10": "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.25.10.tgz#11119e18781f136d8083ea10eb6be73db7532de8",
+    "@esbuild/linux-mips64el@0.25.10": "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.25.10.tgz#3052f5436b0c0c67a25658d5fc87f045e7def9e6",
+    "@esbuild/linux-ppc64@0.25.10": "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.25.10.tgz#2f098920ee5be2ce799f35e367b28709925a8744",
+    "@esbuild/linux-riscv64@0.25.10": "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.25.10.tgz#fa51d7fd0a22a62b51b4b94b405a3198cf7405dd",
+    "@esbuild/linux-s390x@0.25.10": "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.25.10.tgz#a27642e36fc282748fdb38954bd3ef4f85791e8a",
+    "@esbuild/linux-x64@0.25.10": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.10.tgz",
+    "@esbuild/netbsd-arm64@0.25.10": "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.10.tgz#25c09a659c97e8af19e3f2afd1c9190435802151",
+    "@esbuild/netbsd-x64@0.25.10": "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.25.10.tgz#7fa5f6ffc19be3a0f6f5fd32c90df3dc2506937a",
+    "@esbuild/openbsd-arm64@0.25.10": "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.10.tgz#8faa6aa1afca0c6d024398321d6cb1c18e72a1c3",
+    "@esbuild/openbsd-x64@0.25.10": "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.25.10.tgz#a42979b016f29559a8453d32440d3c8cd420af5e",
+    "@esbuild/openharmony-arm64@0.25.10": "https://registry.yarnpkg.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.10.tgz#fd87bfeadd7eeb3aa384bbba907459ffa3197cb1",
+    "@esbuild/sunos-x64@0.25.10": "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.25.10.tgz#3a18f590e36cb78ae7397976b760b2b8c74407f4",
+    "@esbuild/win32-arm64@0.25.10": "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.25.10.tgz#e71741a251e3fd971408827a529d2325551f530c",
+    "@esbuild/win32-ia32@0.25.10": "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.25.10.tgz#c6f010b5d3b943d8901a0c87ea55f93b8b54bf94",
+    "@esbuild/win32-x64@0.25.10": "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.25.10.tgz#e4b3e255a1b4aea84f6e1d2ae0b73f826c3785bd",
+    "@jridgewell/gen-mapping@^0.3.2": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz",
+    "@jridgewell/resolve-uri@^3.1.0": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+    "@jridgewell/set-array@^1.0.1": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+    "@jridgewell/sourcemap-codec@^1.4.10": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
+    "@jridgewell/sourcemap-codec@^1.4.14": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
+    "@jridgewell/trace-mapping@^0.3.9": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
+    "@nodelib/fs.scandir@2.1.5": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+    "@nodelib/fs.stat@2.0.5": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+    "@nodelib/fs.stat@^2.0.2": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+    "@nodelib/fs.walk@^1.2.3": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+    "@parcel/watcher-android-arm64@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-android-arm64/-/watcher-android-arm64-2.5.0.tgz#e32d3dda6647791ee930556aee206fcd5ea0fb7a",
+    "@parcel/watcher-darwin-arm64@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-darwin-arm64/-/watcher-darwin-arm64-2.5.0.tgz#0d9e680b7e9ec1c8f54944f1b945aa8755afb12f",
+    "@parcel/watcher-darwin-x64@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-darwin-x64/-/watcher-darwin-x64-2.5.0.tgz#f9f1d5ce9d5878d344f14ef1856b7a830c59d1bb",
+    "@parcel/watcher-freebsd-x64@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-freebsd-x64/-/watcher-freebsd-x64-2.5.0.tgz#2b77f0c82d19e84ff4c21de6da7f7d096b1a7e82",
+    "@parcel/watcher-linux-arm-glibc@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-linux-arm-glibc/-/watcher-linux-arm-glibc-2.5.0.tgz#92ed322c56dbafa3d2545dcf2803334aee131e42",
+    "@parcel/watcher-linux-arm-musl@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-linux-arm-musl/-/watcher-linux-arm-musl-2.5.0.tgz#cd48e9bfde0cdbbd2ecd9accfc52967e22f849a4",
+    "@parcel/watcher-linux-arm64-glibc@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-linux-arm64-glibc/-/watcher-linux-arm64-glibc-2.5.0.tgz#7b81f6d5a442bb89fbabaf6c13573e94a46feb03",
+    "@parcel/watcher-linux-arm64-musl@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-linux-arm64-musl/-/watcher-linux-arm64-musl-2.5.0.tgz#dcb8ff01077cdf59a18d9e0a4dff7a0cfe5fd732",
+    "@parcel/watcher-linux-x64-glibc@2.5.0": "https://registry.npmjs.org/@parcel/watcher-linux-x64-glibc/-/watcher-linux-x64-glibc-2.5.0.tgz",
+    "@parcel/watcher-linux-x64-musl@2.5.0": "https://registry.npmjs.org/@parcel/watcher-linux-x64-musl/-/watcher-linux-x64-musl-2.5.0.tgz",
+    "@parcel/watcher-win32-arm64@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-win32-arm64/-/watcher-win32-arm64-2.5.0.tgz#87cdb16e0783e770197e52fb1dc027bb0c847154",
+    "@parcel/watcher-win32-ia32@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-win32-ia32/-/watcher-win32-ia32-2.5.0.tgz#778c39b56da33e045ba21c678c31a9f9d7c6b220",
+    "@parcel/watcher-win32-x64@2.5.0": "https://registry.yarnpkg.com/@parcel/watcher-win32-x64/-/watcher-win32-x64-2.5.0.tgz#33873876d0bbc588aacce38e90d1d7480ce81cb7",
+    "@parcel/watcher@^2.4.1": "https://registry.npmjs.org/@parcel/watcher/-/watcher-2.5.0.tgz",
+    "@pkgr/utils@^2.3.1": "https://registry.npmjs.org/@pkgr/utils/-/utils-2.4.1.tgz",
+    "@prettier/plugin-php@^0.19.0": "https://registry.npmjs.org/@prettier/plugin-php/-/plugin-php-0.19.5.tgz",
+    "@prettier/plugin-php@^0.19.3": "https://registry.npmjs.org/@prettier/plugin-php/-/plugin-php-0.19.5.tgz",
+    "@rollup/rollup-android-arm-eabi@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.4.tgz#59e7478d310f7e6a7c72453978f562483828112f",
+    "@rollup/rollup-android-arm64@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.4.tgz#a825192a0b1b2f27a5c950c439e7e37a33c5d056",
+    "@rollup/rollup-darwin-arm64@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.4.tgz#4ee37078bccd725ae3c5f30ef92efc8e1bf886f3",
+    "@rollup/rollup-darwin-x64@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.4.tgz#43cc08bd05bf9f388f125e7210a544e62d368d90",
+    "@rollup/rollup-freebsd-arm64@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.4.tgz#bc8e640e28abe52450baf3fc80d9b26d9bb6587d",
+    "@rollup/rollup-freebsd-x64@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.4.tgz#e981a22e057cc8c65bb523019d344d3a66b15bbc",
+    "@rollup/rollup-linux-arm-gnueabihf@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.4.tgz#4036b68904f392a20f3499d63b33e055b67eb274",
+    "@rollup/rollup-linux-arm-musleabihf@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.4.tgz#d3b1b9589606e0ff916801c855b1ace9e733427a",
+    "@rollup/rollup-linux-arm64-gnu@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.4.tgz#cbf0943c477e3b96340136dd3448eaf144378cf2",
+    "@rollup/rollup-linux-arm64-musl@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.4.tgz#837f5a428020d5dce1c3b4cc049876075402cf78",
+    "@rollup/rollup-linux-loong64-gnu@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.4.tgz#532c214ababb32ab4bc21b4054278b9a8979e516",
+    "@rollup/rollup-linux-ppc64-gnu@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.4.tgz#93900163b61b49cee666d10ee38257a8b1dd161a",
+    "@rollup/rollup-linux-riscv64-gnu@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.4.tgz#f0ffdcc7066ca04bc972370c74289f35c7a7dc42",
+    "@rollup/rollup-linux-riscv64-musl@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.4.tgz#361695c39dbe96773509745d77a870a32a9f8e48",
+    "@rollup/rollup-linux-s390x-gnu@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.4.tgz#09fc6cc2e266a2324e366486ae5d1bca48c43a6a",
+    "@rollup/rollup-linux-x64-gnu@4.52.4": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.4.tgz",
+    "@rollup/rollup-linux-x64-musl@4.52.4": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.4.tgz",
+    "@rollup/rollup-openharmony-arm64@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.4.tgz#ef493c072f9dac7e0edb6c72d63366846b6ffcd9",
+    "@rollup/rollup-win32-arm64-msvc@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.4.tgz#56e1aaa6a630d2202ee7ec0adddd05cf384ffd44",
+    "@rollup/rollup-win32-ia32-msvc@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.4.tgz#0a44bbf933a9651c7da2b8569fa448dec0de7480",
+    "@rollup/rollup-win32-x64-gnu@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.4.tgz#730e12f0b60b234a7c02d5d3179ca3ec7972033d",
+    "@rollup/rollup-win32-x64-msvc@4.52.4": "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.4.tgz#5b2dd648a960b8fa00d76f2cc4eea2f03daa80f4",
+    "@shufo/prettier-plugin-blade@^1.8.6": "https://registry.npmjs.org/@shufo/prettier-plugin-blade/-/prettier-plugin-blade-1.8.12.tgz",
+    "@shufo/tailwindcss-class-sorter@^2.0.0": "https://registry.npmjs.org/@shufo/tailwindcss-class-sorter/-/tailwindcss-class-sorter-2.0.0.tgz",
+    "@tailwindcss/forms@^0.5.2": "https://registry.npmjs.org/@tailwindcss/forms/-/forms-0.5.3.tgz",
+    "@tailwindcss/typography@^0.5.9": "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.9.tgz",
+    "@types/estree@1.0.8": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+    "@types/json-schema@^7.0.8": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.12.tgz",
+    "@vue/reactivity@~3.1.1": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.1.5.tgz",
+    "@vue/shared@3.1.5": "https://registry.npmjs.org/@vue/shared/-/shared-3.1.5.tgz",
+    "abbrev@^1.0.0": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+    "aigle-core@^1.0.0": "https://registry.npmjs.org/aigle-core/-/aigle-core-1.0.0.tgz",
+    "aigle@^1.14.1": "https://registry.npmjs.org/aigle/-/aigle-1.14.1.tgz",
+    "ajv-keywords@^3.5.2": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+    "ajv@^6.12.5": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+    "ajv@^8.9.0": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
+    "alpinejs@^3.10.3": "https://registry.npmjs.org/alpinejs/-/alpinejs-3.12.2.tgz",
+    "ansi-regex@^5.0.1": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+    "ansi-styles@^4.0.0": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+    "ansi-styles@^4.1.0": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+    "any-promise@^1.0.0": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
+    "anymatch@~3.1.2": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+    "arg@^5.0.2": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
+    "asynckit@^0.4.0": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+    "autoprefixer@^10.4.7": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.14.tgz",
+    "axios@^1.6.2": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
+    "balanced-match@^1.0.0": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+    "big-integer@^1.6.44": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.51.tgz",
+    "big.js@^5.2.2": "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz",
+    "binary-extensions@^2.0.0": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+    "blade-formatter@^1.32.12": "https://registry.npmjs.org/blade-formatter/-/blade-formatter-1.32.12.tgz",
+    "bootstrap@^5.3.3": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.3.3.tgz",
+    "bplist-parser@^0.2.0": "https://registry.npmjs.org/bplist-parser/-/bplist-parser-0.2.0.tgz",
+    "brace-expansion@^1.1.7": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+    "brace-expansion@^2.0.1": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+    "braces@^3.0.3": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+    "braces@~3.0.2": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+    "browserslist@^4.21.5": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.3.tgz",
+    "buffer-from@^1.0.0": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+    "bundle-name@^3.0.0": "https://registry.npmjs.org/bundle-name/-/bundle-name-3.0.0.tgz",
+    "call-bind-apply-helpers@^1.0.1": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+    "call-bind-apply-helpers@^1.0.2": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+    "camelcase-css@^2.0.1": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
+    "caniuse-lite@^1.0.30001464": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001690.tgz",
+    "caniuse-lite@^1.0.30001688": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001690.tgz",
+    "chalk@^4.1.0": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+    "chokidar@^3.5.3": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+    "chokidar@^4.0.0": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+    "cliui@^8.0.1": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+    "color-convert@^2.0.1": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+    "color-name@~1.1.4": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+    "combined-stream@^1.0.8": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+    "commander@^2.19.0": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+    "commander@^4.0.0": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
+    "concat-map@0.0.1": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+    "concat-stream@^2.0.0": "https://registry.npmjs.org/concat-stream/-/concat-stream-2.0.0.tgz",
+    "config-chain@^1.1.13": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz",
+    "core-js-pure@^3.43.0": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.45.1.tgz",
+    "cross-spawn@^7.0.3": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+    "cssesc@^3.0.0": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
+    "default-browser-id@^3.0.0": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-3.0.0.tgz",
+    "default-browser@^4.0.0": "https://registry.npmjs.org/default-browser/-/default-browser-4.0.0.tgz",
+    "define-lazy-prop@^3.0.0": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz",
+    "delayed-stream@~1.0.0": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+    "detect-indent@^6.0.0": "https://registry.npmjs.org/detect-indent/-/detect-indent-6.1.0.tgz",
+    "detect-libc@^1.0.3": "https://registry.npmjs.org/detect-libc/-/detect-libc-1.0.3.tgz",
+    "didyoumean@^1.2.2": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
+    "dlv@^1.1.3": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
+    "dom7@^4.0.4": "https://registry.npmjs.org/dom7/-/dom7-4.0.6.tgz",
+    "dunder-proto@^1.0.1": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+    "editorconfig@^0.15.3": "https://registry.npmjs.org/editorconfig/-/editorconfig-0.15.3.tgz",
+    "electron-to-chromium@^1.5.73": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.76.tgz",
+    "emoji-regex@^8.0.0": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+    "emojis-list@^3.0.0": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz",
+    "es-define-property@^1.0.1": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+    "es-errors@^1.3.0": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+    "es-object-atoms@^1.0.0": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+    "es-object-atoms@^1.1.1": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+    "es-set-tostringtag@^2.1.0": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+    "esbuild@^0.25.0": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.10.tgz",
+    "escalade@^3.1.1": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+    "escalade@^3.2.0": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+    "execa@^5.0.0": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz",
+    "execa@^7.1.1": "https://registry.npmjs.org/execa/-/execa-7.1.1.tgz",
+    "fast-deep-equal@^3.1.1": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+    "fast-glob@^3.2.12": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz",
+    "fast-json-stable-stringify@^2.0.0": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+    "fastq@^1.6.0": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz",
+    "fdir@^6.4.4": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+    "fdir@^6.5.0": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+    "fill-range@^7.1.1": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+    "find-config@^1.0.0": "https://registry.npmjs.org/find-config/-/find-config-1.0.0.tgz",
+    "focus-trap@^6.6.1": "https://registry.npmjs.org/focus-trap/-/focus-trap-6.9.4.tgz",
+    "follow-redirects@^1.15.6": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+    "form-data@^4.0.4": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+    "fraction.js@^4.2.0": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.2.0.tgz",
+    "fs.realpath@^1.0.0": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+    "fsevents@~2.3.2": "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6",
+    "fsevents@~2.3.3": "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6",
+    "function-bind@^1.1.1": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+    "function-bind@^1.1.2": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+    "get-caller-file@^2.0.5": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+    "get-intrinsic@^1.2.6": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+    "get-proto@^1.0.1": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+    "get-stream@^6.0.0": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
+    "get-stream@^6.0.1": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
+    "glob-parent@^5.1.2": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+    "glob-parent@^6.0.2": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+    "glob-parent@~5.1.2": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+    "glob@7.1.6": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+    "glob@^8.0.1": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+    "glob@^8.1.0": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+    "gopd@^1.2.0": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+    "has-flag@^4.0.0": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+    "has-symbols@^1.0.3": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+    "has-symbols@^1.1.0": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+    "has-tostringtag@^1.0.2": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+    "has@^1.0.3": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+    "hasown@^2.0.2": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+    "html-attribute-sorter@^0.4.3": "https://registry.npmjs.org/html-attribute-sorter/-/html-attribute-sorter-0.4.3.tgz",
+    "human-signals@^2.1.0": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz",
+    "human-signals@^4.3.0": "https://registry.npmjs.org/human-signals/-/human-signals-4.3.1.tgz",
+    "ignore@^5.1.8": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz",
+    "immutable@^5.0.2": "https://registry.npmjs.org/immutable/-/immutable-5.0.3.tgz",
+    "inflight@^1.0.4": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+    "inherits@2": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+    "inherits@^2.0.3": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+    "ini@^1.3.4": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+    "is-binary-path@~2.1.0": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+    "is-core-module@^2.11.0": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.12.1.tgz",
+    "is-docker@^2.0.0": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz",
+    "is-docker@^3.0.0": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz",
+    "is-extglob@^2.1.1": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+    "is-fullwidth-code-point@^3.0.0": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+    "is-glob@^4.0.1": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+    "is-glob@^4.0.3": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+    "is-glob@~4.0.1": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+    "is-inside-container@^1.0.0": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz",
+    "is-number@^7.0.0": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+    "is-stream@^2.0.0": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+    "is-stream@^3.0.0": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
+    "is-wsl@^2.2.0": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
+    "isexe@^2.0.0": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+    "jiti@^1.18.2": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+    "jquery@^3.5": "https://registry.npmjs.org/jquery/-/jquery-3.7.0.tgz",
+    "js-beautify@^1.14.0": "https://registry.npmjs.org/js-beautify/-/js-beautify-1.14.8.tgz",
+    "json-schema-traverse@^0.4.1": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+    "json-schema-traverse@^1.0.0": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+    "json5@^2.1.2": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+    "klona@^2.0.4": "https://registry.npmjs.org/klona/-/klona-2.0.6.tgz",
+    "laravel-vite-plugin@^1.3.0": "https://registry.npmjs.org/laravel-vite-plugin/-/laravel-vite-plugin-1.3.0.tgz",
+    "lilconfig@^2.0.5": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
+    "lilconfig@^2.1.0": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
+    "lines-and-columns@^1.1.6": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+    "linguist-languages@^7.21.0": "https://registry.npmjs.org/linguist-languages/-/linguist-languages-7.21.0.tgz",
+    "loader-utils@^2.0.0": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.4.tgz",
+    "lodash.castarray@^4.4.0": "https://registry.npmjs.org/lodash.castarray/-/lodash.castarray-4.4.0.tgz",
+    "lodash.isplainobject@^4.0.6": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+    "lodash.merge@^4.6.2": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+    "lodash@^4.17.19": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+    "lru-cache@^4.1.5": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz",
+    "lru-cache@^6.0.0": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+    "map-age-cleaner@^0.1.3": "https://registry.npmjs.org/map-age-cleaner/-/map-age-cleaner-0.1.3.tgz",
+    "math-intrinsics@^1.1.0": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+    "mem@^8.0.0": "https://registry.npmjs.org/mem/-/mem-8.1.1.tgz",
+    "merge-stream@^2.0.0": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
+    "merge2@^1.3.0": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+    "micromatch@^4.0.4": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+    "micromatch@^4.0.5": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+    "mime-db@1.52.0": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+    "mime-types@^2.1.12": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+    "mimic-fn@^2.1.0": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
+    "mimic-fn@^3.1.0": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-3.1.0.tgz",
+    "mimic-fn@^4.0.0": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz",
+    "mini-svg-data-uri@^1.2.3": "https://registry.npmjs.org/mini-svg-data-uri/-/mini-svg-data-uri-1.4.4.tgz",
+    "minimatch@^3.0.4": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+    "minimatch@^5.0.1": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+    "mz@^2.7.0": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
+    "nanoid@^3.3.11": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+    "neo-async@^2.6.2": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz",
+    "node-addon-api@^7.0.0": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-7.1.1.tgz",
+    "node-releases@^2.0.19": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
+    "nopt@^6.0.0": "https://registry.npmjs.org/nopt/-/nopt-6.0.0.tgz",
+    "normalize-path@^3.0.0": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+    "normalize-path@~3.0.0": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+    "normalize-range@^0.1.2": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
+    "npm-run-path@^4.0.1": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
+    "npm-run-path@^5.1.0": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.1.0.tgz",
+    "object-assign@^4.0.1": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+    "object-hash@^3.0.0": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
+    "once@^1.3.0": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+    "onetime@^5.1.2": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
+    "onetime@^6.0.0": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz",
+    "open@^9.1.0": "https://registry.npmjs.org/open/-/open-9.1.0.tgz",
+    "os-homedir@^1.0.0": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz",
+    "p-defer@^1.0.0": "https://registry.npmjs.org/p-defer/-/p-defer-1.0.0.tgz",
+    "path-is-absolute@^1.0.0": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+    "path-key@^3.0.0": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+    "path-key@^3.1.0": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+    "path-key@^4.0.0": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
+    "path-parse@^1.0.7": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+    "php-parser@3.1.4": "https://registry.npmjs.org/php-parser/-/php-parser-3.1.4.tgz",
+    "php-parser@^3.1.3": "https://registry.npmjs.org/php-parser/-/php-parser-3.1.5.tgz",
+    "picocolors@^1.0.0": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+    "picocolors@^1.1.0": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+    "picocolors@^1.1.1": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+    "picomatch@^2.0.4": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+    "picomatch@^2.2.1": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+    "picomatch@^2.3.1": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+    "picomatch@^4.0.2": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+    "picomatch@^4.0.3": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+    "pify@^2.3.0": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+    "pirates@^4.0.1": "https://registry.npmjs.org/pirates/-/pirates-4.0.5.tgz",
+    "popper.js@^1.16": "https://registry.npmjs.org/popper.js/-/popper.js-1.16.1.tgz",
+    "postcss-import@^14.1.0": "https://registry.npmjs.org/postcss-import/-/postcss-import-14.1.0.tgz",
+    "postcss-import@^15.1.0": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz",
+    "postcss-js@^4.0.1": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.1.tgz",
+    "postcss-load-config@^4.0.1": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.1.tgz",
+    "postcss-nested@^6.0.1": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.0.1.tgz",
+    "postcss-selector-parser@6.0.10": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz",
+    "postcss-selector-parser@^6.0.11": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz",
+    "postcss-value-parser@^4.0.0": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+    "postcss-value-parser@^4.2.0": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+    "postcss@^8.4.14": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+    "postcss@^8.4.23": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+    "postcss@^8.5.3": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+    "prettier@^2.2.0": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
+    "prettier@^2.6.2": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
+    "proto-list@~1.2.1": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz",
+    "proxy-from-env@^1.1.0": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+    "pseudomap@^1.0.2": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",
+    "punycode@^2.1.0": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz",
+    "queue-microtask@^1.2.2": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+    "read-cache@^1.0.0": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+    "readable-stream@^3.0.2": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+    "readdirp@^4.0.1": "https://registry.npmjs.org/readdirp/-/readdirp-4.0.2.tgz",
+    "readdirp@~3.6.0": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+    "require-directory@^2.1.1": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+    "require-from-string@^2.0.2": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+    "resolve@^1.1.7": "https://registry.npmjs.org/resolve/-/resolve-1.22.2.tgz",
+    "resolve@^1.22.2": "https://registry.npmjs.org/resolve/-/resolve-1.22.2.tgz",
+    "reusify@^1.0.4": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
+    "rollup@^4.34.9": "https://registry.npmjs.org/rollup/-/rollup-4.52.4.tgz",
+    "run-applescript@^5.0.0": "https://registry.npmjs.org/run-applescript/-/run-applescript-5.0.0.tgz",
+    "run-parallel@^1.1.9": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+    "safe-buffer@~5.2.0": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+    "sass-loader@^10.1.1": "https://registry.npmjs.org/sass-loader/-/sass-loader-10.4.1.tgz",
+    "sass@^1.89.0": "https://registry.npmjs.org/sass/-/sass-1.93.2.tgz",
+    "schema-utils@^3.0.0": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.2.0.tgz",
+    "semver@^5.6.0": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
+    "semver@^7.3.2": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz",
+    "shebang-command@^2.0.0": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+    "shebang-regex@^3.0.0": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+    "sigmund@^1.0.1": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz",
+    "signal-exit@^3.0.3": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+    "signal-exit@^3.0.7": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+    "source-map-js@>=0.6.2 <2.0.0": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+    "source-map-js@^1.2.1": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+    "ssr-window@^4.0.0": "https://registry.npmjs.org/ssr-window/-/ssr-window-4.0.2.tgz",
+    "ssr-window@^4.0.2": "https://registry.npmjs.org/ssr-window/-/ssr-window-4.0.2.tgz",
+    "string-width@^4.1.0": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+    "string-width@^4.2.0": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+    "string-width@^4.2.3": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+    "string_decoder@^1.1.1": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+    "strip-ansi@^6.0.0": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+    "strip-ansi@^6.0.1": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+    "strip-final-newline@^2.0.0": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
+    "strip-final-newline@^3.0.0": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
+    "sucrase@^3.32.0": "https://registry.npmjs.org/sucrase/-/sucrase-3.32.0.tgz",
+    "supports-color@^7.1.0": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+    "supports-preserve-symlinks-flag@^1.0.0": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+    "swiper@^8.4.7": "https://registry.npmjs.org/swiper/-/swiper-8.4.7.tgz",
+    "synckit@^0.8.5": "https://registry.npmjs.org/synckit/-/synckit-0.8.5.tgz",
+    "tabbable@^5.3.3": "https://registry.npmjs.org/tabbable/-/tabbable-5.3.3.tgz",
+    "tailwindcss@^3.1.6": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.3.2.tgz",
+    "tailwindcss@^3.1.8": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.3.2.tgz",
+    "tailwindcss@^3.2.4": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.3.2.tgz",
+    "thenify-all@^1.0.0": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
+    "thenify@>= 3.1.0 < 4": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
+    "tinyglobby@^0.2.13": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+    "titleize@^3.0.0": "https://registry.npmjs.org/titleize/-/titleize-3.0.0.tgz",
+    "to-regex-range@^5.0.1": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+    "ts-interface-checker@^0.1.9": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
+    "tslib@^2.5.0": "https://registry.npmjs.org/tslib/-/tslib-2.5.3.tgz",
+    "turbolinks@^5.2.0": "https://registry.npmjs.org/turbolinks/-/turbolinks-5.2.0.tgz",
+    "typedarray@^0.0.6": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+    "untildify@^4.0.0": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz",
+    "update-browserslist-db@^1.1.1": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz",
+    "uri-js@^4.2.2": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+    "user-home@^2.0.0": "https://registry.npmjs.org/user-home/-/user-home-2.0.0.tgz",
+    "util-deprecate@^1.0.1": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+    "util-deprecate@^1.0.2": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+    "vite-plugin-full-reload@^1.1.0": "https://registry.npmjs.org/vite-plugin-full-reload/-/vite-plugin-full-reload-1.2.0.tgz",
+    "vite@^6.3.6": "https://registry.npmjs.org/vite/-/vite-6.3.6.tgz",
+    "vscode-oniguruma@1.7.0": "https://registry.npmjs.org/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz",
+    "vscode-textmate@^7.0.1": "https://registry.npmjs.org/vscode-textmate/-/vscode-textmate-7.0.4.tgz",
+    "which@^2.0.1": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+    "wrap-ansi@^7.0.0": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+    "wrappy@1": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+    "xregexp@^5.0.1": "https://registry.npmjs.org/xregexp/-/xregexp-5.1.1.tgz",
+    "y18n@^5.0.5": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+    "yallist@^2.1.2": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz",
+    "yallist@^4.0.0": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+    "yaml@^2.1.1": "https://registry.npmjs.org/yaml/-/yaml-2.8.1.tgz",
+    "yargs-parser@^21.1.1": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+    "yargs@^17.3.1": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz"
+  },
+  "files": [],
+  "artifacts": {}
+}

Optimized Atomcms daily updated/node_modules/@alloc/quick-lru/index.d.ts

@@ -0,0 +1,128 @@
+declare namespace QuickLRU {
+	interface Options<KeyType, ValueType> {
+		/**
+		The maximum number of milliseconds an item should remain in the cache.
+
+		@default Infinity
+
+		By default, `maxAge` will be `Infinity`, which means that items will never expire.
+		Lazy expiration upon the next write or read call.
+
+		Individual expiration of an item can be specified by the `set(key, value, maxAge)` method.
+		*/
+		readonly maxAge?: number;
+
+		/**
+		The maximum number of items before evicting the least recently used items.
+		*/
+		readonly maxSize: number;
+
+		/**
+		Called right before an item is evicted from the cache.
+
+		Useful for side effects or for items like object URLs that need explicit cleanup (`revokeObjectURL`).
+		*/
+		onEviction?: (key: KeyType, value: ValueType) => void;
+	}
+}
+
+declare class QuickLRU<KeyType, ValueType>
+	implements Iterable<[KeyType, ValueType]> {
+	/**
+	The stored item count.
+	*/
+	readonly size: number;
+
+	/**
+	Simple ["Least Recently Used" (LRU) cache](https://en.m.wikipedia.org/wiki/Cache_replacement_policies#Least_Recently_Used_.28LRU.29).
+
+	The instance is [`iterable`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols) so you can use it directly in a [`for…of`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/for...of) loop.
+
+	@example
+	```
+	import QuickLRU = require('quick-lru');
+
+	const lru = new QuickLRU({maxSize: 1000});
+
+	lru.set('🦄', '🌈');
+
+	lru.has('🦄');
+	//=> true
+
+	lru.get('🦄');
+	//=> '🌈'
+	```
+	*/
+	constructor(options: QuickLRU.Options<KeyType, ValueType>);
+
+	[Symbol.iterator](): IterableIterator<[KeyType, ValueType]>;
+
+	/**
+	Set an item. Returns the instance.
+
+	Individual expiration of an item can be specified with the `maxAge` option. If not specified, the global `maxAge` value will be used in case it is specified in the constructor, otherwise the item will never expire.
+
+	@returns The list instance.
+	*/
+	set(key: KeyType, value: ValueType, options?: {maxAge?: number}): this;
+
+	/**
+	Get an item.
+
+	@returns The stored item or `undefined`.
+	*/
+	get(key: KeyType): ValueType | undefined;
+
+	/**
+	Check if an item exists.
+	*/
+	has(key: KeyType): boolean;
+
+	/**
+	Get an item without marking it as recently used.
+
+	@returns The stored item or `undefined`.
+	*/
+	peek(key: KeyType): ValueType | undefined;
+
+	/**
+	Delete an item.
+
+	@returns `true` if the item is removed or `false` if the item doesn't exist.
+	*/
+	delete(key: KeyType): boolean;
+
+	/**
+	Delete all items.
+	*/
+	clear(): void;
+
+	/**
+	Update the `maxSize` in-place, discarding items as necessary. Insertion order is mostly preserved, though this is not a strong guarantee.
+
+	Useful for on-the-fly tuning of cache sizes in live systems.
+	*/
+	resize(maxSize: number): void;
+
+	/**
+	Iterable for all the keys.
+	*/
+	keys(): IterableIterator<KeyType>;
+
+	/**
+	Iterable for all the values.
+	*/
+	values(): IterableIterator<ValueType>;
+
+	/**
+	Iterable for all entries, starting with the oldest (ascending in recency).
+	*/
+	entriesAscending(): IterableIterator<[KeyType, ValueType]>;
+
+	/**
+	Iterable for all entries, starting with the newest (descending in recency).
+	*/
+	entriesDescending(): IterableIterator<[KeyType, ValueType]>;
+}
+
+export = QuickLRU;

Optimized Atomcms daily updated/node_modules/@alloc/quick-lru/index.js

@@ -0,0 +1,263 @@
+'use strict';
+
+class QuickLRU {
+	constructor(options = {}) {
+		if (!(options.maxSize && options.maxSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
+		}
+
+		if (typeof options.maxAge === 'number' && options.maxAge === 0) {
+			throw new TypeError('`maxAge` must be a number greater than 0');
+		}
+
+		this.maxSize = options.maxSize;
+		this.maxAge = options.maxAge || Infinity;
+		this.onEviction = options.onEviction;
+		this.cache = new Map();
+		this.oldCache = new Map();
+		this._size = 0;
+	}
+
+	_emitEvictions(cache) {
+		if (typeof this.onEviction !== 'function') {
+			return;
+		}
+
+		for (const [key, item] of cache) {
+			this.onEviction(key, item.value);
+		}
+	}
+
+	_deleteIfExpired(key, item) {
+		if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
+			if (typeof this.onEviction === 'function') {
+				this.onEviction(key, item.value);
+			}
+
+			return this.delete(key);
+		}
+
+		return false;
+	}
+
+	_getOrDeleteIfExpired(key, item) {
+		const deleted = this._deleteIfExpired(key, item);
+		if (deleted === false) {
+			return item.value;
+		}
+	}
+
+	_getItemValue(key, item) {
+		return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
+	}
+
+	_peek(key, cache) {
+		const item = cache.get(key);
+
+		return this._getItemValue(key, item);
+	}
+
+	_set(key, value) {
+		this.cache.set(key, value);
+		this._size++;
+
+		if (this._size >= this.maxSize) {
+			this._size = 0;
+			this._emitEvictions(this.oldCache);
+			this.oldCache = this.cache;
+			this.cache = new Map();
+		}
+	}
+
+	_moveToRecent(key, item) {
+		this.oldCache.delete(key);
+		this._set(key, item);
+	}
+
+	* _entriesAscending() {
+		for (const item of this.oldCache) {
+			const [key, value] = item;
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield item;
+				}
+			}
+		}
+
+		for (const item of this.cache) {
+			const [key, value] = item;
+			const deleted = this._deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield item;
+			}
+		}
+	}
+
+	get(key) {
+		if (this.cache.has(key)) {
+			const item = this.cache.get(key);
+
+			return this._getItemValue(key, item);
+		}
+
+		if (this.oldCache.has(key)) {
+			const item = this.oldCache.get(key);
+			if (this._deleteIfExpired(key, item) === false) {
+				this._moveToRecent(key, item);
+				return item.value;
+			}
+		}
+	}
+
+	set(key, value, {maxAge = this.maxAge === Infinity ? undefined : Date.now() + this.maxAge} = {}) {
+		if (this.cache.has(key)) {
+			this.cache.set(key, {
+				value,
+				maxAge
+			});
+		} else {
+			this._set(key, {value, expiry: maxAge});
+		}
+	}
+
+	has(key) {
+		if (this.cache.has(key)) {
+			return !this._deleteIfExpired(key, this.cache.get(key));
+		}
+
+		if (this.oldCache.has(key)) {
+			return !this._deleteIfExpired(key, this.oldCache.get(key));
+		}
+
+		return false;
+	}
+
+	peek(key) {
+		if (this.cache.has(key)) {
+			return this._peek(key, this.cache);
+		}
+
+		if (this.oldCache.has(key)) {
+			return this._peek(key, this.oldCache);
+		}
+	}
+
+	delete(key) {
+		const deleted = this.cache.delete(key);
+		if (deleted) {
+			this._size--;
+		}
+
+		return this.oldCache.delete(key) || deleted;
+	}
+
+	clear() {
+		this.cache.clear();
+		this.oldCache.clear();
+		this._size = 0;
+	}
+	
+	resize(newSize) {
+		if (!(newSize && newSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
+		}
+
+		const items = [...this._entriesAscending()];
+		const removeCount = items.length - newSize;
+		if (removeCount < 0) {
+			this.cache = new Map(items);
+			this.oldCache = new Map();
+			this._size = items.length;
+		} else {
+			if (removeCount > 0) {
+				this._emitEvictions(items.slice(0, removeCount));
+			}
+
+			this.oldCache = new Map(items.slice(removeCount));
+			this.cache = new Map();
+			this._size = 0;
+		}
+
+		this.maxSize = newSize;
+	}
+
+	* keys() {
+		for (const [key] of this) {
+			yield key;
+		}
+	}
+
+	* values() {
+		for (const [, value] of this) {
+			yield value;
+		}
+	}
+
+	* [Symbol.iterator]() {
+		for (const item of this.cache) {
+			const [key, value] = item;
+			const deleted = this._deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield [key, value.value];
+			}
+		}
+
+		for (const item of this.oldCache) {
+			const [key, value] = item;
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield [key, value.value];
+				}
+			}
+		}
+	}
+
+	* entriesDescending() {
+		let items = [...this.cache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const item = items[i];
+			const [key, value] = item;
+			const deleted = this._deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield [key, value.value];
+			}
+		}
+
+		items = [...this.oldCache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const item = items[i];
+			const [key, value] = item;
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield [key, value.value];
+				}
+			}
+		}
+	}
+
+	* entriesAscending() {
+		for (const [key, value] of this._entriesAscending()) {
+			yield [key, value.value];
+		}
+	}
+
+	get size() {
+		if (!this._size) {
+			return this.oldCache.size;
+		}
+
+		let oldCacheSize = 0;
+		for (const key of this.oldCache.keys()) {
+			if (!this.cache.has(key)) {
+				oldCacheSize++;
+			}
+		}
+
+		return Math.min(this._size + oldCacheSize, this.maxSize);
+	}
+}
+
+module.exports = QuickLRU;

Optimized Atomcms daily updated/node_modules/@alloc/quick-lru/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Optimized Atomcms daily updated/node_modules/@alloc/quick-lru/package.json

@@ -0,0 +1,43 @@
+{
+	"name": "@alloc/quick-lru",
+	"version": "5.2.0",
+	"description": "Simple “Least Recently Used” (LRU) cache",
+	"license": "MIT",
+	"repository": "sindresorhus/quick-lru",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=10"
+	},
+	"scripts": {
+		"test": "xo && nyc ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"lru",
+		"quick",
+		"cache",
+		"caching",
+		"least",
+		"recently",
+		"used",
+		"fast",
+		"map",
+		"hash",
+		"buffer"
+	],
+	"devDependencies": {
+		"ava": "^2.0.0",
+		"coveralls": "^3.0.3",
+		"nyc": "^15.0.0",
+		"tsd": "^0.11.0",
+		"xo": "^0.26.0"
+	}
+}

Optimized Atomcms daily updated/node_modules/@alloc/quick-lru/readme.md

@@ -0,0 +1,139 @@
+# quick-lru [![Build Status](https://travis-ci.org/sindresorhus/quick-lru.svg?branch=master)](https://travis-ci.org/sindresorhus/quick-lru) [![Coverage Status](https://coveralls.io/repos/github/sindresorhus/quick-lru/badge.svg?branch=master)](https://coveralls.io/github/sindresorhus/quick-lru?branch=master)
+
+> Simple [“Least Recently Used” (LRU) cache](https://en.m.wikipedia.org/wiki/Cache_replacement_policies#Least_Recently_Used_.28LRU.29)
+
+Useful when you need to cache something and limit memory usage.
+
+Inspired by the [`hashlru` algorithm](https://github.com/dominictarr/hashlru#algorithm), but instead uses [`Map`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Map) to support keys of any type, not just strings, and values can be `undefined`.
+
+## Install
+
+```
+$ npm install quick-lru
+```
+
+## Usage
+
+```js
+const QuickLRU = require('quick-lru');
+
+const lru = new QuickLRU({maxSize: 1000});
+
+lru.set('🦄', '🌈');
+
+lru.has('🦄');
+//=> true
+
+lru.get('🦄');
+//=> '🌈'
+```
+
+## API
+
+### new QuickLRU(options?)
+
+Returns a new instance.
+
+### options
+
+Type: `object`
+
+#### maxSize
+
+*Required*\
+Type: `number`
+
+The maximum number of items before evicting the least recently used items.
+
+#### maxAge
+
+Type: `number`\
+Default: `Infinity`
+
+The maximum number of milliseconds an item should remain in cache.
+By default maxAge will be Infinity, which means that items will never expire.
+
+Lazy expiration happens upon the next `write` or `read` call.
+
+Individual expiration of an item can be specified by the `set(key, value, options)` method.
+
+#### onEviction
+
+*Optional*\
+Type: `(key, value) => void`
+
+Called right before an item is evicted from the cache.
+
+Useful for side effects or for items like object URLs that need explicit cleanup (`revokeObjectURL`).
+
+### Instance
+
+The instance is [`iterable`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols) so you can use it directly in a [`for…of`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/for...of) loop.
+
+Both `key` and `value` can be of any type.
+
+#### .set(key, value, options?)
+
+Set an item. Returns the instance.
+
+Individual expiration of an item can be specified with the `maxAge` option. If not specified, the global `maxAge` value will be used in case it is specified on the constructor, otherwise the item will never expire.
+
+#### .get(key)
+
+Get an item.
+
+#### .has(key)
+
+Check if an item exists.
+
+#### .peek(key)
+
+Get an item without marking it as recently used.
+
+#### .delete(key)
+
+Delete an item.
+
+Returns `true` if the item is removed or `false` if the item doesn't exist.
+
+#### .clear()
+
+Delete all items.
+
+#### .resize(maxSize)
+
+Update the `maxSize`, discarding items as necessary. Insertion order is mostly preserved, though this is not a strong guarantee.
+
+Useful for on-the-fly tuning of cache sizes in live systems.
+
+#### .keys()
+
+Iterable for all the keys.
+
+#### .values()
+
+Iterable for all the values.
+
+#### .entriesAscending()
+
+Iterable for all entries, starting with the oldest (ascending in recency).
+
+#### .entriesDescending()
+
+Iterable for all entries, starting with the newest (descending in recency).
+
+#### .size
+
+The stored item count.
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-quick-lru?utm_source=npm-quick-lru&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>

Optimized Atomcms daily updated/node_modules/@alpinejs/focus/builds/cdn.js

@@ -0,0 +1,5 @@
+import trap from '../src/index.js'
+
+document.addEventListener('alpine:init', () => {
+    window.Alpine.plugin(trap)
+})

Optimized Atomcms daily updated/node_modules/@alpinejs/focus/builds/module.js

@@ -0,0 +1,3 @@
+import registerFocusPlugin from '../src/index.js'
+
+export default registerFocusPlugin

Optimized Atomcms daily updated/node_modules/@alpinejs/focus/dist/cdn.js

@@ -0,0 +1,827 @@
+(() => {
+  // node_modules/tabbable/dist/index.esm.js
+  /*!
+  * tabbable 5.2.1
+  * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+  */
+  var candidateSelectors = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])', "details>summary:first-of-type", "details"];
+  var candidateSelector = /* @__PURE__ */ candidateSelectors.join(",");
+  var matches = typeof Element === "undefined" ? function() {
+  } : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+  var getCandidates = function getCandidates2(el, includeContainer, filter) {
+    var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+    if (includeContainer && matches.call(el, candidateSelector)) {
+      candidates.unshift(el);
+    }
+    candidates = candidates.filter(filter);
+    return candidates;
+  };
+  var isContentEditable = function isContentEditable2(node) {
+    return node.contentEditable === "true";
+  };
+  var getTabindex = function getTabindex2(node) {
+    var tabindexAttr = parseInt(node.getAttribute("tabindex"), 10);
+    if (!isNaN(tabindexAttr)) {
+      return tabindexAttr;
+    }
+    if (isContentEditable(node)) {
+      return 0;
+    }
+    if ((node.nodeName === "AUDIO" || node.nodeName === "VIDEO" || node.nodeName === "DETAILS") && node.getAttribute("tabindex") === null) {
+      return 0;
+    }
+    return node.tabIndex;
+  };
+  var sortOrderedTabbables = function sortOrderedTabbables2(a, b) {
+    return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+  };
+  var isInput = function isInput2(node) {
+    return node.tagName === "INPUT";
+  };
+  var isHiddenInput = function isHiddenInput2(node) {
+    return isInput(node) && node.type === "hidden";
+  };
+  var isDetailsWithSummary = function isDetailsWithSummary2(node) {
+    var r = node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+      return child.tagName === "SUMMARY";
+    });
+    return r;
+  };
+  var getCheckedRadio = function getCheckedRadio2(nodes, form) {
+    for (var i = 0; i < nodes.length; i++) {
+      if (nodes[i].checked && nodes[i].form === form) {
+        return nodes[i];
+      }
+    }
+  };
+  var isTabbableRadio = function isTabbableRadio2(node) {
+    if (!node.name) {
+      return true;
+    }
+    var radioScope = node.form || node.ownerDocument;
+    var queryRadios = function queryRadios2(name) {
+      return radioScope.querySelectorAll('input[type="radio"][name="' + name + '"]');
+    };
+    var radioSet;
+    if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") {
+      radioSet = queryRadios(window.CSS.escape(node.name));
+    } else {
+      try {
+        radioSet = queryRadios(node.name);
+      } catch (err) {
+        console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+        return false;
+      }
+    }
+    var checked = getCheckedRadio(radioSet, node.form);
+    return !checked || checked === node;
+  };
+  var isRadio = function isRadio2(node) {
+    return isInput(node) && node.type === "radio";
+  };
+  var isNonTabbableRadio = function isNonTabbableRadio2(node) {
+    return isRadio(node) && !isTabbableRadio(node);
+  };
+  var isHidden = function isHidden2(node, displayCheck) {
+    if (getComputedStyle(node).visibility === "hidden") {
+      return true;
+    }
+    var isDirectSummary = matches.call(node, "details>summary:first-of-type");
+    var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
+    if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
+      return true;
+    }
+    if (!displayCheck || displayCheck === "full") {
+      while (node) {
+        if (getComputedStyle(node).display === "none") {
+          return true;
+        }
+        node = node.parentElement;
+      }
+    } else if (displayCheck === "non-zero-area") {
+      var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+      return width === 0 && height === 0;
+    }
+    return false;
+  };
+  var isDisabledFromFieldset = function isDisabledFromFieldset2(node) {
+    if (isInput(node) || node.tagName === "SELECT" || node.tagName === "TEXTAREA" || node.tagName === "BUTTON") {
+      var parentNode = node.parentElement;
+      while (parentNode) {
+        if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+          for (var i = 0; i < parentNode.children.length; i++) {
+            var child = parentNode.children.item(i);
+            if (child.tagName === "LEGEND") {
+              if (child.contains(node)) {
+                return false;
+              }
+              return true;
+            }
+          }
+          return true;
+        }
+        parentNode = parentNode.parentElement;
+      }
+    }
+    return false;
+  };
+  var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable2(options, node) {
+    if (node.disabled || isHiddenInput(node) || isHidden(node, options.displayCheck) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
+      return false;
+    }
+    return true;
+  };
+  var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable2(options, node) {
+    if (!isNodeMatchingSelectorFocusable(options, node) || isNonTabbableRadio(node) || getTabindex(node) < 0) {
+      return false;
+    }
+    return true;
+  };
+  var tabbable = function tabbable2(el, options) {
+    options = options || {};
+    var regularTabbables = [];
+    var orderedTabbables = [];
+    var candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+    candidates.forEach(function(candidate, i) {
+      var candidateTabindex = getTabindex(candidate);
+      if (candidateTabindex === 0) {
+        regularTabbables.push(candidate);
+      } else {
+        orderedTabbables.push({
+          documentOrder: i,
+          tabIndex: candidateTabindex,
+          node: candidate
+        });
+      }
+    });
+    var tabbableNodes = orderedTabbables.sort(sortOrderedTabbables).map(function(a) {
+      return a.node;
+    }).concat(regularTabbables);
+    return tabbableNodes;
+  };
+  var focusable = function focusable2(el, options) {
+    options = options || {};
+    var candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+    return candidates;
+  };
+  var focusableCandidateSelector = /* @__PURE__ */ candidateSelectors.concat("iframe").join(",");
+  var isFocusable = function isFocusable2(node, options) {
+    options = options || {};
+    if (!node) {
+      throw new Error("No node provided");
+    }
+    if (matches.call(node, focusableCandidateSelector) === false) {
+      return false;
+    }
+    return isNodeMatchingSelectorFocusable(options, node);
+  };
+
+  // node_modules/focus-trap/dist/focus-trap.esm.js
+  /*!
+  * focus-trap 6.6.1
+  * @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
+  */
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      if (enumerableOnly) {
+        symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+      }
+      keys.push.apply(keys, symbols);
+    }
+    return keys;
+  }
+  function _objectSpread2(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i] != null ? arguments[i] : {};
+      if (i % 2) {
+        ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        });
+      } else if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+      } else {
+        ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+    }
+    return target;
+  }
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  var activeFocusTraps = function() {
+    var trapQueue = [];
+    return {
+      activateTrap: function activateTrap(trap) {
+        if (trapQueue.length > 0) {
+          var activeTrap = trapQueue[trapQueue.length - 1];
+          if (activeTrap !== trap) {
+            activeTrap.pause();
+          }
+        }
+        var trapIndex = trapQueue.indexOf(trap);
+        if (trapIndex === -1) {
+          trapQueue.push(trap);
+        } else {
+          trapQueue.splice(trapIndex, 1);
+          trapQueue.push(trap);
+        }
+      },
+      deactivateTrap: function deactivateTrap(trap) {
+        var trapIndex = trapQueue.indexOf(trap);
+        if (trapIndex !== -1) {
+          trapQueue.splice(trapIndex, 1);
+        }
+        if (trapQueue.length > 0) {
+          trapQueue[trapQueue.length - 1].unpause();
+        }
+      }
+    };
+  }();
+  var isSelectableInput = function isSelectableInput2(node) {
+    return node.tagName && node.tagName.toLowerCase() === "input" && typeof node.select === "function";
+  };
+  var isEscapeEvent = function isEscapeEvent2(e) {
+    return e.key === "Escape" || e.key === "Esc" || e.keyCode === 27;
+  };
+  var isTabEvent = function isTabEvent2(e) {
+    return e.key === "Tab" || e.keyCode === 9;
+  };
+  var delay = function delay2(fn) {
+    return setTimeout(fn, 0);
+  };
+  var findIndex = function findIndex2(arr, fn) {
+    var idx = -1;
+    arr.every(function(value, i) {
+      if (fn(value)) {
+        idx = i;
+        return false;
+      }
+      return true;
+    });
+    return idx;
+  };
+  var valueOrHandler = function valueOrHandler2(value) {
+    for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      params[_key - 1] = arguments[_key];
+    }
+    return typeof value === "function" ? value.apply(void 0, params) : value;
+  };
+  var createFocusTrap = function createFocusTrap2(elements, userOptions) {
+    var doc = document;
+    var config = _objectSpread2({
+      returnFocusOnDeactivate: true,
+      escapeDeactivates: true,
+      delayInitialFocus: true
+    }, userOptions);
+    var state = {
+      containers: [],
+      tabbableGroups: [],
+      nodeFocusedBeforeActivation: null,
+      mostRecentlyFocusedNode: null,
+      active: false,
+      paused: false,
+      delayInitialFocusTimer: void 0
+    };
+    var trap;
+    var getOption = function getOption2(configOverrideOptions, optionName, configOptionName) {
+      return configOverrideOptions && configOverrideOptions[optionName] !== void 0 ? configOverrideOptions[optionName] : config[configOptionName || optionName];
+    };
+    var containersContain = function containersContain2(element) {
+      return state.containers.some(function(container) {
+        return container.contains(element);
+      });
+    };
+    var getNodeForOption = function getNodeForOption2(optionName) {
+      var optionValue = config[optionName];
+      if (!optionValue) {
+        return null;
+      }
+      var node = optionValue;
+      if (typeof optionValue === "string") {
+        node = doc.querySelector(optionValue);
+        if (!node) {
+          throw new Error("`".concat(optionName, "` refers to no known node"));
+        }
+      }
+      if (typeof optionValue === "function") {
+        node = optionValue();
+        if (!node) {
+          throw new Error("`".concat(optionName, "` did not return a node"));
+        }
+      }
+      return node;
+    };
+    var getInitialFocusNode = function getInitialFocusNode2() {
+      var node;
+      if (getOption({}, "initialFocus") === false) {
+        return false;
+      }
+      if (getNodeForOption("initialFocus") !== null) {
+        node = getNodeForOption("initialFocus");
+      } else if (containersContain(doc.activeElement)) {
+        node = doc.activeElement;
+      } else {
+        var firstTabbableGroup = state.tabbableGroups[0];
+        var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;
+        node = firstTabbableNode || getNodeForOption("fallbackFocus");
+      }
+      if (!node) {
+        throw new Error("Your focus-trap needs to have at least one focusable element");
+      }
+      return node;
+    };
+    var updateTabbableNodes = function updateTabbableNodes2() {
+      state.tabbableGroups = state.containers.map(function(container) {
+        var tabbableNodes = tabbable(container);
+        if (tabbableNodes.length > 0) {
+          return {
+            container,
+            firstTabbableNode: tabbableNodes[0],
+            lastTabbableNode: tabbableNodes[tabbableNodes.length - 1]
+          };
+        }
+        return void 0;
+      }).filter(function(group) {
+        return !!group;
+      });
+      if (state.tabbableGroups.length <= 0 && !getNodeForOption("fallbackFocus")) {
+        throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
+      }
+    };
+    var tryFocus = function tryFocus2(node) {
+      if (node === false) {
+        return;
+      }
+      if (node === doc.activeElement) {
+        return;
+      }
+      if (!node || !node.focus) {
+        tryFocus2(getInitialFocusNode());
+        return;
+      }
+      node.focus({
+        preventScroll: !!config.preventScroll
+      });
+      state.mostRecentlyFocusedNode = node;
+      if (isSelectableInput(node)) {
+        node.select();
+      }
+    };
+    var getReturnFocusNode = function getReturnFocusNode2(previousActiveElement) {
+      var node = getNodeForOption("setReturnFocus");
+      return node ? node : previousActiveElement;
+    };
+    var checkPointerDown = function checkPointerDown2(e) {
+      if (containersContain(e.target)) {
+        return;
+      }
+      if (valueOrHandler(config.clickOutsideDeactivates, e)) {
+        trap.deactivate({
+          returnFocus: config.returnFocusOnDeactivate && !isFocusable(e.target)
+        });
+        return;
+      }
+      if (valueOrHandler(config.allowOutsideClick, e)) {
+        return;
+      }
+      e.preventDefault();
+    };
+    var checkFocusIn = function checkFocusIn2(e) {
+      var targetContained = containersContain(e.target);
+      if (targetContained || e.target instanceof Document) {
+        if (targetContained) {
+          state.mostRecentlyFocusedNode = e.target;
+        }
+      } else {
+        e.stopImmediatePropagation();
+        tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());
+      }
+    };
+    var checkTab = function checkTab2(e) {
+      updateTabbableNodes();
+      var destinationNode = null;
+      if (state.tabbableGroups.length > 0) {
+        var containerIndex = findIndex(state.tabbableGroups, function(_ref) {
+          var container = _ref.container;
+          return container.contains(e.target);
+        });
+        if (containerIndex < 0) {
+          if (e.shiftKey) {
+            destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;
+          } else {
+            destinationNode = state.tabbableGroups[0].firstTabbableNode;
+          }
+        } else if (e.shiftKey) {
+          var startOfGroupIndex = findIndex(state.tabbableGroups, function(_ref2) {
+            var firstTabbableNode = _ref2.firstTabbableNode;
+            return e.target === firstTabbableNode;
+          });
+          if (startOfGroupIndex < 0 && state.tabbableGroups[containerIndex].container === e.target) {
+            startOfGroupIndex = containerIndex;
+          }
+          if (startOfGroupIndex >= 0) {
+            var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;
+            var destinationGroup = state.tabbableGroups[destinationGroupIndex];
+            destinationNode = destinationGroup.lastTabbableNode;
+          }
+        } else {
+          var lastOfGroupIndex = findIndex(state.tabbableGroups, function(_ref3) {
+            var lastTabbableNode = _ref3.lastTabbableNode;
+            return e.target === lastTabbableNode;
+          });
+          if (lastOfGroupIndex < 0 && state.tabbableGroups[containerIndex].container === e.target) {
+            lastOfGroupIndex = containerIndex;
+          }
+          if (lastOfGroupIndex >= 0) {
+            var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;
+            var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];
+            destinationNode = _destinationGroup.firstTabbableNode;
+          }
+        }
+      } else {
+        destinationNode = getNodeForOption("fallbackFocus");
+      }
+      if (destinationNode) {
+        e.preventDefault();
+        tryFocus(destinationNode);
+      }
+    };
+    var checkKey = function checkKey2(e) {
+      if (isEscapeEvent(e) && valueOrHandler(config.escapeDeactivates) !== false) {
+        e.preventDefault();
+        trap.deactivate();
+        return;
+      }
+      if (isTabEvent(e)) {
+        checkTab(e);
+        return;
+      }
+    };
+    var checkClick = function checkClick2(e) {
+      if (valueOrHandler(config.clickOutsideDeactivates, e)) {
+        return;
+      }
+      if (containersContain(e.target)) {
+        return;
+      }
+      if (valueOrHandler(config.allowOutsideClick, e)) {
+        return;
+      }
+      e.preventDefault();
+      e.stopImmediatePropagation();
+    };
+    var addListeners = function addListeners2() {
+      if (!state.active) {
+        return;
+      }
+      activeFocusTraps.activateTrap(trap);
+      state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function() {
+        tryFocus(getInitialFocusNode());
+      }) : tryFocus(getInitialFocusNode());
+      doc.addEventListener("focusin", checkFocusIn, true);
+      doc.addEventListener("mousedown", checkPointerDown, {
+        capture: true,
+        passive: false
+      });
+      doc.addEventListener("touchstart", checkPointerDown, {
+        capture: true,
+        passive: false
+      });
+      doc.addEventListener("click", checkClick, {
+        capture: true,
+        passive: false
+      });
+      doc.addEventListener("keydown", checkKey, {
+        capture: true,
+        passive: false
+      });
+      return trap;
+    };
+    var removeListeners = function removeListeners2() {
+      if (!state.active) {
+        return;
+      }
+      doc.removeEventListener("focusin", checkFocusIn, true);
+      doc.removeEventListener("mousedown", checkPointerDown, true);
+      doc.removeEventListener("touchstart", checkPointerDown, true);
+      doc.removeEventListener("click", checkClick, true);
+      doc.removeEventListener("keydown", checkKey, true);
+      return trap;
+    };
+    trap = {
+      activate: function activate(activateOptions) {
+        if (state.active) {
+          return this;
+        }
+        var onActivate = getOption(activateOptions, "onActivate");
+        var onPostActivate = getOption(activateOptions, "onPostActivate");
+        var checkCanFocusTrap = getOption(activateOptions, "checkCanFocusTrap");
+        if (!checkCanFocusTrap) {
+          updateTabbableNodes();
+        }
+        state.active = true;
+        state.paused = false;
+        state.nodeFocusedBeforeActivation = doc.activeElement;
+        if (onActivate) {
+          onActivate();
+        }
+        var finishActivation = function finishActivation2() {
+          if (checkCanFocusTrap) {
+            updateTabbableNodes();
+          }
+          addListeners();
+          if (onPostActivate) {
+            onPostActivate();
+          }
+        };
+        if (checkCanFocusTrap) {
+          checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);
+          return this;
+        }
+        finishActivation();
+        return this;
+      },
+      deactivate: function deactivate(deactivateOptions) {
+        if (!state.active) {
+          return this;
+        }
+        clearTimeout(state.delayInitialFocusTimer);
+        state.delayInitialFocusTimer = void 0;
+        removeListeners();
+        state.active = false;
+        state.paused = false;
+        activeFocusTraps.deactivateTrap(trap);
+        var onDeactivate = getOption(deactivateOptions, "onDeactivate");
+        var onPostDeactivate = getOption(deactivateOptions, "onPostDeactivate");
+        var checkCanReturnFocus = getOption(deactivateOptions, "checkCanReturnFocus");
+        if (onDeactivate) {
+          onDeactivate();
+        }
+        var returnFocus = getOption(deactivateOptions, "returnFocus", "returnFocusOnDeactivate");
+        var finishDeactivation = function finishDeactivation2() {
+          delay(function() {
+            if (returnFocus) {
+              tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));
+            }
+            if (onPostDeactivate) {
+              onPostDeactivate();
+            }
+          });
+        };
+        if (returnFocus && checkCanReturnFocus) {
+          checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);
+          return this;
+        }
+        finishDeactivation();
+        return this;
+      },
+      pause: function pause() {
+        if (state.paused || !state.active) {
+          return this;
+        }
+        state.paused = true;
+        removeListeners();
+        return this;
+      },
+      unpause: function unpause() {
+        if (!state.paused || !state.active) {
+          return this;
+        }
+        state.paused = false;
+        updateTabbableNodes();
+        addListeners();
+        return this;
+      },
+      updateContainerElements: function updateContainerElements(containerElements) {
+        var elementsAsArray = [].concat(containerElements).filter(Boolean);
+        state.containers = elementsAsArray.map(function(element) {
+          return typeof element === "string" ? doc.querySelector(element) : element;
+        });
+        if (state.active) {
+          updateTabbableNodes();
+        }
+        return this;
+      }
+    };
+    trap.updateContainerElements(elements);
+    return trap;
+  };
+
+  // packages/focus/src/index.js
+  function src_default(Alpine) {
+    let lastFocused;
+    let currentFocused;
+    window.addEventListener("focusin", () => {
+      lastFocused = currentFocused;
+      currentFocused = document.activeElement;
+    });
+    Alpine.magic("focus", (el) => {
+      let within = el;
+      return {
+        __noscroll: false,
+        __wrapAround: false,
+        within(el2) {
+          within = el2;
+          return this;
+        },
+        withoutScrolling() {
+          this.__noscroll = true;
+          return this;
+        },
+        noscroll() {
+          this.__noscroll = true;
+          return this;
+        },
+        withWrapAround() {
+          this.__wrapAround = true;
+          return this;
+        },
+        wrap() {
+          return this.withWrapAround();
+        },
+        focusable(el2) {
+          return isFocusable(el2);
+        },
+        previouslyFocused() {
+          return lastFocused;
+        },
+        lastFocused() {
+          return lastFocused;
+        },
+        focused() {
+          return currentFocused;
+        },
+        focusables() {
+          if (Array.isArray(within))
+            return within;
+          return focusable(within, {displayCheck: "none"});
+        },
+        all() {
+          return this.focusables();
+        },
+        isFirst(el2) {
+          let els = this.all();
+          return els[0] && els[0].isSameNode(el2);
+        },
+        isLast(el2) {
+          let els = this.all();
+          return els.length && els.slice(-1)[0].isSameNode(el2);
+        },
+        getFirst() {
+          return this.all()[0];
+        },
+        getLast() {
+          return this.all().slice(-1)[0];
+        },
+        getNext() {
+          let list = this.all();
+          let current = document.activeElement;
+          if (list.indexOf(current) === -1)
+            return;
+          if (this.__wrapAround && list.indexOf(current) === list.length - 1) {
+            return list[0];
+          }
+          return list[list.indexOf(current) + 1];
+        },
+        getPrevious() {
+          let list = this.all();
+          let current = document.activeElement;
+          if (list.indexOf(current) === -1)
+            return;
+          if (this.__wrapAround && list.indexOf(current) === 0) {
+            return list.slice(-1)[0];
+          }
+          return list[list.indexOf(current) - 1];
+        },
+        first() {
+          this.focus(this.getFirst());
+        },
+        last() {
+          this.focus(this.getLast());
+        },
+        next() {
+          this.focus(this.getNext());
+        },
+        previous() {
+          this.focus(this.getPrevious());
+        },
+        prev() {
+          return this.previous();
+        },
+        focus(el2) {
+          if (!el2)
+            return;
+          setTimeout(() => {
+            if (!el2.hasAttribute("tabindex"))
+              el2.setAttribute("tabindex", "0");
+            el2.focus({preventScroll: this._noscroll});
+          });
+        }
+      };
+    });
+    Alpine.directive("trap", Alpine.skipDuringClone((el, {expression, modifiers}, {effect, evaluateLater, cleanup}) => {
+      let evaluator = evaluateLater(expression);
+      let oldValue = false;
+      let options = {
+        escapeDeactivates: false,
+        allowOutsideClick: true,
+        fallbackFocus: () => el
+      };
+      let autofocusEl = el.querySelector("[autofocus]");
+      if (autofocusEl)
+        options.initialFocus = autofocusEl;
+      let trap = createFocusTrap(el, options);
+      let undoInert = () => {
+      };
+      let undoDisableScrolling = () => {
+      };
+      const releaseFocus = () => {
+        undoInert();
+        undoInert = () => {
+        };
+        undoDisableScrolling();
+        undoDisableScrolling = () => {
+        };
+        trap.deactivate({
+          returnFocus: !modifiers.includes("noreturn")
+        });
+      };
+      effect(() => evaluator((value) => {
+        if (oldValue === value)
+          return;
+        if (value && !oldValue) {
+          setTimeout(() => {
+            if (modifiers.includes("inert"))
+              undoInert = setInert(el);
+            if (modifiers.includes("noscroll"))
+              undoDisableScrolling = disableScrolling();
+            trap.activate();
+          });
+        }
+        if (!value && oldValue) {
+          releaseFocus();
+        }
+        oldValue = !!value;
+      }));
+      cleanup(releaseFocus);
+    }, (el, {expression, modifiers}, {evaluate}) => {
+      if (modifiers.includes("inert") && evaluate(expression))
+        setInert(el);
+    }));
+  }
+  function setInert(el) {
+    let undos = [];
+    crawlSiblingsUp(el, (sibling) => {
+      let cache = sibling.hasAttribute("aria-hidden");
+      sibling.setAttribute("aria-hidden", "true");
+      undos.push(() => cache || sibling.removeAttribute("aria-hidden"));
+    });
+    return () => {
+      while (undos.length)
+        undos.pop()();
+    };
+  }
+  function crawlSiblingsUp(el, callback) {
+    if (el.isSameNode(document.body) || !el.parentNode)
+      return;
+    Array.from(el.parentNode.children).forEach((sibling) => {
+      if (sibling.isSameNode(el)) {
+        crawlSiblingsUp(el.parentNode, callback);
+      } else {
+        callback(sibling);
+      }
+    });
+  }
+  function disableScrolling() {
+    let overflow = document.documentElement.style.overflow;
+    let paddingRight = document.documentElement.style.paddingRight;
+    let scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+    document.documentElement.style.overflow = "hidden";
+    document.documentElement.style.paddingRight = `${scrollbarWidth}px`;
+    return () => {
+      document.documentElement.style.overflow = overflow;
+      document.documentElement.style.paddingRight = paddingRight;
+    };
+  }
+
+  // packages/focus/builds/cdn.js
+  document.addEventListener("alpine:init", () => {
+    window.Alpine.plugin(src_default);
+  });
+})();

Optimized Atomcms daily updated/node_modules/@alpinejs/focus/dist/module.cjs.js

@@ -0,0 +1,885 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __commonJS = (callback, module2) => () => {
+  if (!module2) {
+    module2 = {exports: {}};
+    callback(module2.exports, module2);
+  }
+  return module2.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// node_modules/tabbable/dist/index.js
+var require_dist = __commonJS((exports2) => {
+  /*!
+  * tabbable 5.2.1
+  * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+  */
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  var candidateSelectors = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])', "details>summary:first-of-type", "details"];
+  var candidateSelector = /* @__PURE__ */ candidateSelectors.join(",");
+  var matches = typeof Element === "undefined" ? function() {
+  } : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+  var getCandidates = function getCandidates2(el, includeContainer, filter) {
+    var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+    if (includeContainer && matches.call(el, candidateSelector)) {
+      candidates.unshift(el);
+    }
+    candidates = candidates.filter(filter);
+    return candidates;
+  };
+  var isContentEditable = function isContentEditable2(node) {
+    return node.contentEditable === "true";
+  };
+  var getTabindex = function getTabindex2(node) {
+    var tabindexAttr = parseInt(node.getAttribute("tabindex"), 10);
+    if (!isNaN(tabindexAttr)) {
+      return tabindexAttr;
+    }
+    if (isContentEditable(node)) {
+      return 0;
+    }
+    if ((node.nodeName === "AUDIO" || node.nodeName === "VIDEO" || node.nodeName === "DETAILS") && node.getAttribute("tabindex") === null) {
+      return 0;
+    }
+    return node.tabIndex;
+  };
+  var sortOrderedTabbables = function sortOrderedTabbables2(a, b) {
+    return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+  };
+  var isInput = function isInput2(node) {
+    return node.tagName === "INPUT";
+  };
+  var isHiddenInput = function isHiddenInput2(node) {
+    return isInput(node) && node.type === "hidden";
+  };
+  var isDetailsWithSummary = function isDetailsWithSummary2(node) {
+    var r = node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+      return child.tagName === "SUMMARY";
+    });
+    return r;
+  };
+  var getCheckedRadio = function getCheckedRadio2(nodes, form) {
+    for (var i = 0; i < nodes.length; i++) {
+      if (nodes[i].checked && nodes[i].form === form) {
+        return nodes[i];
+      }
+    }
+  };
+  var isTabbableRadio = function isTabbableRadio2(node) {
+    if (!node.name) {
+      return true;
+    }
+    var radioScope = node.form || node.ownerDocument;
+    var queryRadios = function queryRadios2(name) {
+      return radioScope.querySelectorAll('input[type="radio"][name="' + name + '"]');
+    };
+    var radioSet;
+    if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") {
+      radioSet = queryRadios(window.CSS.escape(node.name));
+    } else {
+      try {
+        radioSet = queryRadios(node.name);
+      } catch (err) {
+        console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+        return false;
+      }
+    }
+    var checked = getCheckedRadio(radioSet, node.form);
+    return !checked || checked === node;
+  };
+  var isRadio = function isRadio2(node) {
+    return isInput(node) && node.type === "radio";
+  };
+  var isNonTabbableRadio = function isNonTabbableRadio2(node) {
+    return isRadio(node) && !isTabbableRadio(node);
+  };
+  var isHidden = function isHidden2(node, displayCheck) {
+    if (getComputedStyle(node).visibility === "hidden") {
+      return true;
+    }
+    var isDirectSummary = matches.call(node, "details>summary:first-of-type");
+    var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
+    if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
+      return true;
+    }
+    if (!displayCheck || displayCheck === "full") {
+      while (node) {
+        if (getComputedStyle(node).display === "none") {
+          return true;
+        }
+        node = node.parentElement;
+      }
+    } else if (displayCheck === "non-zero-area") {
+      var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+      return width === 0 && height === 0;
+    }
+    return false;
+  };
+  var isDisabledFromFieldset = function isDisabledFromFieldset2(node) {
+    if (isInput(node) || node.tagName === "SELECT" || node.tagName === "TEXTAREA" || node.tagName === "BUTTON") {
+      var parentNode = node.parentElement;
+      while (parentNode) {
+        if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+          for (var i = 0; i < parentNode.children.length; i++) {
+            var child = parentNode.children.item(i);
+            if (child.tagName === "LEGEND") {
+              if (child.contains(node)) {
+                return false;
+              }
+              return true;
+            }
+          }
+          return true;
+        }
+        parentNode = parentNode.parentElement;
+      }
+    }
+    return false;
+  };
+  var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable2(options, node) {
+    if (node.disabled || isHiddenInput(node) || isHidden(node, options.displayCheck) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
+      return false;
+    }
+    return true;
+  };
+  var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable2(options, node) {
+    if (!isNodeMatchingSelectorFocusable(options, node) || isNonTabbableRadio(node) || getTabindex(node) < 0) {
+      return false;
+    }
+    return true;
+  };
+  var tabbable = function tabbable2(el, options) {
+    options = options || {};
+    var regularTabbables = [];
+    var orderedTabbables = [];
+    var candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+    candidates.forEach(function(candidate, i) {
+      var candidateTabindex = getTabindex(candidate);
+      if (candidateTabindex === 0) {
+        regularTabbables.push(candidate);
+      } else {
+        orderedTabbables.push({
+          documentOrder: i,
+          tabIndex: candidateTabindex,
+          node: candidate
+        });
+      }
+    });
+    var tabbableNodes = orderedTabbables.sort(sortOrderedTabbables).map(function(a) {
+      return a.node;
+    }).concat(regularTabbables);
+    return tabbableNodes;
+  };
+  var focusable2 = function focusable3(el, options) {
+    options = options || {};
+    var candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+    return candidates;
+  };
+  var isTabbable = function isTabbable2(node, options) {
+    options = options || {};
+    if (!node) {
+      throw new Error("No node provided");
+    }
+    if (matches.call(node, candidateSelector) === false) {
+      return false;
+    }
+    return isNodeMatchingSelectorTabbable(options, node);
+  };
+  var focusableCandidateSelector = /* @__PURE__ */ candidateSelectors.concat("iframe").join(",");
+  var isFocusable2 = function isFocusable3(node, options) {
+    options = options || {};
+    if (!node) {
+      throw new Error("No node provided");
+    }
+    if (matches.call(node, focusableCandidateSelector) === false) {
+      return false;
+    }
+    return isNodeMatchingSelectorFocusable(options, node);
+  };
+  exports2.focusable = focusable2;
+  exports2.isFocusable = isFocusable2;
+  exports2.isTabbable = isTabbable;
+  exports2.tabbable = tabbable;
+});
+
+// node_modules/focus-trap/dist/focus-trap.js
+var require_focus_trap = __commonJS((exports2) => {
+  /*!
+  * focus-trap 6.6.1
+  * @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
+  */
+  "use strict";
+  Object.defineProperty(exports2, "__esModule", {value: true});
+  var tabbable = require_dist();
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      if (enumerableOnly) {
+        symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+      }
+      keys.push.apply(keys, symbols);
+    }
+    return keys;
+  }
+  function _objectSpread2(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i] != null ? arguments[i] : {};
+      if (i % 2) {
+        ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        });
+      } else if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+      } else {
+        ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+    }
+    return target;
+  }
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  var activeFocusTraps = function() {
+    var trapQueue = [];
+    return {
+      activateTrap: function activateTrap(trap) {
+        if (trapQueue.length > 0) {
+          var activeTrap = trapQueue[trapQueue.length - 1];
+          if (activeTrap !== trap) {
+            activeTrap.pause();
+          }
+        }
+        var trapIndex = trapQueue.indexOf(trap);
+        if (trapIndex === -1) {
+          trapQueue.push(trap);
+        } else {
+          trapQueue.splice(trapIndex, 1);
+          trapQueue.push(trap);
+        }
+      },
+      deactivateTrap: function deactivateTrap(trap) {
+        var trapIndex = trapQueue.indexOf(trap);
+        if (trapIndex !== -1) {
+          trapQueue.splice(trapIndex, 1);
+        }
+        if (trapQueue.length > 0) {
+          trapQueue[trapQueue.length - 1].unpause();
+        }
+      }
+    };
+  }();
+  var isSelectableInput = function isSelectableInput2(node) {
+    return node.tagName && node.tagName.toLowerCase() === "input" && typeof node.select === "function";
+  };
+  var isEscapeEvent = function isEscapeEvent2(e) {
+    return e.key === "Escape" || e.key === "Esc" || e.keyCode === 27;
+  };
+  var isTabEvent = function isTabEvent2(e) {
+    return e.key === "Tab" || e.keyCode === 9;
+  };
+  var delay = function delay2(fn) {
+    return setTimeout(fn, 0);
+  };
+  var findIndex = function findIndex2(arr, fn) {
+    var idx = -1;
+    arr.every(function(value, i) {
+      if (fn(value)) {
+        idx = i;
+        return false;
+      }
+      return true;
+    });
+    return idx;
+  };
+  var valueOrHandler = function valueOrHandler2(value) {
+    for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      params[_key - 1] = arguments[_key];
+    }
+    return typeof value === "function" ? value.apply(void 0, params) : value;
+  };
+  var createFocusTrap2 = function createFocusTrap3(elements, userOptions) {
+    var doc = document;
+    var config = _objectSpread2({
+      returnFocusOnDeactivate: true,
+      escapeDeactivates: true,
+      delayInitialFocus: true
+    }, userOptions);
+    var state = {
+      containers: [],
+      tabbableGroups: [],
+      nodeFocusedBeforeActivation: null,
+      mostRecentlyFocusedNode: null,
+      active: false,
+      paused: false,
+      delayInitialFocusTimer: void 0
+    };
+    var trap;
+    var getOption = function getOption2(configOverrideOptions, optionName, configOptionName) {
+      return configOverrideOptions && configOverrideOptions[optionName] !== void 0 ? configOverrideOptions[optionName] : config[configOptionName || optionName];
+    };
+    var containersContain = function containersContain2(element) {
+      return state.containers.some(function(container) {
+        return container.contains(element);
+      });
+    };
+    var getNodeForOption = function getNodeForOption2(optionName) {
+      var optionValue = config[optionName];
+      if (!optionValue) {
+        return null;
+      }
+      var node = optionValue;
+      if (typeof optionValue === "string") {
+        node = doc.querySelector(optionValue);
+        if (!node) {
+          throw new Error("`".concat(optionName, "` refers to no known node"));
+        }
+      }
+      if (typeof optionValue === "function") {
+        node = optionValue();
+        if (!node) {
+          throw new Error("`".concat(optionName, "` did not return a node"));
+        }
+      }
+      return node;
+    };
+    var getInitialFocusNode = function getInitialFocusNode2() {
+      var node;
+      if (getOption({}, "initialFocus") === false) {
+        return false;
+      }
+      if (getNodeForOption("initialFocus") !== null) {
+        node = getNodeForOption("initialFocus");
+      } else if (containersContain(doc.activeElement)) {
+        node = doc.activeElement;
+      } else {
+        var firstTabbableGroup = state.tabbableGroups[0];
+        var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;
+        node = firstTabbableNode || getNodeForOption("fallbackFocus");
+      }
+      if (!node) {
+        throw new Error("Your focus-trap needs to have at least one focusable element");
+      }
+      return node;
+    };
+    var updateTabbableNodes = function updateTabbableNodes2() {
+      state.tabbableGroups = state.containers.map(function(container) {
+        var tabbableNodes = tabbable.tabbable(container);
+        if (tabbableNodes.length > 0) {
+          return {
+            container,
+            firstTabbableNode: tabbableNodes[0],
+            lastTabbableNode: tabbableNodes[tabbableNodes.length - 1]
+          };
+        }
+        return void 0;
+      }).filter(function(group) {
+        return !!group;
+      });
+      if (state.tabbableGroups.length <= 0 && !getNodeForOption("fallbackFocus")) {
+        throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
+      }
+    };
+    var tryFocus = function tryFocus2(node) {
+      if (node === false) {
+        return;
+      }
+      if (node === doc.activeElement) {
+        return;
+      }
+      if (!node || !node.focus) {
+        tryFocus2(getInitialFocusNode());
+        return;
+      }
+      node.focus({
+        preventScroll: !!config.preventScroll
+      });
+      state.mostRecentlyFocusedNode = node;
+      if (isSelectableInput(node)) {
+        node.select();
+      }
+    };
+    var getReturnFocusNode = function getReturnFocusNode2(previousActiveElement) {
+      var node = getNodeForOption("setReturnFocus");
+      return node ? node : previousActiveElement;
+    };
+    var checkPointerDown = function checkPointerDown2(e) {
+      if (containersContain(e.target)) {
+        return;
+      }
+      if (valueOrHandler(config.clickOutsideDeactivates, e)) {
+        trap.deactivate({
+          returnFocus: config.returnFocusOnDeactivate && !tabbable.isFocusable(e.target)
+        });
+        return;
+      }
+      if (valueOrHandler(config.allowOutsideClick, e)) {
+        return;
+      }
+      e.preventDefault();
+    };
+    var checkFocusIn = function checkFocusIn2(e) {
+      var targetContained = containersContain(e.target);
+      if (targetContained || e.target instanceof Document) {
+        if (targetContained) {
+          state.mostRecentlyFocusedNode = e.target;
+        }
+      } else {
+        e.stopImmediatePropagation();
+        tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());
+      }
+    };
+    var checkTab = function checkTab2(e) {
+      updateTabbableNodes();
+      var destinationNode = null;
+      if (state.tabbableGroups.length > 0) {
+        var containerIndex = findIndex(state.tabbableGroups, function(_ref) {
+          var container = _ref.container;
+          return container.contains(e.target);
+        });
+        if (containerIndex < 0) {
+          if (e.shiftKey) {
+            destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;
+          } else {
+            destinationNode = state.tabbableGroups[0].firstTabbableNode;
+          }
+        } else if (e.shiftKey) {
+          var startOfGroupIndex = findIndex(state.tabbableGroups, function(_ref2) {
+            var firstTabbableNode = _ref2.firstTabbableNode;
+            return e.target === firstTabbableNode;
+          });
+          if (startOfGroupIndex < 0 && state.tabbableGroups[containerIndex].container === e.target) {
+            startOfGroupIndex = containerIndex;
+          }
+          if (startOfGroupIndex >= 0) {
+            var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;
+            var destinationGroup = state.tabbableGroups[destinationGroupIndex];
+            destinationNode = destinationGroup.lastTabbableNode;
+          }
+        } else {
+          var lastOfGroupIndex = findIndex(state.tabbableGroups, function(_ref3) {
+            var lastTabbableNode = _ref3.lastTabbableNode;
+            return e.target === lastTabbableNode;
+          });
+          if (lastOfGroupIndex < 0 && state.tabbableGroups[containerIndex].container === e.target) {
+            lastOfGroupIndex = containerIndex;
+          }
+          if (lastOfGroupIndex >= 0) {
+            var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;
+            var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];
+            destinationNode = _destinationGroup.firstTabbableNode;
+          }
+        }
+      } else {
+        destinationNode = getNodeForOption("fallbackFocus");
+      }
+      if (destinationNode) {
+        e.preventDefault();
+        tryFocus(destinationNode);
+      }
+    };
+    var checkKey = function checkKey2(e) {
+      if (isEscapeEvent(e) && valueOrHandler(config.escapeDeactivates) !== false) {
+        e.preventDefault();
+        trap.deactivate();
+        return;
+      }
+      if (isTabEvent(e)) {
+        checkTab(e);
+        return;
+      }
+    };
+    var checkClick = function checkClick2(e) {
+      if (valueOrHandler(config.clickOutsideDeactivates, e)) {
+        return;
+      }
+      if (containersContain(e.target)) {
+        return;
+      }
+      if (valueOrHandler(config.allowOutsideClick, e)) {
+        return;
+      }
+      e.preventDefault();
+      e.stopImmediatePropagation();
+    };
+    var addListeners = function addListeners2() {
+      if (!state.active) {
+        return;
+      }
+      activeFocusTraps.activateTrap(trap);
+      state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function() {
+        tryFocus(getInitialFocusNode());
+      }) : tryFocus(getInitialFocusNode());
+      doc.addEventListener("focusin", checkFocusIn, true);
+      doc.addEventListener("mousedown", checkPointerDown, {
+        capture: true,
+        passive: false
+      });
+      doc.addEventListener("touchstart", checkPointerDown, {
+        capture: true,
+        passive: false
+      });
+      doc.addEventListener("click", checkClick, {
+        capture: true,
+        passive: false
+      });
+      doc.addEventListener("keydown", checkKey, {
+        capture: true,
+        passive: false
+      });
+      return trap;
+    };
+    var removeListeners = function removeListeners2() {
+      if (!state.active) {
+        return;
+      }
+      doc.removeEventListener("focusin", checkFocusIn, true);
+      doc.removeEventListener("mousedown", checkPointerDown, true);
+      doc.removeEventListener("touchstart", checkPointerDown, true);
+      doc.removeEventListener("click", checkClick, true);
+      doc.removeEventListener("keydown", checkKey, true);
+      return trap;
+    };
+    trap = {
+      activate: function activate(activateOptions) {
+        if (state.active) {
+          return this;
+        }
+        var onActivate = getOption(activateOptions, "onActivate");
+        var onPostActivate = getOption(activateOptions, "onPostActivate");
+        var checkCanFocusTrap = getOption(activateOptions, "checkCanFocusTrap");
+        if (!checkCanFocusTrap) {
+          updateTabbableNodes();
+        }
+        state.active = true;
+        state.paused = false;
+        state.nodeFocusedBeforeActivation = doc.activeElement;
+        if (onActivate) {
+          onActivate();
+        }
+        var finishActivation = function finishActivation2() {
+          if (checkCanFocusTrap) {
+            updateTabbableNodes();
+          }
+          addListeners();
+          if (onPostActivate) {
+            onPostActivate();
+          }
+        };
+        if (checkCanFocusTrap) {
+          checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);
+          return this;
+        }
+        finishActivation();
+        return this;
+      },
+      deactivate: function deactivate(deactivateOptions) {
+        if (!state.active) {
+          return this;
+        }
+        clearTimeout(state.delayInitialFocusTimer);
+        state.delayInitialFocusTimer = void 0;
+        removeListeners();
+        state.active = false;
+        state.paused = false;
+        activeFocusTraps.deactivateTrap(trap);
+        var onDeactivate = getOption(deactivateOptions, "onDeactivate");
+        var onPostDeactivate = getOption(deactivateOptions, "onPostDeactivate");
+        var checkCanReturnFocus = getOption(deactivateOptions, "checkCanReturnFocus");
+        if (onDeactivate) {
+          onDeactivate();
+        }
+        var returnFocus = getOption(deactivateOptions, "returnFocus", "returnFocusOnDeactivate");
+        var finishDeactivation = function finishDeactivation2() {
+          delay(function() {
+            if (returnFocus) {
+              tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));
+            }
+            if (onPostDeactivate) {
+              onPostDeactivate();
+            }
+          });
+        };
+        if (returnFocus && checkCanReturnFocus) {
+          checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);
+          return this;
+        }
+        finishDeactivation();
+        return this;
+      },
+      pause: function pause() {
+        if (state.paused || !state.active) {
+          return this;
+        }
+        state.paused = true;
+        removeListeners();
+        return this;
+      },
+      unpause: function unpause() {
+        if (!state.paused || !state.active) {
+          return this;
+        }
+        state.paused = false;
+        updateTabbableNodes();
+        addListeners();
+        return this;
+      },
+      updateContainerElements: function updateContainerElements(containerElements) {
+        var elementsAsArray = [].concat(containerElements).filter(Boolean);
+        state.containers = elementsAsArray.map(function(element) {
+          return typeof element === "string" ? doc.querySelector(element) : element;
+        });
+        if (state.active) {
+          updateTabbableNodes();
+        }
+        return this;
+      }
+    };
+    trap.updateContainerElements(elements);
+    return trap;
+  };
+  exports2.createFocusTrap = createFocusTrap2;
+});
+
+// packages/focus/builds/module.js
+__markAsModule(exports);
+__export(exports, {
+  default: () => module_default
+});
+
+// packages/focus/src/index.js
+var import_focus_trap = __toModule(require_focus_trap());
+var import_tabbable = __toModule(require_dist());
+function src_default(Alpine) {
+  let lastFocused;
+  let currentFocused;
+  window.addEventListener("focusin", () => {
+    lastFocused = currentFocused;
+    currentFocused = document.activeElement;
+  });
+  Alpine.magic("focus", (el) => {
+    let within = el;
+    return {
+      __noscroll: false,
+      __wrapAround: false,
+      within(el2) {
+        within = el2;
+        return this;
+      },
+      withoutScrolling() {
+        this.__noscroll = true;
+        return this;
+      },
+      noscroll() {
+        this.__noscroll = true;
+        return this;
+      },
+      withWrapAround() {
+        this.__wrapAround = true;
+        return this;
+      },
+      wrap() {
+        return this.withWrapAround();
+      },
+      focusable(el2) {
+        return (0, import_tabbable.isFocusable)(el2);
+      },
+      previouslyFocused() {
+        return lastFocused;
+      },
+      lastFocused() {
+        return lastFocused;
+      },
+      focused() {
+        return currentFocused;
+      },
+      focusables() {
+        if (Array.isArray(within))
+          return within;
+        return (0, import_tabbable.focusable)(within, {displayCheck: "none"});
+      },
+      all() {
+        return this.focusables();
+      },
+      isFirst(el2) {
+        let els = this.all();
+        return els[0] && els[0].isSameNode(el2);
+      },
+      isLast(el2) {
+        let els = this.all();
+        return els.length && els.slice(-1)[0].isSameNode(el2);
+      },
+      getFirst() {
+        return this.all()[0];
+      },
+      getLast() {
+        return this.all().slice(-1)[0];
+      },
+      getNext() {
+        let list = this.all();
+        let current = document.activeElement;
+        if (list.indexOf(current) === -1)
+          return;
+        if (this.__wrapAround && list.indexOf(current) === list.length - 1) {
+          return list[0];
+        }
+        return list[list.indexOf(current) + 1];
+      },
+      getPrevious() {
+        let list = this.all();
+        let current = document.activeElement;
+        if (list.indexOf(current) === -1)
+          return;
+        if (this.__wrapAround && list.indexOf(current) === 0) {
+          return list.slice(-1)[0];
+        }
+        return list[list.indexOf(current) - 1];
+      },
+      first() {
+        this.focus(this.getFirst());
+      },
+      last() {
+        this.focus(this.getLast());
+      },
+      next() {
+        this.focus(this.getNext());
+      },
+      previous() {
+        this.focus(this.getPrevious());
+      },
+      prev() {
+        return this.previous();
+      },
+      focus(el2) {
+        if (!el2)
+          return;
+        setTimeout(() => {
+          if (!el2.hasAttribute("tabindex"))
+            el2.setAttribute("tabindex", "0");
+          el2.focus({preventScroll: this._noscroll});
+        });
+      }
+    };
+  });
+  Alpine.directive("trap", Alpine.skipDuringClone((el, {expression, modifiers}, {effect, evaluateLater, cleanup}) => {
+    let evaluator = evaluateLater(expression);
+    let oldValue = false;
+    let options = {
+      escapeDeactivates: false,
+      allowOutsideClick: true,
+      fallbackFocus: () => el
+    };
+    let autofocusEl = el.querySelector("[autofocus]");
+    if (autofocusEl)
+      options.initialFocus = autofocusEl;
+    let trap = (0, import_focus_trap.createFocusTrap)(el, options);
+    let undoInert = () => {
+    };
+    let undoDisableScrolling = () => {
+    };
+    const releaseFocus = () => {
+      undoInert();
+      undoInert = () => {
+      };
+      undoDisableScrolling();
+      undoDisableScrolling = () => {
+      };
+      trap.deactivate({
+        returnFocus: !modifiers.includes("noreturn")
+      });
+    };
+    effect(() => evaluator((value) => {
+      if (oldValue === value)
+        return;
+      if (value && !oldValue) {
+        setTimeout(() => {
+          if (modifiers.includes("inert"))
+            undoInert = setInert(el);
+          if (modifiers.includes("noscroll"))
+            undoDisableScrolling = disableScrolling();
+          trap.activate();
+        });
+      }
+      if (!value && oldValue) {
+        releaseFocus();
+      }
+      oldValue = !!value;
+    }));
+    cleanup(releaseFocus);
+  }, (el, {expression, modifiers}, {evaluate}) => {
+    if (modifiers.includes("inert") && evaluate(expression))
+      setInert(el);
+  }));
+}
+function setInert(el) {
+  let undos = [];
+  crawlSiblingsUp(el, (sibling) => {
+    let cache = sibling.hasAttribute("aria-hidden");
+    sibling.setAttribute("aria-hidden", "true");
+    undos.push(() => cache || sibling.removeAttribute("aria-hidden"));
+  });
+  return () => {
+    while (undos.length)
+      undos.pop()();
+  };
+}
+function crawlSiblingsUp(el, callback) {
+  if (el.isSameNode(document.body) || !el.parentNode)
+    return;
+  Array.from(el.parentNode.children).forEach((sibling) => {
+    if (sibling.isSameNode(el)) {
+      crawlSiblingsUp(el.parentNode, callback);
+    } else {
+      callback(sibling);
+    }
+  });
+}
+function disableScrolling() {
+  let overflow = document.documentElement.style.overflow;
+  let paddingRight = document.documentElement.style.paddingRight;
+  let scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+  document.documentElement.style.overflow = "hidden";
+  document.documentElement.style.paddingRight = `${scrollbarWidth}px`;
+  return () => {
+    document.documentElement.style.overflow = overflow;
+    document.documentElement.style.paddingRight = paddingRight;
+  };
+}
+
+// packages/focus/builds/module.js
+var module_default = src_default;

Optimized Atomcms daily updated/node_modules/@alpinejs/focus/dist/module.esm.js

@@ -0,0 +1,826 @@
+// node_modules/tabbable/dist/index.esm.js
+/*!
+* tabbable 5.2.1
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
+var candidateSelectors = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])', "details>summary:first-of-type", "details"];
+var candidateSelector = /* @__PURE__ */ candidateSelectors.join(",");
+var matches = typeof Element === "undefined" ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+var getCandidates = function getCandidates2(el, includeContainer, filter) {
+  var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+  if (includeContainer && matches.call(el, candidateSelector)) {
+    candidates.unshift(el);
+  }
+  candidates = candidates.filter(filter);
+  return candidates;
+};
+var isContentEditable = function isContentEditable2(node) {
+  return node.contentEditable === "true";
+};
+var getTabindex = function getTabindex2(node) {
+  var tabindexAttr = parseInt(node.getAttribute("tabindex"), 10);
+  if (!isNaN(tabindexAttr)) {
+    return tabindexAttr;
+  }
+  if (isContentEditable(node)) {
+    return 0;
+  }
+  if ((node.nodeName === "AUDIO" || node.nodeName === "VIDEO" || node.nodeName === "DETAILS") && node.getAttribute("tabindex") === null) {
+    return 0;
+  }
+  return node.tabIndex;
+};
+var sortOrderedTabbables = function sortOrderedTabbables2(a, b) {
+  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+};
+var isInput = function isInput2(node) {
+  return node.tagName === "INPUT";
+};
+var isHiddenInput = function isHiddenInput2(node) {
+  return isInput(node) && node.type === "hidden";
+};
+var isDetailsWithSummary = function isDetailsWithSummary2(node) {
+  var r = node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+    return child.tagName === "SUMMARY";
+  });
+  return r;
+};
+var getCheckedRadio = function getCheckedRadio2(nodes, form) {
+  for (var i = 0; i < nodes.length; i++) {
+    if (nodes[i].checked && nodes[i].form === form) {
+      return nodes[i];
+    }
+  }
+};
+var isTabbableRadio = function isTabbableRadio2(node) {
+  if (!node.name) {
+    return true;
+  }
+  var radioScope = node.form || node.ownerDocument;
+  var queryRadios = function queryRadios2(name) {
+    return radioScope.querySelectorAll('input[type="radio"][name="' + name + '"]');
+  };
+  var radioSet;
+  if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") {
+    radioSet = queryRadios(window.CSS.escape(node.name));
+  } else {
+    try {
+      radioSet = queryRadios(node.name);
+    } catch (err) {
+      console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+      return false;
+    }
+  }
+  var checked = getCheckedRadio(radioSet, node.form);
+  return !checked || checked === node;
+};
+var isRadio = function isRadio2(node) {
+  return isInput(node) && node.type === "radio";
+};
+var isNonTabbableRadio = function isNonTabbableRadio2(node) {
+  return isRadio(node) && !isTabbableRadio(node);
+};
+var isHidden = function isHidden2(node, displayCheck) {
+  if (getComputedStyle(node).visibility === "hidden") {
+    return true;
+  }
+  var isDirectSummary = matches.call(node, "details>summary:first-of-type");
+  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
+  if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
+    return true;
+  }
+  if (!displayCheck || displayCheck === "full") {
+    while (node) {
+      if (getComputedStyle(node).display === "none") {
+        return true;
+      }
+      node = node.parentElement;
+    }
+  } else if (displayCheck === "non-zero-area") {
+    var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+    return width === 0 && height === 0;
+  }
+  return false;
+};
+var isDisabledFromFieldset = function isDisabledFromFieldset2(node) {
+  if (isInput(node) || node.tagName === "SELECT" || node.tagName === "TEXTAREA" || node.tagName === "BUTTON") {
+    var parentNode = node.parentElement;
+    while (parentNode) {
+      if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+        for (var i = 0; i < parentNode.children.length; i++) {
+          var child = parentNode.children.item(i);
+          if (child.tagName === "LEGEND") {
+            if (child.contains(node)) {
+              return false;
+            }
+            return true;
+          }
+        }
+        return true;
+      }
+      parentNode = parentNode.parentElement;
+    }
+  }
+  return false;
+};
+var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable2(options, node) {
+  if (node.disabled || isHiddenInput(node) || isHidden(node, options.displayCheck) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
+    return false;
+  }
+  return true;
+};
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable2(options, node) {
+  if (!isNodeMatchingSelectorFocusable(options, node) || isNonTabbableRadio(node) || getTabindex(node) < 0) {
+    return false;
+  }
+  return true;
+};
+var tabbable = function tabbable2(el, options) {
+  options = options || {};
+  var regularTabbables = [];
+  var orderedTabbables = [];
+  var candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+  candidates.forEach(function(candidate, i) {
+    var candidateTabindex = getTabindex(candidate);
+    if (candidateTabindex === 0) {
+      regularTabbables.push(candidate);
+    } else {
+      orderedTabbables.push({
+        documentOrder: i,
+        tabIndex: candidateTabindex,
+        node: candidate
+      });
+    }
+  });
+  var tabbableNodes = orderedTabbables.sort(sortOrderedTabbables).map(function(a) {
+    return a.node;
+  }).concat(regularTabbables);
+  return tabbableNodes;
+};
+var focusable = function focusable2(el, options) {
+  options = options || {};
+  var candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+  return candidates;
+};
+var focusableCandidateSelector = /* @__PURE__ */ candidateSelectors.concat("iframe").join(",");
+var isFocusable = function isFocusable2(node, options) {
+  options = options || {};
+  if (!node) {
+    throw new Error("No node provided");
+  }
+  if (matches.call(node, focusableCandidateSelector) === false) {
+    return false;
+  }
+  return isNodeMatchingSelectorFocusable(options, node);
+};
+
+// node_modules/focus-trap/dist/focus-trap.esm.js
+/*!
+* focus-trap 6.6.1
+* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
+*/
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) {
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function(key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var activeFocusTraps = function() {
+  var trapQueue = [];
+  return {
+    activateTrap: function activateTrap(trap) {
+      if (trapQueue.length > 0) {
+        var activeTrap = trapQueue[trapQueue.length - 1];
+        if (activeTrap !== trap) {
+          activeTrap.pause();
+        }
+      }
+      var trapIndex = trapQueue.indexOf(trap);
+      if (trapIndex === -1) {
+        trapQueue.push(trap);
+      } else {
+        trapQueue.splice(trapIndex, 1);
+        trapQueue.push(trap);
+      }
+    },
+    deactivateTrap: function deactivateTrap(trap) {
+      var trapIndex = trapQueue.indexOf(trap);
+      if (trapIndex !== -1) {
+        trapQueue.splice(trapIndex, 1);
+      }
+      if (trapQueue.length > 0) {
+        trapQueue[trapQueue.length - 1].unpause();
+      }
+    }
+  };
+}();
+var isSelectableInput = function isSelectableInput2(node) {
+  return node.tagName && node.tagName.toLowerCase() === "input" && typeof node.select === "function";
+};
+var isEscapeEvent = function isEscapeEvent2(e) {
+  return e.key === "Escape" || e.key === "Esc" || e.keyCode === 27;
+};
+var isTabEvent = function isTabEvent2(e) {
+  return e.key === "Tab" || e.keyCode === 9;
+};
+var delay = function delay2(fn) {
+  return setTimeout(fn, 0);
+};
+var findIndex = function findIndex2(arr, fn) {
+  var idx = -1;
+  arr.every(function(value, i) {
+    if (fn(value)) {
+      idx = i;
+      return false;
+    }
+    return true;
+  });
+  return idx;
+};
+var valueOrHandler = function valueOrHandler2(value) {
+  for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    params[_key - 1] = arguments[_key];
+  }
+  return typeof value === "function" ? value.apply(void 0, params) : value;
+};
+var createFocusTrap = function createFocusTrap2(elements, userOptions) {
+  var doc = document;
+  var config = _objectSpread2({
+    returnFocusOnDeactivate: true,
+    escapeDeactivates: true,
+    delayInitialFocus: true
+  }, userOptions);
+  var state = {
+    containers: [],
+    tabbableGroups: [],
+    nodeFocusedBeforeActivation: null,
+    mostRecentlyFocusedNode: null,
+    active: false,
+    paused: false,
+    delayInitialFocusTimer: void 0
+  };
+  var trap;
+  var getOption = function getOption2(configOverrideOptions, optionName, configOptionName) {
+    return configOverrideOptions && configOverrideOptions[optionName] !== void 0 ? configOverrideOptions[optionName] : config[configOptionName || optionName];
+  };
+  var containersContain = function containersContain2(element) {
+    return state.containers.some(function(container) {
+      return container.contains(element);
+    });
+  };
+  var getNodeForOption = function getNodeForOption2(optionName) {
+    var optionValue = config[optionName];
+    if (!optionValue) {
+      return null;
+    }
+    var node = optionValue;
+    if (typeof optionValue === "string") {
+      node = doc.querySelector(optionValue);
+      if (!node) {
+        throw new Error("`".concat(optionName, "` refers to no known node"));
+      }
+    }
+    if (typeof optionValue === "function") {
+      node = optionValue();
+      if (!node) {
+        throw new Error("`".concat(optionName, "` did not return a node"));
+      }
+    }
+    return node;
+  };
+  var getInitialFocusNode = function getInitialFocusNode2() {
+    var node;
+    if (getOption({}, "initialFocus") === false) {
+      return false;
+    }
+    if (getNodeForOption("initialFocus") !== null) {
+      node = getNodeForOption("initialFocus");
+    } else if (containersContain(doc.activeElement)) {
+      node = doc.activeElement;
+    } else {
+      var firstTabbableGroup = state.tabbableGroups[0];
+      var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;
+      node = firstTabbableNode || getNodeForOption("fallbackFocus");
+    }
+    if (!node) {
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    }
+    return node;
+  };
+  var updateTabbableNodes = function updateTabbableNodes2() {
+    state.tabbableGroups = state.containers.map(function(container) {
+      var tabbableNodes = tabbable(container);
+      if (tabbableNodes.length > 0) {
+        return {
+          container,
+          firstTabbableNode: tabbableNodes[0],
+          lastTabbableNode: tabbableNodes[tabbableNodes.length - 1]
+        };
+      }
+      return void 0;
+    }).filter(function(group) {
+      return !!group;
+    });
+    if (state.tabbableGroups.length <= 0 && !getNodeForOption("fallbackFocus")) {
+      throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
+    }
+  };
+  var tryFocus = function tryFocus2(node) {
+    if (node === false) {
+      return;
+    }
+    if (node === doc.activeElement) {
+      return;
+    }
+    if (!node || !node.focus) {
+      tryFocus2(getInitialFocusNode());
+      return;
+    }
+    node.focus({
+      preventScroll: !!config.preventScroll
+    });
+    state.mostRecentlyFocusedNode = node;
+    if (isSelectableInput(node)) {
+      node.select();
+    }
+  };
+  var getReturnFocusNode = function getReturnFocusNode2(previousActiveElement) {
+    var node = getNodeForOption("setReturnFocus");
+    return node ? node : previousActiveElement;
+  };
+  var checkPointerDown = function checkPointerDown2(e) {
+    if (containersContain(e.target)) {
+      return;
+    }
+    if (valueOrHandler(config.clickOutsideDeactivates, e)) {
+      trap.deactivate({
+        returnFocus: config.returnFocusOnDeactivate && !isFocusable(e.target)
+      });
+      return;
+    }
+    if (valueOrHandler(config.allowOutsideClick, e)) {
+      return;
+    }
+    e.preventDefault();
+  };
+  var checkFocusIn = function checkFocusIn2(e) {
+    var targetContained = containersContain(e.target);
+    if (targetContained || e.target instanceof Document) {
+      if (targetContained) {
+        state.mostRecentlyFocusedNode = e.target;
+      }
+    } else {
+      e.stopImmediatePropagation();
+      tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());
+    }
+  };
+  var checkTab = function checkTab2(e) {
+    updateTabbableNodes();
+    var destinationNode = null;
+    if (state.tabbableGroups.length > 0) {
+      var containerIndex = findIndex(state.tabbableGroups, function(_ref) {
+        var container = _ref.container;
+        return container.contains(e.target);
+      });
+      if (containerIndex < 0) {
+        if (e.shiftKey) {
+          destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;
+        } else {
+          destinationNode = state.tabbableGroups[0].firstTabbableNode;
+        }
+      } else if (e.shiftKey) {
+        var startOfGroupIndex = findIndex(state.tabbableGroups, function(_ref2) {
+          var firstTabbableNode = _ref2.firstTabbableNode;
+          return e.target === firstTabbableNode;
+        });
+        if (startOfGroupIndex < 0 && state.tabbableGroups[containerIndex].container === e.target) {
+          startOfGroupIndex = containerIndex;
+        }
+        if (startOfGroupIndex >= 0) {
+          var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;
+          var destinationGroup = state.tabbableGroups[destinationGroupIndex];
+          destinationNode = destinationGroup.lastTabbableNode;
+        }
+      } else {
+        var lastOfGroupIndex = findIndex(state.tabbableGroups, function(_ref3) {
+          var lastTabbableNode = _ref3.lastTabbableNode;
+          return e.target === lastTabbableNode;
+        });
+        if (lastOfGroupIndex < 0 && state.tabbableGroups[containerIndex].container === e.target) {
+          lastOfGroupIndex = containerIndex;
+        }
+        if (lastOfGroupIndex >= 0) {
+          var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;
+          var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];
+          destinationNode = _destinationGroup.firstTabbableNode;
+        }
+      }
+    } else {
+      destinationNode = getNodeForOption("fallbackFocus");
+    }
+    if (destinationNode) {
+      e.preventDefault();
+      tryFocus(destinationNode);
+    }
+  };
+  var checkKey = function checkKey2(e) {
+    if (isEscapeEvent(e) && valueOrHandler(config.escapeDeactivates) !== false) {
+      e.preventDefault();
+      trap.deactivate();
+      return;
+    }
+    if (isTabEvent(e)) {
+      checkTab(e);
+      return;
+    }
+  };
+  var checkClick = function checkClick2(e) {
+    if (valueOrHandler(config.clickOutsideDeactivates, e)) {
+      return;
+    }
+    if (containersContain(e.target)) {
+      return;
+    }
+    if (valueOrHandler(config.allowOutsideClick, e)) {
+      return;
+    }
+    e.preventDefault();
+    e.stopImmediatePropagation();
+  };
+  var addListeners = function addListeners2() {
+    if (!state.active) {
+      return;
+    }
+    activeFocusTraps.activateTrap(trap);
+    state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function() {
+      tryFocus(getInitialFocusNode());
+    }) : tryFocus(getInitialFocusNode());
+    doc.addEventListener("focusin", checkFocusIn, true);
+    doc.addEventListener("mousedown", checkPointerDown, {
+      capture: true,
+      passive: false
+    });
+    doc.addEventListener("touchstart", checkPointerDown, {
+      capture: true,
+      passive: false
+    });
+    doc.addEventListener("click", checkClick, {
+      capture: true,
+      passive: false
+    });
+    doc.addEventListener("keydown", checkKey, {
+      capture: true,
+      passive: false
+    });
+    return trap;
+  };
+  var removeListeners = function removeListeners2() {
+    if (!state.active) {
+      return;
+    }
+    doc.removeEventListener("focusin", checkFocusIn, true);
+    doc.removeEventListener("mousedown", checkPointerDown, true);
+    doc.removeEventListener("touchstart", checkPointerDown, true);
+    doc.removeEventListener("click", checkClick, true);
+    doc.removeEventListener("keydown", checkKey, true);
+    return trap;
+  };
+  trap = {
+    activate: function activate(activateOptions) {
+      if (state.active) {
+        return this;
+      }
+      var onActivate = getOption(activateOptions, "onActivate");
+      var onPostActivate = getOption(activateOptions, "onPostActivate");
+      var checkCanFocusTrap = getOption(activateOptions, "checkCanFocusTrap");
+      if (!checkCanFocusTrap) {
+        updateTabbableNodes();
+      }
+      state.active = true;
+      state.paused = false;
+      state.nodeFocusedBeforeActivation = doc.activeElement;
+      if (onActivate) {
+        onActivate();
+      }
+      var finishActivation = function finishActivation2() {
+        if (checkCanFocusTrap) {
+          updateTabbableNodes();
+        }
+        addListeners();
+        if (onPostActivate) {
+          onPostActivate();
+        }
+      };
+      if (checkCanFocusTrap) {
+        checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);
+        return this;
+      }
+      finishActivation();
+      return this;
+    },
+    deactivate: function deactivate(deactivateOptions) {
+      if (!state.active) {
+        return this;
+      }
+      clearTimeout(state.delayInitialFocusTimer);
+      state.delayInitialFocusTimer = void 0;
+      removeListeners();
+      state.active = false;
+      state.paused = false;
+      activeFocusTraps.deactivateTrap(trap);
+      var onDeactivate = getOption(deactivateOptions, "onDeactivate");
+      var onPostDeactivate = getOption(deactivateOptions, "onPostDeactivate");
+      var checkCanReturnFocus = getOption(deactivateOptions, "checkCanReturnFocus");
+      if (onDeactivate) {
+        onDeactivate();
+      }
+      var returnFocus = getOption(deactivateOptions, "returnFocus", "returnFocusOnDeactivate");
+      var finishDeactivation = function finishDeactivation2() {
+        delay(function() {
+          if (returnFocus) {
+            tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));
+          }
+          if (onPostDeactivate) {
+            onPostDeactivate();
+          }
+        });
+      };
+      if (returnFocus && checkCanReturnFocus) {
+        checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);
+        return this;
+      }
+      finishDeactivation();
+      return this;
+    },
+    pause: function pause() {
+      if (state.paused || !state.active) {
+        return this;
+      }
+      state.paused = true;
+      removeListeners();
+      return this;
+    },
+    unpause: function unpause() {
+      if (!state.paused || !state.active) {
+        return this;
+      }
+      state.paused = false;
+      updateTabbableNodes();
+      addListeners();
+      return this;
+    },
+    updateContainerElements: function updateContainerElements(containerElements) {
+      var elementsAsArray = [].concat(containerElements).filter(Boolean);
+      state.containers = elementsAsArray.map(function(element) {
+        return typeof element === "string" ? doc.querySelector(element) : element;
+      });
+      if (state.active) {
+        updateTabbableNodes();
+      }
+      return this;
+    }
+  };
+  trap.updateContainerElements(elements);
+  return trap;
+};
+
+// packages/focus/src/index.js
+function src_default(Alpine) {
+  let lastFocused;
+  let currentFocused;
+  window.addEventListener("focusin", () => {
+    lastFocused = currentFocused;
+    currentFocused = document.activeElement;
+  });
+  Alpine.magic("focus", (el) => {
+    let within = el;
+    return {
+      __noscroll: false,
+      __wrapAround: false,
+      within(el2) {
+        within = el2;
+        return this;
+      },
+      withoutScrolling() {
+        this.__noscroll = true;
+        return this;
+      },
+      noscroll() {
+        this.__noscroll = true;
+        return this;
+      },
+      withWrapAround() {
+        this.__wrapAround = true;
+        return this;
+      },
+      wrap() {
+        return this.withWrapAround();
+      },
+      focusable(el2) {
+        return isFocusable(el2);
+      },
+      previouslyFocused() {
+        return lastFocused;
+      },
+      lastFocused() {
+        return lastFocused;
+      },
+      focused() {
+        return currentFocused;
+      },
+      focusables() {
+        if (Array.isArray(within))
+          return within;
+        return focusable(within, {displayCheck: "none"});
+      },
+      all() {
+        return this.focusables();
+      },
+      isFirst(el2) {
+        let els = this.all();
+        return els[0] && els[0].isSameNode(el2);
+      },
+      isLast(el2) {
+        let els = this.all();
+        return els.length && els.slice(-1)[0].isSameNode(el2);
+      },
+      getFirst() {
+        return this.all()[0];
+      },
+      getLast() {
+        return this.all().slice(-1)[0];
+      },
+      getNext() {
+        let list = this.all();
+        let current = document.activeElement;
+        if (list.indexOf(current) === -1)
+          return;
+        if (this.__wrapAround && list.indexOf(current) === list.length - 1) {
+          return list[0];
+        }
+        return list[list.indexOf(current) + 1];
+      },
+      getPrevious() {
+        let list = this.all();
+        let current = document.activeElement;
+        if (list.indexOf(current) === -1)
+          return;
+        if (this.__wrapAround && list.indexOf(current) === 0) {
+          return list.slice(-1)[0];
+        }
+        return list[list.indexOf(current) - 1];
+      },
+      first() {
+        this.focus(this.getFirst());
+      },
+      last() {
+        this.focus(this.getLast());
+      },
+      next() {
+        this.focus(this.getNext());
+      },
+      previous() {
+        this.focus(this.getPrevious());
+      },
+      prev() {
+        return this.previous();
+      },
+      focus(el2) {
+        if (!el2)
+          return;
+        setTimeout(() => {
+          if (!el2.hasAttribute("tabindex"))
+            el2.setAttribute("tabindex", "0");
+          el2.focus({preventScroll: this._noscroll});
+        });
+      }
+    };
+  });
+  Alpine.directive("trap", Alpine.skipDuringClone((el, {expression, modifiers}, {effect, evaluateLater, cleanup}) => {
+    let evaluator = evaluateLater(expression);
+    let oldValue = false;
+    let options = {
+      escapeDeactivates: false,
+      allowOutsideClick: true,
+      fallbackFocus: () => el
+    };
+    let autofocusEl = el.querySelector("[autofocus]");
+    if (autofocusEl)
+      options.initialFocus = autofocusEl;
+    let trap = createFocusTrap(el, options);
+    let undoInert = () => {
+    };
+    let undoDisableScrolling = () => {
+    };
+    const releaseFocus = () => {
+      undoInert();
+      undoInert = () => {
+      };
+      undoDisableScrolling();
+      undoDisableScrolling = () => {
+      };
+      trap.deactivate({
+        returnFocus: !modifiers.includes("noreturn")
+      });
+    };
+    effect(() => evaluator((value) => {
+      if (oldValue === value)
+        return;
+      if (value && !oldValue) {
+        setTimeout(() => {
+          if (modifiers.includes("inert"))
+            undoInert = setInert(el);
+          if (modifiers.includes("noscroll"))
+            undoDisableScrolling = disableScrolling();
+          trap.activate();
+        });
+      }
+      if (!value && oldValue) {
+        releaseFocus();
+      }
+      oldValue = !!value;
+    }));
+    cleanup(releaseFocus);
+  }, (el, {expression, modifiers}, {evaluate}) => {
+    if (modifiers.includes("inert") && evaluate(expression))
+      setInert(el);
+  }));
+}
+function setInert(el) {
+  let undos = [];
+  crawlSiblingsUp(el, (sibling) => {
+    let cache = sibling.hasAttribute("aria-hidden");
+    sibling.setAttribute("aria-hidden", "true");
+    undos.push(() => cache || sibling.removeAttribute("aria-hidden"));
+  });
+  return () => {
+    while (undos.length)
+      undos.pop()();
+  };
+}
+function crawlSiblingsUp(el, callback) {
+  if (el.isSameNode(document.body) || !el.parentNode)
+    return;
+  Array.from(el.parentNode.children).forEach((sibling) => {
+    if (sibling.isSameNode(el)) {
+      crawlSiblingsUp(el.parentNode, callback);
+    } else {
+      callback(sibling);
+    }
+  });
+}
+function disableScrolling() {
+  let overflow = document.documentElement.style.overflow;
+  let paddingRight = document.documentElement.style.paddingRight;
+  let scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+  document.documentElement.style.overflow = "hidden";
+  document.documentElement.style.paddingRight = `${scrollbarWidth}px`;
+  return () => {
+    document.documentElement.style.overflow = overflow;
+    document.documentElement.style.paddingRight = paddingRight;
+  };
+}
+
+// packages/focus/builds/module.js
+var module_default = src_default;
+export {
+  module_default as default
+};

Optimized Atomcms daily updated/node_modules/@alpinejs/focus/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "@alpinejs/focus",
+    "version": "3.12.2",
+    "description": "Manage focus within a page",
+    "homepage": "https://alpinejs.dev/plugins/focus",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/alpinejs/alpine.git",
+        "directory": "packages/focus"
+    },
+    "author": "Caleb Porzio",
+    "license": "MIT",
+    "main": "dist/module.cjs.js",
+    "module": "dist/module.esm.js",
+    "unpkg": "dist/cdn.min.js",
+    "dependencies": {
+        "focus-trap": "^6.6.1"
+    }
+}

Optimized Atomcms daily updated/node_modules/@alpinejs/focus/src/index.js

@@ -0,0 +1,205 @@
+import { createFocusTrap } from 'focus-trap'
+import { focusable, isFocusable } from 'tabbable'
+
+export default function (Alpine) {
+    let lastFocused
+    let currentFocused
+
+    window.addEventListener('focusin', () => {
+        lastFocused = currentFocused
+        currentFocused = document.activeElement
+    })
+
+    Alpine.magic('focus', el => {
+        let within = el
+
+        return {
+            __noscroll: false,
+            __wrapAround: false,
+            within(el) { within = el; return this },
+            withoutScrolling() { this.__noscroll = true; return this },
+            noscroll() { this.__noscroll = true; return this },
+            withWrapAround() { this.__wrapAround = true; return this },
+            wrap() { return this.withWrapAround() },
+            focusable(el) {
+                return isFocusable(el)
+            },
+            previouslyFocused() {
+                return lastFocused
+            },
+            lastFocused() {
+                return lastFocused
+            },
+            focused() {
+                return currentFocused
+            },
+            focusables() {
+                if (Array.isArray(within)) return within
+
+                return focusable(within, { displayCheck: 'none' })
+            },
+            all() { return this.focusables() },
+            isFirst(el) {
+                let els = this.all()
+
+                return els[0] && els[0].isSameNode(el)
+            },
+            isLast(el) {
+                let els = this.all()
+
+                return els.length && els.slice(-1)[0].isSameNode(el)
+            },
+            getFirst() { return this.all()[0] },
+            getLast() { return this.all().slice(-1)[0] },
+            getNext() {
+                let list = this.all()
+                let current = document.activeElement
+
+                // Can't find currently focusable element in list.
+                if (list.indexOf(current) === -1) return
+
+                // This is the last element in the list and we want to wrap around.
+                if (this.__wrapAround && list.indexOf(current) === list.length - 1) {
+                    return list[0]
+                }
+
+                return list[list.indexOf(current) + 1]
+            },
+            getPrevious() {
+                let list = this.all()
+                let current = document.activeElement
+
+                // Can't find currently focusable element in list.
+                if (list.indexOf(current) === -1) return
+
+                // This is the first element in the list and we want to wrap around.
+                if (this.__wrapAround && list.indexOf(current) === 0) {
+                    return list.slice(-1)[0]
+                }
+
+                return list[list.indexOf(current) - 1]
+            },
+            first() { this.focus(this.getFirst()) },
+            last() { this.focus(this.getLast()) },
+            next() { this.focus(this.getNext()) },
+            previous() { this.focus(this.getPrevious()) },
+            prev() { return this.previous() },
+            focus(el) {
+                if (! el) return
+
+                setTimeout(() => {
+                    if (! el.hasAttribute('tabindex')) el.setAttribute('tabindex', '0')
+
+                    el.focus({ preventScroll: this._noscroll })
+                })
+            }
+        }
+    })
+
+    Alpine.directive('trap', Alpine.skipDuringClone(
+        (el, { expression, modifiers }, { effect, evaluateLater, cleanup }) => {
+            let evaluator = evaluateLater(expression)
+
+            let oldValue = false
+
+            let options = {
+                escapeDeactivates: false,
+                allowOutsideClick: true,
+                fallbackFocus: () => el,
+            }
+
+            let autofocusEl = el.querySelector('[autofocus]')
+
+            if (autofocusEl) options.initialFocus = autofocusEl
+
+            let trap = createFocusTrap(el, options)
+
+            let undoInert = () => {}
+            let undoDisableScrolling = () => {}
+
+            const releaseFocus = () => {
+                undoInert()
+                undoInert = () => {}
+
+                undoDisableScrolling()
+                undoDisableScrolling = () => {}
+
+                trap.deactivate({
+                    returnFocus: !modifiers.includes('noreturn')
+                })
+            }
+
+            effect(() => evaluator(value => {
+                if (oldValue === value) return
+
+                // Start trapping.
+                if (value && ! oldValue) {
+                    setTimeout(() => {
+                        if (modifiers.includes('inert')) undoInert = setInert(el)
+                        if (modifiers.includes('noscroll')) undoDisableScrolling = disableScrolling()
+
+                        trap.activate()
+                    });
+                }
+
+                // Stop trapping.
+                if (! value && oldValue) {
+                    releaseFocus()
+                }
+
+                oldValue = !! value
+            }))
+
+            cleanup(releaseFocus)
+        },
+        // When cloning, we only want to add aria-hidden attributes to the
+        // DOM and not try to actually trap, as trapping can mess with the
+        // live DOM and isn't just isolated to the cloned DOM.
+        (el, { expression, modifiers }, { evaluate }) => {
+            if (modifiers.includes('inert') && evaluate(expression)) setInert(el)
+        },
+    ))
+}
+
+function setInert(el) {
+    let undos = []
+
+    crawlSiblingsUp(el, (sibling) => {
+        let cache = sibling.hasAttribute('aria-hidden')
+
+        sibling.setAttribute('aria-hidden', 'true')
+
+        undos.push(() => cache || sibling.removeAttribute('aria-hidden'))
+    })
+
+    return () => {
+        while(undos.length) undos.pop()()
+    }
+}
+
+function crawlSiblingsUp(el, callback) {
+    if (el.isSameNode(document.body) || ! el.parentNode) return
+
+    Array.from(el.parentNode.children).forEach(sibling => {
+        if (sibling.isSameNode(el)) {
+            crawlSiblingsUp(el.parentNode, callback)
+        } else {
+            callback(sibling)
+        }
+    })
+}
+
+function disableScrolling() {
+    let overflow = document.documentElement.style.overflow
+    let paddingRight = document.documentElement.style.paddingRight
+
+    let scrollbarWidth = window.innerWidth - document.documentElement.clientWidth
+
+    document.documentElement.style.overflow = 'hidden'
+    document.documentElement.style.paddingRight = `${scrollbarWidth}px`
+
+    return () => {
+        document.documentElement.style.overflow = overflow
+        document.documentElement.style.paddingRight = paddingRight
+    }
+}

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/README.md

@@ -0,0 +1,19 @@
+# @babel/runtime-corejs3
+
+> babel's modular runtime helpers with core-js@3 polyfilling
+
+See our website [@babel/runtime-corejs3](https://babeljs.io/docs/babel-runtime-corejs3) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/runtime-corejs3
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/runtime-corejs3
+```

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/array/from.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/array/from");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/array/is-array.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/array/is-array");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/array/of.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/array/of");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/clear-immediate.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/clear-immediate");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/date/now.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/date/now");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/bind.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/bind");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/code-point-at.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/code-point-at");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/concat.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/concat");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/copy-within.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/copy-within");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/ends-with.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/ends-with");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/entries.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/entries");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/every.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/every");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/fill.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/fill");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/filter.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/filter");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/find-index.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/find-index");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/find.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/find");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/flags.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/flags");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/flat-map.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/flat-map");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/flat.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/flat");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/for-each.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/for-each");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/includes.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/includes");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/index-of.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/index-of");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/keys.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/keys");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/last-index-of.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/last-index-of");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/map.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/map");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/pad-end.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/pad-end");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/pad-start.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/pad-start");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/reduce-right.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/reduce-right");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/reduce.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/reduce");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/repeat.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/repeat");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/reverse.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/reverse");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/slice.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/slice");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/some.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/some");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/sort.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/sort");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/splice.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/splice");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/starts-with.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/starts-with");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/trim-end.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/trim-end");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/trim-left.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/trim-left");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/trim-right.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/trim-right");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/trim-start.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/trim-start");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/trim.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/trim");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/instance/values.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/instance/values");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/json/stringify.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/json/stringify");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/map.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/map");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/math/acosh.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/math/acosh");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/math/asinh.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/math/asinh");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/math/atanh.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/math/atanh");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/math/cbrt.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/math/cbrt");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/math/clz32.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/math/clz32");

Optimized Atomcms daily updated/node_modules/@babel/runtime-corejs3/core-js-stable/math/cosh.js

@@ -0,0 +1 @@
+module.exports = require("core-js-pure/stable/math/cosh");