astro-md-editor 0.0.1

package/.output/server/_libs/reselect.mjs

@@ -0,0 +1,326 @@
+var NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
+function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
+  if (typeof func !== "function") {
+    throw new TypeError(errorMessage);
+  }
+}
+function assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {
+  if (typeof object !== "object") {
+    throw new TypeError(errorMessage);
+  }
+}
+function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
+  if (!array.every((item) => typeof item === "function")) {
+    const itemTypes = array.map(
+      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
+    ).join(", ");
+    throw new TypeError(`${errorMessage}[${itemTypes}]`);
+  }
+}
+var ensureIsArray = (item) => {
+  return Array.isArray(item) ? item : [item];
+};
+function getDependencies(createSelectorArgs) {
+  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
+  assertIsArrayOfFunctions(
+    dependencies,
+    `createSelector expects all input-selectors to be functions, but received the following types: `
+  );
+  return dependencies;
+}
+function collectInputSelectorResults(dependencies, inputSelectorArgs) {
+  const inputSelectorResults = [];
+  const { length } = dependencies;
+  for (let i = 0; i < length; i++) {
+    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
+  }
+  return inputSelectorResults;
+}
+function createSingletonCache(equals) {
+  let entry;
+  return {
+    get(key) {
+      if (entry && equals(entry.key, key)) {
+        return entry.value;
+      }
+      return NOT_FOUND;
+    },
+    put(key, value) {
+      entry = { key, value };
+    },
+    getEntries() {
+      return entry ? [entry] : [];
+    },
+    clear() {
+      entry = void 0;
+    }
+  };
+}
+function createLruCache(maxSize, equals) {
+  let entries = [];
+  function get(key) {
+    const cacheIndex = entries.findIndex((entry) => equals(key, entry.key));
+    if (cacheIndex > -1) {
+      const entry = entries[cacheIndex];
+      if (cacheIndex > 0) {
+        entries.splice(cacheIndex, 1);
+        entries.unshift(entry);
+      }
+      return entry.value;
+    }
+    return NOT_FOUND;
+  }
+  function put(key, value) {
+    if (get(key) === NOT_FOUND) {
+      entries.unshift({ key, value });
+      if (entries.length > maxSize) {
+        entries.pop();
+      }
+    }
+  }
+  function getEntries() {
+    return entries;
+  }
+  function clear() {
+    entries = [];
+  }
+  return { get, put, getEntries, clear };
+}
+var referenceEqualityCheck = (a, b) => a === b;
+function createCacheKeyComparator(equalityCheck) {
+  return function areArgumentsShallowlyEqual(prev, next) {
+    if (prev === null || next === null || prev.length !== next.length) {
+      return false;
+    }
+    const { length } = prev;
+    for (let i = 0; i < length; i++) {
+      if (!equalityCheck(prev[i], next[i])) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function lruMemoize(func, equalityCheckOrOptions) {
+  const providedOptions = typeof equalityCheckOrOptions === "object" ? equalityCheckOrOptions : { equalityCheck: equalityCheckOrOptions };
+  const {
+    equalityCheck = referenceEqualityCheck,
+    maxSize = 1,
+    resultEqualityCheck
+  } = providedOptions;
+  const comparator = createCacheKeyComparator(equalityCheck);
+  let resultsCount = 0;
+  const cache = maxSize <= 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);
+  function memoized() {
+    let value = cache.get(arguments);
+    if (value === NOT_FOUND) {
+      value = func.apply(null, arguments);
+      resultsCount++;
+      if (resultEqualityCheck) {
+        const entries = cache.getEntries();
+        const matchingEntry = entries.find(
+          (entry) => resultEqualityCheck(entry.value, value)
+        );
+        if (matchingEntry) {
+          value = matchingEntry.value;
+          resultsCount !== 0 && resultsCount--;
+        }
+      }
+      cache.put(arguments, value);
+    }
+    return value;
+  }
+  memoized.clearCache = () => {
+    cache.clear();
+    memoized.resetResultsCount();
+  };
+  memoized.resultsCount = () => resultsCount;
+  memoized.resetResultsCount = () => {
+    resultsCount = 0;
+  };
+  return memoized;
+}
+var StrongRef = class {
+  constructor(value) {
+    this.value = value;
+  }
+  deref() {
+    return this.value;
+  }
+};
+var Ref = typeof WeakRef !== "undefined" ? WeakRef : StrongRef;
+var UNTERMINATED = 0;
+var TERMINATED = 1;
+function createCacheNode() {
+  return {
+    s: UNTERMINATED,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function weakMapMemoize(func, options = {}) {
+  let fnNode = createCacheNode();
+  const { resultEqualityCheck } = options;
+  let lastResult;
+  let resultsCount = 0;
+  function memoized() {
+    let cacheNode = fnNode;
+    const { length } = arguments;
+    for (let i = 0, l = length; i < l; i++) {
+      const arg = arguments[i];
+      if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
+        let objectCache = cacheNode.o;
+        if (objectCache === null) {
+          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();
+        }
+        const objectNode = objectCache.get(arg);
+        if (objectNode === void 0) {
+          cacheNode = createCacheNode();
+          objectCache.set(arg, cacheNode);
+        } else {
+          cacheNode = objectNode;
+        }
+      } else {
+        let primitiveCache = cacheNode.p;
+        if (primitiveCache === null) {
+          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();
+        }
+        const primitiveNode = primitiveCache.get(arg);
+        if (primitiveNode === void 0) {
+          cacheNode = createCacheNode();
+          primitiveCache.set(arg, cacheNode);
+        } else {
+          cacheNode = primitiveNode;
+        }
+      }
+    }
+    const terminatedNode = cacheNode;
+    let result;
+    if (cacheNode.s === TERMINATED) {
+      result = cacheNode.v;
+    } else {
+      result = func.apply(null, arguments);
+      resultsCount++;
+      if (resultEqualityCheck) {
+        const lastResultValue = lastResult?.deref?.() ?? lastResult;
+        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
+          result = lastResultValue;
+          resultsCount !== 0 && resultsCount--;
+        }
+        const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
+        lastResult = needsWeakRef ? new Ref(result) : result;
+      }
+    }
+    terminatedNode.s = TERMINATED;
+    terminatedNode.v = result;
+    return result;
+  }
+  memoized.clearCache = () => {
+    fnNode = createCacheNode();
+    memoized.resetResultsCount();
+  };
+  memoized.resultsCount = () => resultsCount;
+  memoized.resetResultsCount = () => {
+    resultsCount = 0;
+  };
+  return memoized;
+}
+function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
+  const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
+    memoize: memoizeOrOptions,
+    memoizeOptions: memoizeOptionsFromArgs
+  } : memoizeOrOptions;
+  const createSelector2 = (...createSelectorArgs) => {
+    let recomputations = 0;
+    let dependencyRecomputations = 0;
+    let lastResult;
+    let directlyPassedOptions = {};
+    let resultFunc = createSelectorArgs.pop();
+    if (typeof resultFunc === "object") {
+      directlyPassedOptions = resultFunc;
+      resultFunc = createSelectorArgs.pop();
+    }
+    assertIsFunction(
+      resultFunc,
+      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`
+    );
+    const combinedOptions = {
+      ...createSelectorCreatorOptions,
+      ...directlyPassedOptions
+    };
+    const {
+      memoize,
+      memoizeOptions = [],
+      argsMemoize = weakMapMemoize,
+      argsMemoizeOptions = []
+    } = combinedOptions;
+    const finalMemoizeOptions = ensureIsArray(memoizeOptions);
+    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);
+    const dependencies = getDependencies(createSelectorArgs);
+    const memoizedResultFunc = memoize(function recomputationWrapper() {
+      recomputations++;
+      return resultFunc.apply(
+        null,
+        arguments
+      );
+    }, ...finalMemoizeOptions);
+    const selector = argsMemoize(function dependenciesChecker() {
+      dependencyRecomputations++;
+      const inputSelectorResults = collectInputSelectorResults(
+        dependencies,
+        arguments
+      );
+      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
+      return lastResult;
+    }, ...finalArgsMemoizeOptions);
+    return Object.assign(selector, {
+      resultFunc,
+      memoizedResultFunc,
+      dependencies,
+      dependencyRecomputations: () => dependencyRecomputations,
+      resetDependencyRecomputations: () => {
+        dependencyRecomputations = 0;
+      },
+      lastResult: () => lastResult,
+      recomputations: () => recomputations,
+      resetRecomputations: () => {
+        recomputations = 0;
+      },
+      memoize,
+      argsMemoize
+    });
+  };
+  Object.assign(createSelector2, {
+    withTypes: () => createSelector2
+  });
+  return createSelector2;
+}
+var createSelector = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);
+var createStructuredSelector = Object.assign(
+  (inputSelectorsObject, selectorCreator = createSelector) => {
+    assertIsObject(
+      inputSelectorsObject,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`
+    );
+    const inputSelectorKeys = Object.keys(inputSelectorsObject);
+    const dependencies = inputSelectorKeys.map(
+      (key) => inputSelectorsObject[key]
+    );
+    const structuredSelector = selectorCreator(
+      dependencies,
+      (...inputSelectorResults) => {
+        return inputSelectorResults.reduce((composition, value, index) => {
+          composition[inputSelectorKeys[index]] = value;
+          return composition;
+        }, {});
+      }
+    );
+    return structuredSelector;
+  },
+  { withTypes: () => createStructuredSelector }
+);
+export {
+  createSelectorCreator as c,
+  lruMemoize as l
+};

