@moonwalker/artemis-content - npm Package Compare versions

Comparing version 0.1.9 to 0.1.10

dist/main.js

@@ -0,10 +1,919 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/index.js
+var require_out = __commonJS({
+  "../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/index.js"(exports, module) {
+    "use strict";
+    var taskManager = __require("../../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/managers/tasks");
+    var patternManager = __require("../../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/managers/patterns");
+    var async_1 = __require("../../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/async");
+    var stream_1 = __require("../../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/stream");
+    var sync_1 = __require("../../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/sync");
+    var settings_1 = __require("../../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/settings");
+    var utils = __require("../../../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/utils");
+    async function FastGlob(source, options) {
+      assertPatternsInput(source);
+      const works = getWorks(source, async_1.default, options);
+      const result = await Promise.all(works);
+      return utils.array.flatten(result);
+    }
+    (function(FastGlob2) {
+      function sync(source, options) {
+        assertPatternsInput(source);
+        const works = getWorks(source, sync_1.default, options);
+        return utils.array.flatten(works);
+      }
+      FastGlob2.sync = sync;
+      function stream(source, options) {
+        assertPatternsInput(source);
+        const works = getWorks(source, stream_1.default, options);
+        return utils.stream.merge(works);
+      }
+      FastGlob2.stream = stream;
+      function generateTasks(source, options) {
+        assertPatternsInput(source);
+        const patterns = patternManager.transform([].concat(source));
+        const settings = new settings_1.default(options);
+        return taskManager.generate(patterns, settings);
+      }
+      FastGlob2.generateTasks = generateTasks;
+      function isDynamicPattern(source, options) {
+        assertPatternsInput(source);
+        const settings = new settings_1.default(options);
+        return utils.pattern.isDynamicPattern(source, settings);
+      }
+      FastGlob2.isDynamicPattern = isDynamicPattern;
+      function escapePath(source) {
+        assertPatternsInput(source);
+        return utils.path.escape(source);
+      }
+      FastGlob2.escapePath = escapePath;
+    })(FastGlob || (FastGlob = {}));
+    function getWorks(source, _Provider, options) {
+      const patterns = patternManager.transform([].concat(source));
+      const settings = new settings_1.default(options);
+      const tasks = taskManager.generate(patterns, settings);
+      const provider = new _Provider(settings);
+      return tasks.map(provider.read, provider);
+    }
+    function assertPatternsInput(input) {
+      const source = [].concat(input);
+      const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
+      if (!isValidSource) {
+        throw new TypeError("Patterns must be a string (non empty) or an array of strings");
+      }
+    }
+    module.exports = FastGlob;
+  }
+});
+
+// ../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js
+var require_gray_matter = __commonJS({
+  "../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var sections = __require("../../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/section-matter/index.js");
+    var defaults = __require("../../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults");
+    var stringify = __require("../../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify");
+    var excerpt = __require("../../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt");
+    var engines = __require("../../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines");
+    var toFile = __require("../../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file");
+    var parse2 = __require("../../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse");
+    var utils = __require("../../../node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils");
+    function matter2(input, options) {
+      if (input === "") {
+        return { data: {}, content: input, excerpt: "", orig: input };
+      }
+      let file = toFile(input);
+      const cached = matter2.cache[file.content];
+      if (!options) {
+        if (cached) {
+          file = Object.assign({}, cached);
+          file.orig = cached.orig;
+          return file;
+        }
+        matter2.cache[file.content] = file;
+      }
+      return parseMatter(file, options);
+    }
+    function parseMatter(file, options) {
+      const opts = defaults(options);
+      const open = opts.delimiters[0];
+      const close = "\n" + opts.delimiters[1];
+      let str = file.content;
+      if (opts.language) {
+        file.language = opts.language;
+      }
+      const openLen = open.length;
+      if (!utils.startsWith(str, open, openLen)) {
+        excerpt(file, opts);
+        return file;
+      }
+      if (str.charAt(openLen) === open.slice(-1)) {
+        return file;
+      }
+      str = str.slice(openLen);
+      const len = str.length;
+      const language = matter2.language(str, opts);
+      if (language.name) {
+        file.language = language.name;
+        str = str.slice(language.raw.length);
+      }
+      let closeIndex = str.indexOf(close);
+      if (closeIndex === -1) {
+        closeIndex = len;
+      }
+      file.matter = str.slice(0, closeIndex);
+      const block = file.matter.replace(/^\s*#[^\n]+/gm, "").trim();
+      if (block === "") {
+        file.isEmpty = true;
+        file.empty = file.content;
+        file.data = {};
+      } else {
+        file.data = parse2(file.language, file.matter, opts);
+      }
+      if (closeIndex === len) {
+        file.content = "";
+      } else {
+        file.content = str.slice(closeIndex + close.length);
+        if (file.content[0] === "\r") {
+          file.content = file.content.slice(1);
+        }
+        if (file.content[0] === "\n") {
+          file.content = file.content.slice(1);
+        }
+      }
+      excerpt(file, opts);
+      if (opts.sections === true || typeof opts.section === "function") {
+        sections(file, opts.section);
+      }
+      return file;
+    }
+    matter2.engines = engines;
+    matter2.stringify = function(file, data, options) {
+      if (typeof file === "string")
+        file = matter2(file, options);
+      return stringify(file, data, options);
+    };
+    matter2.read = function(filepath, options) {
+      const str = fs.readFileSync(filepath, "utf8");
+      const file = matter2(str, options);
+      file.path = filepath;
+      return file;
+    };
+    matter2.test = function(str, options) {
+      return utils.startsWith(str, defaults(options).delimiters[0]);
+    };
+    matter2.language = function(str, options) {
+      const opts = defaults(options);
+      const open = opts.delimiters[0];
+      if (matter2.test(str)) {
+        str = str.slice(open.length);
+      }
+      const language = str.slice(0, str.search(/\r?\n/));
+      return {
+        raw: language,
+        name: language ? language.trim() : ""
+      };
+    };
+    matter2.cache = {};
+    matter2.clearCache = function() {
+      matter2.cache = {};
+    };
+    module.exports = matter2;
+  }
+});
+
+// ../../node_modules/.pnpm/chokidar@3.5.3/node_modules/chokidar/index.js
+var require_chokidar = __commonJS({
+  "../../node_modules/.pnpm/chokidar@3.5.3/node_modules/chokidar/index.js"(exports) {
+    "use strict";
+    var { EventEmitter } = __require("events");
+    var fs = __require("fs");
+    var sysPath = __require("path");
+    var { promisify } = __require("util");
+    var readdirp = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/readdirp/index.js");
+    var anymatch = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/anymatch/index.js").default;
+    var globParent = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/glob-parent/index.js");
+    var isGlob = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/is-glob/index.js");
+    var braces = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/braces/index.js");
+    var normalizePath = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/normalize-path/index.js");
+    var NodeFsHandler = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/chokidar/lib/nodefs-handler");
+    var FsEventsHandler = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/chokidar/lib/fsevents-handler");
+    var {
+      EV_ALL,
+      EV_READY,
+      EV_ADD,
+      EV_CHANGE,
+      EV_UNLINK,
+      EV_ADD_DIR,
+      EV_UNLINK_DIR,
+      EV_RAW,
+      EV_ERROR,
+      STR_CLOSE,
+      STR_END,
+      BACK_SLASH_RE,
+      DOUBLE_SLASH_RE,
+      SLASH_OR_BACK_SLASH_RE,
+      DOT_RE,
+      REPLACER_RE,
+      SLASH,
+      SLASH_SLASH,
+      BRACE_START,
+      BANG,
+      ONE_DOT,
+      TWO_DOTS,
+      GLOBSTAR,
+      SLASH_GLOBSTAR,
+      ANYMATCH_OPTS,
+      STRING_TYPE,
+      FUNCTION_TYPE,
+      EMPTY_STR,
+      EMPTY_FN,
+      isWindows,
+      isMacos,
+      isIBMi
+    } = __require("../../../node_modules/.pnpm/chokidar@3.5.3/node_modules/chokidar/lib/constants");
+    var stat2 = promisify(fs.stat);
+    var readdir = promisify(fs.readdir);
+    var arrify = (value = []) => Array.isArray(value) ? value : [value];
+    var flatten = (list, result = []) => {
+      list.forEach((item) => {
+        if (Array.isArray(item)) {
+          flatten(item, result);
+        } else {
+          result.push(item);
+        }
+      });
+      return result;
+    };
+    var unifyPaths = (paths_) => {
+      const paths = flatten(arrify(paths_));
+      if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+      }
+      return paths.map(normalizePathToUnix);
+    };
+    var toUnix = (string) => {
+      let str = string.replace(BACK_SLASH_RE, SLASH);
+      let prepend = false;
+      if (str.startsWith(SLASH_SLASH)) {
+        prepend = true;
+      }
+      while (str.match(DOUBLE_SLASH_RE)) {
+        str = str.replace(DOUBLE_SLASH_RE, SLASH);
+      }
+      if (prepend) {
+        str = SLASH + str;
+      }
+      return str;
+    };
+    var normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+    var normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
+      if (typeof path !== STRING_TYPE)
+        return path;
+      return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+    };
+    var getAbsolutePath = (path, cwd) => {
+      if (sysPath.isAbsolute(path)) {
+        return path;
+      }
+      if (path.startsWith(BANG)) {
+        return BANG + sysPath.join(cwd, path.slice(1));
+      }
+      return sysPath.join(cwd, path);
+    };
+    var undef = (opts, key) => opts[key] === void 0;
+    var DirEntry = class {
+      constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = /* @__PURE__ */ new Set();
+      }
+      add(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        if (item !== ONE_DOT && item !== TWO_DOTS)
+          items.add(item);
+      }
+      async remove(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        items.delete(item);
+        if (items.size > 0)
+          return;
+        const dir = this.path;
+        try {
+          await readdir(dir);
+        } catch (err) {
+          if (this._removeWatcher) {
+            this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+          }
+        }
+      }
+      has(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        return items.has(item);
+      }
+      getChildren() {
+        const { items } = this;
+        if (!items)
+          return;
+        return [...items.values()];
+      }
+      dispose() {
+        this.items.clear();
+        delete this.path;
+        delete this._removeWatcher;
+        delete this.items;
+        Object.freeze(this);
+      }
+    };
+    var STAT_METHOD_F = "stat";
+    var STAT_METHOD_L = "lstat";
+    var WatchHelper = class {
+      constructor(path, watchPath, follow, fsw) {
+        this.fsw = fsw;
+        this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
+        this.watchPath = watchPath;
+        this.fullWatchPath = sysPath.resolve(watchPath);
+        this.hasGlob = watchPath !== path;
+        if (path === EMPTY_STR)
+          this.hasGlob = false;
+        this.globSymlink = this.hasGlob && follow ? void 0 : false;
+        this.globFilter = this.hasGlob ? anymatch(path, void 0, ANYMATCH_OPTS) : false;
+        this.dirParts = this.getDirParts(path);
+        this.dirParts.forEach((parts) => {
+          if (parts.length > 1)
+            parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+      }
+      checkGlobSymlink(entry) {
+        if (this.globSymlink === void 0) {
+          this.globSymlink = entry.fullParentDir === this.fullWatchPath ? false : { realPath: entry.fullParentDir, linkPath: this.fullWatchPath };
+        }
+        if (this.globSymlink) {
+          return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
+        }
+        return entry.fullPath;
+      }
+      entryPath(entry) {
+        return sysPath.join(
+          this.watchPath,
+          sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
+        );
+      }
+      filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink())
+          return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ? this.globFilter(resolvedPath) : true;
+        return matchesGlob && this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+      }
+      getDirParts(path) {
+        if (!this.hasGlob)
+          return [];
+        const parts = [];
+        const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
+        expandedPath.forEach((path2) => {
+          parts.push(sysPath.relative(this.watchPath, path2).split(SLASH_OR_BACK_SLASH_RE));
+        });
+        return parts;
+      }
+      filterDir(entry) {
+        if (this.hasGlob) {
+          const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
+          let globstar = false;
+          this.unmatchedGlob = !this.dirParts.some((parts) => {
+            return parts.every((part, i) => {
+              if (part === GLOBSTAR)
+                globstar = true;
+              return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
+            });
+          });
+        }
+        return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+      }
+    };
+    var FSWatcher = class extends EventEmitter {
+      constructor(_opts) {
+        super();
+        const opts = {};
+        if (_opts)
+          Object.assign(opts, _opts);
+        this._watched = /* @__PURE__ */ new Map();
+        this._closers = /* @__PURE__ */ new Map();
+        this._ignoredPaths = /* @__PURE__ */ new Set();
+        this._throttled = /* @__PURE__ */ new Map();
+        this._symlinkPaths = /* @__PURE__ */ new Map();
+        this._streams = /* @__PURE__ */ new Set();
+        this.closed = false;
+        if (undef(opts, "persistent"))
+          opts.persistent = true;
+        if (undef(opts, "ignoreInitial"))
+          opts.ignoreInitial = false;
+        if (undef(opts, "ignorePermissionErrors"))
+          opts.ignorePermissionErrors = false;
+        if (undef(opts, "interval"))
+          opts.interval = 100;
+        if (undef(opts, "binaryInterval"))
+          opts.binaryInterval = 300;
+        if (undef(opts, "disableGlobbing"))
+          opts.disableGlobbing = false;
+        opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
+        if (undef(opts, "useFsEvents"))
+          opts.useFsEvents = !opts.usePolling;
+        const canUseFsEvents = FsEventsHandler.canUse();
+        if (!canUseFsEvents)
+          opts.useFsEvents = false;
+        if (undef(opts, "usePolling") && !opts.useFsEvents) {
+          opts.usePolling = isMacos;
+        }
+        if (isIBMi) {
+          opts.usePolling = true;
+        }
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== void 0) {
+          const envLower = envPoll.toLowerCase();
+          if (envLower === "false" || envLower === "0") {
+            opts.usePolling = false;
+          } else if (envLower === "true" || envLower === "1") {
+            opts.usePolling = true;
+          } else {
+            opts.usePolling = !!envLower;
+          }
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval) {
+          opts.interval = Number.parseInt(envInterval, 10);
+        }
+        if (undef(opts, "atomic"))
+          opts.atomic = !opts.usePolling && !opts.useFsEvents;
+        if (opts.atomic)
+          this._pendingUnlinks = /* @__PURE__ */ new Map();
+        if (undef(opts, "followSymlinks"))
+          opts.followSymlinks = true;
+        if (undef(opts, "awaitWriteFinish"))
+          opts.awaitWriteFinish = false;
+        if (opts.awaitWriteFinish === true)
+          opts.awaitWriteFinish = {};
+        const awf = opts.awaitWriteFinish;
+        if (awf) {
+          if (!awf.stabilityThreshold)
+            awf.stabilityThreshold = 2e3;
+          if (!awf.pollInterval)
+            awf.pollInterval = 100;
+          this._pendingWrites = /* @__PURE__ */ new Map();
+        }
+        if (opts.ignored)
+          opts.ignored = arrify(opts.ignored);
+        let readyCalls = 0;
+        this._emitReady = () => {
+          readyCalls++;
+          if (readyCalls >= this._readyCount) {
+            this._emitReady = EMPTY_FN;
+            this._readyEmitted = true;
+            process.nextTick(() => this.emit(EV_READY));
+          }
+        };
+        this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
+        this._readyEmitted = false;
+        this.options = opts;
+        if (opts.useFsEvents) {
+          this._fsEventsHandler = new FsEventsHandler(this);
+        } else {
+          this._nodeFsHandler = new NodeFsHandler(this);
+        }
+        Object.freeze(opts);
+      }
+      add(paths_, _origAdd, _internal) {
+        const { cwd, disableGlobbing } = this.options;
+        this.closed = false;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+          paths = paths.map((path) => {
+            const absPath = getAbsolutePath(path, cwd);
+            if (disableGlobbing || !isGlob(path)) {
+              return absPath;
+            }
+            return normalizePath(absPath);
+          });
+        }
+        paths = paths.filter((path) => {
+          if (path.startsWith(BANG)) {
+            this._ignoredPaths.add(path.slice(1));
+            return false;
+          }
+          this._ignoredPaths.delete(path);
+          this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
+          this._userIgnored = void 0;
+          return true;
+        });
+        if (this.options.useFsEvents && this._fsEventsHandler) {
+          if (!this._readyCount)
+            this._readyCount = paths.length;
+          if (this.options.persistent)
+            this._readyCount *= 2;
+          paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
+        } else {
+          if (!this._readyCount)
+            this._readyCount = 0;
+          this._readyCount += paths.length;
+          Promise.all(
+            paths.map(async (path) => {
+              const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
+              if (res)
+                this._emitReady();
+              return res;
+            })
+          ).then((results) => {
+            if (this.closed)
+              return;
+            results.filter((item) => item).forEach((item) => {
+              this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+            });
+          });
+        }
+        return this;
+      }
+      unwatch(paths_) {
+        if (this.closed)
+          return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path) => {
+          if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+            if (cwd)
+              path = sysPath.join(cwd, path);
+            path = sysPath.resolve(path);
+          }
+          this._closePath(path);
+          this._ignoredPaths.add(path);
+          if (this._watched.has(path)) {
+            this._ignoredPaths.add(path + SLASH_GLOBSTAR);
+          }
+          this._userIgnored = void 0;
+        });
+        return this;
+      }
+      close() {
+        if (this.closed)
+          return this._closePromise;
+        this.closed = true;
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) => closerList.forEach((closer) => {
+          const promise = closer();
+          if (promise instanceof Promise)
+            closers.push(promise);
+        }));
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = void 0;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        ["closers", "watched", "streams", "symlinkPaths", "throttled"].forEach((key) => {
+          this[`_${key}`].clear();
+        });
+        this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+        return this._closePromise;
+      }
+      getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+          const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+          watchList[key || ONE_DOT] = entry.getChildren().sort();
+        });
+        return watchList;
+      }
+      emitWithAll(event, args) {
+        this.emit(...args);
+        if (event !== EV_ERROR)
+          this.emit(EV_ALL, ...args);
+      }
+      async _emit(event, path, val1, val2, val3) {
+        if (this.closed)
+          return;
+        const opts = this.options;
+        if (isWindows)
+          path = sysPath.normalize(path);
+        if (opts.cwd)
+          path = sysPath.relative(opts.cwd, path);
+        const args = [event, path];
+        if (val3 !== void 0)
+          args.push(val1, val2, val3);
+        else if (val2 !== void 0)
+          args.push(val1, val2);
+        else if (val1 !== void 0)
+          args.push(val1);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path))) {
+          pw.lastChange = new Date();
+          return this;
+        }
+        if (opts.atomic) {
+          if (event === EV_UNLINK) {
+            this._pendingUnlinks.set(path, args);
+            setTimeout(() => {
+              this._pendingUnlinks.forEach((entry, path2) => {
+                this.emit(...entry);
+                this.emit(EV_ALL, ...entry);
+                this._pendingUnlinks.delete(path2);
+              });
+            }, typeof opts.atomic === "number" ? opts.atomic : 100);
+            return this;
+          }
+          if (event === EV_ADD && this._pendingUnlinks.has(path)) {
+            event = args[0] = EV_CHANGE;
+            this._pendingUnlinks.delete(path);
+          }
+        }
+        if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
+          const awfEmit = (err, stats) => {
+            if (err) {
+              event = args[0] = EV_ERROR;
+              args[1] = err;
+              this.emitWithAll(event, args);
+            } else if (stats) {
+              if (args.length > 2) {
+                args[2] = stats;
+              } else {
+                args.push(stats);
+              }
+              this.emitWithAll(event, args);
+            }
+          };
+          this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+          return this;
+        }
+        if (event === EV_CHANGE) {
+          const isThrottled = !this._throttle(EV_CHANGE, path, 50);
+          if (isThrottled)
+            return this;
+        }
+        if (opts.alwaysStat && val1 === void 0 && (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)) {
+          const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+          let stats;
+          try {
+            stats = await stat2(fullPath);
+          } catch (err) {
+          }
+          if (!stats || this.closed)
+            return;
+          args.push(stats);
+        }
+        this.emitWithAll(event, args);
+        return this;
+      }
+      _handleError(error) {
+        const code = error && error.code;
+        if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+          this.emit(EV_ERROR, error);
+        }
+        return error || this.closed;
+      }
+      _throttle(actionType, path, timeout) {
+        if (!this._throttled.has(actionType)) {
+          this._throttled.set(actionType, /* @__PURE__ */ new Map());
+        }
+        const action = this._throttled.get(actionType);
+        const actionPath = action.get(path);
+        if (actionPath) {
+          actionPath.count++;
+          return false;
+        }
+        let timeoutObject;
+        const clear = () => {
+          const item = action.get(path);
+          const count = item ? item.count : 0;
+          action.delete(path);
+          clearTimeout(timeoutObject);
+          if (item)
+            clearTimeout(item.timeoutObject);
+          return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path, thr);
+        return thr;
+      }
+      _incrReadyCount() {
+        return this._readyCount++;
+      }
+      _awaitWriteFinish(path, threshold, event, awfEmit) {
+        let timeoutHandler;
+        let fullPath = path;
+        if (this.options.cwd && !sysPath.isAbsolute(path)) {
+          fullPath = sysPath.join(this.options.cwd, path);
+        }
+        const now = new Date();
+        const awaitWriteFinish = (prevStat) => {
+          fs.stat(fullPath, (err, curStat) => {
+            if (err || !this._pendingWrites.has(path)) {
+              if (err && err.code !== "ENOENT")
+                awfEmit(err);
+              return;
+            }
+            const now2 = Number(new Date());
+            if (prevStat && curStat.size !== prevStat.size) {
+              this._pendingWrites.get(path).lastChange = now2;
+            }
+            const pw = this._pendingWrites.get(path);
+            const df = now2 - pw.lastChange;
+            if (df >= threshold) {
+              this._pendingWrites.delete(path);
+              awfEmit(void 0, curStat);
+            } else {
+              timeoutHandler = setTimeout(
+                awaitWriteFinish,
+                this.options.awaitWriteFinish.pollInterval,
+                curStat
+              );
+            }
+          });
+        };
+        if (!this._pendingWrites.has(path)) {
+          this._pendingWrites.set(path, {
+            lastChange: now,
+            cancelWait: () => {
+              this._pendingWrites.delete(path);
+              clearTimeout(timeoutHandler);
+              return event;
+            }
+          });
+          timeoutHandler = setTimeout(
+            awaitWriteFinish,
+            this.options.awaitWriteFinish.pollInterval
+          );
+        }
+      }
+      _getGlobIgnored() {
+        return [...this._ignoredPaths.values()];
+      }
+      _isIgnored(path, stats) {
+        if (this.options.atomic && DOT_RE.test(path))
+          return true;
+        if (!this._userIgnored) {
+          const { cwd } = this.options;
+          const ign = this.options.ignored;
+          const ignored = ign && ign.map(normalizeIgnored(cwd));
+          const paths = arrify(ignored).filter((path2) => typeof path2 === STRING_TYPE && !isGlob(path2)).map((path2) => path2 + SLASH_GLOBSTAR);
+          const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
+          this._userIgnored = anymatch(list, void 0, ANYMATCH_OPTS);
+        }
+        return this._userIgnored([path, stats]);
+      }
+      _isntIgnored(path, stat3) {
+        return !this._isIgnored(path, stat3);
+      }
+      _getWatchHelpers(path, depth) {
+        const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
+        const follow = this.options.followSymlinks;
+        return new WatchHelper(path, watchPath, follow, this);
+      }
+      _getWatchedDir(directory) {
+        if (!this._boundRemove)
+          this._boundRemove = this._remove.bind(this);
+        const dir = sysPath.resolve(directory);
+        if (!this._watched.has(dir))
+          this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+      }
+      _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors)
+          return true;
+        const md = stats && Number.parseInt(stats.mode, 10);
+        const st = md & 511;
+        const it = Number.parseInt(st.toString(8)[0], 10);
+        return Boolean(4 & it);
+      }
+      _remove(directory, item, isDirectory) {
+        const path = sysPath.join(directory, item);
+        const fullPath = sysPath.resolve(path);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path, 100))
+          return;
+        if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
+          this.add(directory, item, true);
+        }
+        const wp = this._getWatchedDir(path);
+        const nestedDirectoryChildren = wp.getChildren();
+        nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+        const parent = this._getWatchedDir(directory);
+        const wasTracked = parent.has(item);
+        parent.remove(item);
+        if (this._symlinkPaths.has(fullPath)) {
+          this._symlinkPaths.delete(fullPath);
+        }
+        let relPath = path;
+        if (this.options.cwd)
+          relPath = sysPath.relative(this.options.cwd, path);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+          const event = this._pendingWrites.get(relPath).cancelWait();
+          if (event === EV_ADD)
+            return;
+        }
+        this._watched.delete(path);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
+        if (wasTracked && !this._isIgnored(path))
+          this._emit(eventName, path);
+        if (!this.options.useFsEvents) {
+          this._closePath(path);
+        }
+      }
+      _closePath(path) {
+        this._closeFile(path);
+        const dir = sysPath.dirname(path);
+        this._getWatchedDir(dir).remove(sysPath.basename(path));
+      }
+      _closeFile(path) {
+        const closers = this._closers.get(path);
+        if (!closers)
+          return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path);
+      }
+      _addPathCloser(path, closer) {
+        if (!closer)
+          return;
+        let list = this._closers.get(path);
+        if (!list) {
+          list = [];
+          this._closers.set(path, list);
+        }
+        list.push(closer);
+      }
+      _readdirp(root, opts) {
+        if (this.closed)
+          return;
+        const options = { type: EV_ALL, alwaysStat: true, lstat: true, ...opts };
+        let stream = readdirp(root, options);
+        this._streams.add(stream);
+        stream.once(STR_CLOSE, () => {
+          stream = void 0;
+        });
+        stream.once(STR_END, () => {
+          if (stream) {
+            this._streams.delete(stream);
+            stream = void 0;
+          }
+        });
+        return stream;
+      }
+    };
+    exports.FSWatcher = FSWatcher;
+    var watch2 = (paths, options) => {
+      const watcher = new FSWatcher(options);
+      watcher.add(paths);
+      return watcher;
+    };
+    exports.watch = watch2;
+  }
+});
+
 // src/generate.js