package/.output/server/_libs/rou3.mjs

@@ -0,0 +1,8 @@
+const NullProtoObj = /* @__PURE__ */ (() => {
+  const e = function() {
+  };
+  return e.prototype = /* @__PURE__ */ Object.create(null), Object.freeze(e.prototype), e;
+})();
+export {
+  NullProtoObj as N
+};

package/.output/server/_libs/section-matter.mjs

@@ -0,0 +1,112 @@
+import { r as requireKindOf } from "./kind-of.mjs";
+import { r as requireExtendShallow } from "./extend-shallow.mjs";
+var sectionMatter;
+var hasRequiredSectionMatter;
+function requireSectionMatter() {
+  if (hasRequiredSectionMatter) return sectionMatter;
+  hasRequiredSectionMatter = 1;
+  var typeOf = /* @__PURE__ */ requireKindOf();
+  var extend = /* @__PURE__ */ requireExtendShallow();
+  sectionMatter = function(input, options) {
+    if (typeof options === "function") {
+      options = { parse: options };
+    }
+    var file = toObject(input);
+    var defaults = { section_delimiter: "---", parse: identity };
+    var opts = extend({}, defaults, options);
+    var delim = opts.section_delimiter;
+    var lines = file.content.split(/\r?\n/);
+    var sections = null;
+    var section = createSection();
+    var content = [];
+    var stack = [];
+    function initSections(val) {
+      file.content = val;
+      sections = [];
+      content = [];
+    }
+    function closeSection(val) {
+      if (stack.length) {
+        section.key = getKey(stack[0], delim);
+        section.content = val;
+        opts.parse(section, sections);
+        sections.push(section);
+        section = createSection();
+        content = [];
+        stack = [];
+      }
+    }
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i];
+      var len = stack.length;
+      var ln = line.trim();
+      if (isDelimiter(ln, delim)) {
+        if (ln.length === 3 && i !== 0) {
+          if (len === 0 || len === 2) {
+            content.push(line);
+            continue;
+          }
+          stack.push(ln);
+          section.data = content.join("\n");
+          content = [];
+          continue;
+        }
+        if (sections === null) {
+          initSections(content.join("\n"));
+        }
+        if (len === 2) {
+          closeSection(content.join("\n"));
+        }
+        stack.push(ln);
+        continue;
+      }
+      content.push(line);
+    }
+    if (sections === null) {
+      initSections(content.join("\n"));
+    } else {
+      closeSection(content.join("\n"));
+    }
+    file.sections = sections;
+    return file;
+  };
+  function isDelimiter(line, delim) {
+    if (line.slice(0, delim.length) !== delim) {
+      return false;
+    }
+    if (line.charAt(delim.length + 1) === delim.slice(-1)) {
+      return false;
+    }
+    return true;
+  }
+  function toObject(input) {
+    if (typeOf(input) !== "object") {
+      input = { content: input };
+    }
+    if (typeof input.content !== "string" && !isBuffer(input.content)) {
+      throw new TypeError("expected a buffer or string");
+    }
+    input.content = input.content.toString();
+    input.sections = [];
+    return input;
+  }
+  function getKey(val, delim) {
+    return val ? val.slice(delim.length).trim() : "";
+  }
+  function createSection() {
+    return { key: "", data: "", content: "" };
+  }
+  function identity(val) {
+    return val;
+  }
+  function isBuffer(val) {
+    if (val && val.constructor && typeof val.constructor.isBuffer === "function") {
+      return val.constructor.isBuffer(val);
+    }
+    return false;
+  }
+  return sectionMatter;
+}
+export {
+  requireSectionMatter as r
+};

package/.output/server/_libs/seroval-plugins.mjs

@@ -0,0 +1,58 @@
+import { n as ni, t as te } from "./seroval.mjs";
+var n = {}, P = (e) => new ReadableStream({ start: (r) => {
+  e.on({ next: (a) => {
+    try {
+      r.enqueue(a);
+    } catch (t) {
+    }
+  }, throw: (a) => {
+    r.error(a);
+  }, return: () => {
+    try {
+      r.close();
+    } catch (a) {
+    }
+  } });
+} }), x = ni({ tag: "seroval-plugins/web/ReadableStreamFactory", test(e) {
+  return e === n;
+}, parse: { sync() {
+  return n;
+}, async async() {
+  return await Promise.resolve(n);
+}, stream() {
+  return n;
+} }, serialize() {
+  return P.toString();
+}, deserialize() {
+  return n;
+} });
+function w(e) {
+  let r = te(), a = e.getReader();
+  async function t() {
+    try {
+      let s = await a.read();
+      s.done ? r.return(s.value) : (r.next(s.value), await t());
+    } catch (s) {
+      r.throw(s);
+    }
+  }
+  return t().catch(() => {
+  }), r;
+}
+var ee = ni({ tag: "seroval/plugins/web/ReadableStream", extends: [x], test(e) {
+  return typeof ReadableStream == "undefined" ? false : e instanceof ReadableStream;
+}, parse: { sync(e, r) {
+  return { factory: r.parse(n), stream: r.parse(te()) };
+}, async async(e, r) {
+  return { factory: await r.parse(n), stream: await r.parse(w(e)) };
+}, stream(e, r) {
+  return { factory: r.parse(n), stream: r.parse(w(e)) };
+} }, serialize(e, r) {
+  return "(" + r.serialize(e.factory) + ")(" + r.serialize(e.stream) + ")";
+}, deserialize(e, r) {
+  let a = r.deserialize(e.stream);
+  return P(a);
+} }), p = ee;
+export {
+  p
+};