+var import_fast_glob = __toESM(require_out(), 1);
+var import_gray_matter = __toESM(require_gray_matter(), 1);
+var import_chokidar = __toESM(require_chokidar(), 1);
 import { join, dirname, extname, basename, parse } from "path";
 import { stat, mkdir, readFile, writeFile, unlink } from "fs/promises";
 import { spawn } from "node:child_process";
-import fg from "../../../node_modules/fast-glob/out/index.js";
-import matter from "../../../node_modules/gray-matter/index.js";
-import chokidar from "../../../node_modules/chokidar/index.js";
 
-// node_modules/camelcase/index.js
+// ../../node_modules/.pnpm/camelcase@7.0.1/node_modules/camelcase/index.js
 var UPPERCASE = /[\p{Lu}]/u;
@@ -98,3 +1007,3 @@ var LOWERCASE = /[\p{Ll}]/u;
   });
-  const entries = await fg(patterns);
+  const entries = await (0, import_fast_glob.default)(patterns);
   entries.forEach((path) => {
@@ -127,3 +1036,3 @@ parseFile({ path, ...options });
     if (ext === ".md" || ext === ".mdx") {
-      const parsed = matter(data);
+      const parsed = (0, import_gray_matter.default)(data);
       const body = parsed.content.trim();
@@ -143,3 +1052,3 @@ data = { slug, ...parsed.data, body };
   let names = [];
-  const entries = await fg(join(outdir, "*.json"));
+  const entries = await (0, import_fast_glob.default)(join(outdir, "*.json"));
   entries.forEach((path) => {
@@ -166,3 +1075,3 @@ const name = camelCase(parse(path).name);
 var watch = ({ patterns, output }) => {
-  const watcher = chokidar.watch(patterns, {
+  const watcher = import_chokidar.default.watch(patterns, {
     ignored: /(^|[\/\\])\../,
@@ -169,0 +1078,0 @@ persistent: true

package.json

 {
   "name": "@moonwalker/artemis-content",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "type": "module",
   "main": "dist/main.js",
-  "scripts": {
-    "build": "esbuild src/index.js --bundle --platform=node --format=esm --external:../../node_modules/* --outfile=dist/main.js"
-  },
   "dependencies": {
@@ -17,3 +14,6 @@ "camelcase": "^7.0.0",
     "esbuild": "^0.16.4"
+  },
+  "scripts": {
+    "build": "esbuild src/index.js --bundle --platform=node --format=esm --external:../../node_modules/* --outfile=dist/main.js"
   }
-}
+}

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 2 instances in 1 package

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

No License Found

License

(Experimental) License information could not be found.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

42387

497.5%

Number of package files

4

33.33%

Number of low license alerts

0

-100%

Lines of code

1074

535.5%

Worsened metrics

Number of low supply chain risk alerts

7

250%

No dependency changes