astro-md-editor 0.0.1

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

@@ -0,0 +1,393 @@
+import { g as getDefaultExportFromCjs } from "./react.mjs";
+import require$$0 from "fs";
+import { r as requireSectionMatter } from "./section-matter.mjs";
+import { r as requireJsYaml } from "./js-yaml.mjs";
+import { r as requireStripBomString } from "./strip-bom-string.mjs";
+import { r as requireKindOf } from "./kind-of.mjs";
+var engines = { exports: {} };
+var hasRequiredEngines;
+function requireEngines() {
+  if (hasRequiredEngines) return engines.exports;
+  hasRequiredEngines = 1;
+  (function(module, exports$1) {
+    const yaml = /* @__PURE__ */ requireJsYaml();
+    const engines = module.exports;
+    engines.yaml = {
+      parse: yaml.safeLoad.bind(yaml),
+      stringify: yaml.safeDump.bind(yaml)
+    };
+    engines.json = {
+      parse: JSON.parse.bind(JSON),
+      stringify: function(obj, options2) {
+        const opts = Object.assign({ replacer: null, space: 2 }, options2);
+        return JSON.stringify(obj, opts.replacer, opts.space);
+      }
+    };
+    engines.javascript = {
+      parse: function parse(str, options, wrap) {
+        try {
+          if (wrap !== false) {
+            str = "(function() {\nreturn " + str.trim() + ";\n}());";
+          }
+          return eval(str) || {};
+        } catch (err) {
+          if (wrap !== false && /(unexpected|identifier)/i.test(err.message)) {
+            return parse(str, options, false);
+          }
+          throw new SyntaxError(err);
+        }
+      },
+      stringify: function() {
+        throw new Error("stringifying JavaScript is not supported");
+      }
+    };
+  })(engines);
+  return engines.exports;
+}
+var utils = {};
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (function(exports$12) {
+    const stripBom = /* @__PURE__ */ requireStripBomString();
+    const typeOf = /* @__PURE__ */ requireKindOf();
+    exports$12.define = function(obj, key, val) {
+      Reflect.defineProperty(obj, key, {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: val
+      });
+    };
+    exports$12.isBuffer = function(val) {
+      return typeOf(val) === "buffer";
+    };
+    exports$12.isObject = function(val) {
+      return typeOf(val) === "object";
+    };
+    exports$12.toBuffer = function(input) {
+      return typeof input === "string" ? Buffer.from(input) : input;
+    };
+    exports$12.toString = function(input) {
+      if (exports$12.isBuffer(input)) return stripBom(String(input));
+      if (typeof input !== "string") {
+        throw new TypeError("expected input to be a string or buffer");
+      }
+      return stripBom(input);
+    };
+    exports$12.arrayify = function(val) {
+      return val ? Array.isArray(val) ? val : [val] : [];
+    };
+    exports$12.startsWith = function(str2, substr, len) {
+      if (typeof len !== "number") len = substr.length;
+      return str2.slice(0, len) === substr;
+    };
+  })(utils);
+  return utils;
+}
+var defaults;
+var hasRequiredDefaults;
+function requireDefaults() {
+  if (hasRequiredDefaults) return defaults;
+  hasRequiredDefaults = 1;
+  const engines2 = /* @__PURE__ */ requireEngines();
+  const utils2 = /* @__PURE__ */ requireUtils();
+  defaults = function(options2) {
+    const opts = Object.assign({}, options2);
+    opts.delimiters = utils2.arrayify(opts.delims || opts.delimiters || "---");
+    if (opts.delimiters.length === 1) {
+      opts.delimiters.push(opts.delimiters[0]);
+    }
+    opts.language = (opts.language || opts.lang || "yaml").toLowerCase();
+    opts.engines = Object.assign({}, engines2, opts.parsers, opts.engines);
+    return opts;
+  };
+  return defaults;
+}
+var engine;
+var hasRequiredEngine;
+function requireEngine() {
+  if (hasRequiredEngine) return engine;
+  hasRequiredEngine = 1;
+  engine = function(name, options2) {
+    let engine2 = options2.engines[name] || options2.engines[aliase(name)];
+    if (typeof engine2 === "undefined") {
+      throw new Error('gray-matter engine "' + name + '" is not registered');
+    }
+    if (typeof engine2 === "function") {
+      engine2 = { parse: engine2 };
+    }
+    return engine2;
+  };
+  function aliase(name) {
+    switch (name.toLowerCase()) {
+      case "js":
+      case "javascript":
+        return "javascript";
+      case "coffee":
+      case "coffeescript":
+      case "cson":
+        return "coffee";
+      case "yaml":
+      case "yml":
+        return "yaml";
+      default: {
+        return name;
+      }
+    }
+  }
+  return engine;
+}
+var stringify;
+var hasRequiredStringify;
+function requireStringify() {
+  if (hasRequiredStringify) return stringify;
+  hasRequiredStringify = 1;
+  const typeOf = /* @__PURE__ */ requireKindOf();
+  const getEngine = /* @__PURE__ */ requireEngine();
+  const defaults2 = /* @__PURE__ */ requireDefaults();
+  stringify = function(file, data, options2) {
+    if (data == null && options2 == null) {
+      switch (typeOf(file)) {
+        case "object":
+          data = file.data;
+          options2 = {};
+          break;
+        case "string":
+          return file;
+        default: {
+          throw new TypeError("expected file to be a string or object");
+        }
+      }
+    }
+    const str2 = file.content;
+    const opts = defaults2(options2);
+    if (data == null) {
+      if (!opts.data) return file;
+      data = opts.data;
+    }
+    const language = file.language || opts.language;
+    const engine2 = getEngine(language, opts);
+    if (typeof engine2.stringify !== "function") {
+      throw new TypeError('expected "' + language + '.stringify" to be a function');
+    }
+    data = Object.assign({}, file.data, data);
+    const open = opts.delimiters[0];
+    const close = opts.delimiters[1];
+    const matter2 = engine2.stringify(data, options2).trim();
+    let buf = "";
+    if (matter2 !== "{}") {
+      buf = newline(open) + newline(matter2) + newline(close);
+    }
+    if (typeof file.excerpt === "string" && file.excerpt !== "") {
+      if (str2.indexOf(file.excerpt.trim()) === -1) {
+        buf += newline(file.excerpt) + newline(close);
+      }
+    }
+    return buf + newline(str2);
+  };
+  function newline(str2) {
+    return str2.slice(-1) !== "\n" ? str2 + "\n" : str2;
+  }
+  return stringify;
+}
+var excerpt;
+var hasRequiredExcerpt;
+function requireExcerpt() {
+  if (hasRequiredExcerpt) return excerpt;
+  hasRequiredExcerpt = 1;
+  const defaults2 = /* @__PURE__ */ requireDefaults();
+  excerpt = function(file, options2) {
+    const opts = defaults2(options2);
+    if (file.data == null) {
+      file.data = {};
+    }
+    if (typeof opts.excerpt === "function") {
+      return opts.excerpt(file, opts);
+    }
+    const sep = file.data.excerpt_separator || opts.excerpt_separator;
+    if (sep == null && (opts.excerpt === false || opts.excerpt == null)) {
+      return file;
+    }
+    const delimiter = typeof opts.excerpt === "string" ? opts.excerpt : sep || opts.delimiters[0];
+    const idx = file.content.indexOf(delimiter);
+    if (idx !== -1) {
+      file.excerpt = file.content.slice(0, idx);
+    }
+    return file;
+  };
+  return excerpt;
+}
+var toFile;
+var hasRequiredToFile;
+function requireToFile() {
+  if (hasRequiredToFile) return toFile;
+  hasRequiredToFile = 1;
+  const typeOf = /* @__PURE__ */ requireKindOf();
+  const stringify2 = /* @__PURE__ */ requireStringify();
+  const utils2 = /* @__PURE__ */ requireUtils();
+  toFile = function(file) {
+    if (typeOf(file) !== "object") {
+      file = { content: file };
+    }
+    if (typeOf(file.data) !== "object") {
+      file.data = {};
+    }
+    if (file.contents && file.content == null) {
+      file.content = file.contents;
+    }
+    utils2.define(file, "orig", utils2.toBuffer(file.content));
+    utils2.define(file, "language", file.language || "");
+    utils2.define(file, "matter", file.matter || "");
+    utils2.define(file, "stringify", function(data, options2) {
+      if (options2 && options2.language) {
+        file.language = options2.language;
+      }
+      return stringify2(file, data, options2);
+    });
+    file.content = utils2.toString(file.content);
+    file.isEmpty = false;
+    file.excerpt = "";
+    return file;
+  };
+  return toFile;
+}
+var parse;
+var hasRequiredParse;
+function requireParse() {
+  if (hasRequiredParse) return parse;
+  hasRequiredParse = 1;
+  const getEngine = /* @__PURE__ */ requireEngine();
+  const defaults2 = /* @__PURE__ */ requireDefaults();
+  parse = function(language, str2, options2) {
+    const opts = defaults2(options2);
+    const engine2 = getEngine(language, opts);
+    if (typeof engine2.parse !== "function") {
+      throw new TypeError('expected "' + language + '.parse" to be a function');
+    }
+    return engine2.parse(str2, opts);
+  };
+  return parse;
+}
+var grayMatter;
+var hasRequiredGrayMatter;
+function requireGrayMatter() {
+  if (hasRequiredGrayMatter) return grayMatter;
+  hasRequiredGrayMatter = 1;
+  const fs = require$$0;
+  const sections = /* @__PURE__ */ requireSectionMatter();
+  const defaults2 = /* @__PURE__ */ requireDefaults();
+  const stringify2 = /* @__PURE__ */ requireStringify();
+  const excerpt2 = /* @__PURE__ */ requireExcerpt();
+  const engines2 = /* @__PURE__ */ requireEngines();
+  const toFile2 = /* @__PURE__ */ requireToFile();
+  const parse2 = /* @__PURE__ */ requireParse();
+  const utils2 = /* @__PURE__ */ requireUtils();
+  function matter2(input, options2) {
+    if (input === "") {
+      return { data: {}, content: input, excerpt: "", orig: input };
+    }
+    let file = toFile2(input);
+    const cached = matter2.cache[file.content];
+    if (!options2) {
+      if (cached) {
+        file = Object.assign({}, cached);
+        file.orig = cached.orig;
+        return file;
+      }
+      matter2.cache[file.content] = file;
+    }
+    return parseMatter(file, options2);
+  }
+  function parseMatter(file, options2) {
+    const opts = defaults2(options2);
+    const open = opts.delimiters[0];
+    const close = "\n" + opts.delimiters[1];
+    let str2 = file.content;
+    if (opts.language) {
+      file.language = opts.language;
+    }
+    const openLen = open.length;
+    if (!utils2.startsWith(str2, open, openLen)) {
+      excerpt2(file, opts);
+      return file;
+    }
+    if (str2.charAt(openLen) === open.slice(-1)) {
+      return file;
+    }
+    str2 = str2.slice(openLen);
+    const len = str2.length;
+    const language = matter2.language(str2, opts);
+    if (language.name) {
+      file.language = language.name;
+      str2 = str2.slice(language.raw.length);
+    }
+    let closeIndex = str2.indexOf(close);
+    if (closeIndex === -1) {
+      closeIndex = len;
+    }
+    file.matter = str2.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 = str2.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);
+      }
+    }
+    excerpt2(file, opts);
+    if (opts.sections === true || typeof opts.section === "function") {
+      sections(file, opts.section);
+    }
+    return file;
+  }
+  matter2.engines = engines2;
+  matter2.stringify = function(file, data, options2) {
+    if (typeof file === "string") file = matter2(file, options2);
+    return stringify2(file, data, options2);
+  };
+  matter2.read = function(filepath, options2) {
+    const str2 = fs.readFileSync(filepath, "utf8");
+    const file = matter2(str2, options2);
+    file.path = filepath;
+    return file;
+  };
+  matter2.test = function(str2, options2) {
+    return utils2.startsWith(str2, defaults2(options2).delimiters[0]);
+  };
+  matter2.language = function(str2, options2) {
+    const opts = defaults2(options2);
+    const open = opts.delimiters[0];
+    if (matter2.test(str2)) {
+      str2 = str2.slice(open.length);
+    }
+    const language = str2.slice(0, str2.search(/\r?\n/));
+    return {
+      raw: language,
+      name: language ? language.trim() : ""
+    };
+  };
+  matter2.cache = {};
+  matter2.clearCache = function() {
+    matter2.cache = {};
+  };
+  grayMatter = matter2;
+  return grayMatter;
+}
+var grayMatterExports = /* @__PURE__ */ requireGrayMatter();
+const matter = /* @__PURE__ */ getDefaultExportFromCjs(grayMatterExports);
+export {
+  matter as m
+};

package/.output/server/_libs/h3-v2.mjs

@@ -0,0 +1,276 @@
+import { N as NullProtoObj } from "./rou3.mjs";
+import { F as FastURL, N as NodeResponse } from "./srvx.mjs";
+const kEventNS = "h3.internal.event.";
+const kEventRes = /* @__PURE__ */ Symbol.for(`${kEventNS}res`);
+const kEventResHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.headers`);
+var H3Event = class {
+  app;
+  req;
+  url;
+  context;
+  static __is_event__ = true;
+  constructor(req, context, app) {
+    this.context = context || req.context || new NullProtoObj();
+    this.req = req;
+    this.app = app;
+    const _url = req._url;
+    this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+  }
+  get res() {
+    return this[kEventRes] ||= new H3EventResponse();
+  }
+  get runtime() {
+    return this.req.runtime;
+  }
+  waitUntil(promise) {
+    this.req.waitUntil?.(promise);
+  }
+  toString() {
+    return `[${this.req.method}] ${this.req.url}`;
+  }
+  toJSON() {
+    return this.toString();
+  }
+  get node() {
+    return this.req.runtime?.node;
+  }
+  get headers() {
+    return this.req.headers;
+  }
+  get path() {
+    return this.url.pathname + this.url.search;
+  }
+  get method() {
+    return this.req.method;
+  }
+};
+var H3EventResponse = class {
+  status;
+  statusText;
+  get headers() {
+    return this[kEventResHeaders] ||= new Headers();
+  }
+};
+const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+  return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
+}
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+  if (!statusCode) return defaultStatusCode;
+  if (typeof statusCode === "string") statusCode = +statusCode;
+  if (statusCode < 100 || statusCode > 599) return defaultStatusCode;
+  return statusCode;
+}
+var HTTPError = class HTTPError2 extends Error {
+  get name() {
+    return "HTTPError";
+  }
+  status;
+  statusText;
+  headers;
+  cause;
+  data;
+  body;
+  unhandled;
+  static isError(input) {
+    return input instanceof Error && input?.name === "HTTPError";
+  }
+  static status(status, statusText, details) {
+    return new HTTPError2({
+      ...details,
+      statusText,
+      status
+    });
+  }
+  constructor(arg1, arg2) {
+    let messageInput;
+    let details;
+    if (typeof arg1 === "string") {
+      messageInput = arg1;
+      details = arg2;
+    } else details = arg1;
+    const status = sanitizeStatusCode(details?.status || details?.cause?.status || details?.status || details?.statusCode, 500);
+    const statusText = sanitizeStatusMessage(details?.statusText || details?.cause?.statusText || details?.statusText || details?.statusMessage);
+    const message = messageInput || details?.message || details?.cause?.message || details?.statusText || details?.statusMessage || [
+      "HTTPError",
+      status,
+      statusText
+    ].filter(Boolean).join(" ");
+    super(message, { cause: details });
+    this.cause = details;
+    this.status = status;
+    this.statusText = statusText || void 0;
+    const rawHeaders = details?.headers || details?.cause?.headers;
+    this.headers = rawHeaders ? new Headers(rawHeaders) : void 0;
+    this.unhandled = details?.unhandled ?? details?.cause?.unhandled ?? void 0;
+    this.data = details?.data;
+    this.body = details?.body;
+  }
+  get statusCode() {
+    return this.status;
+  }
+  get statusMessage() {
+    return this.statusText;
+  }
+  toJSON() {
+    const unhandled = this.unhandled;
+    return {
+      status: this.status,
+      statusText: this.statusText,
+      unhandled,
+      message: unhandled ? "HTTPError" : this.message,
+      data: unhandled ? void 0 : this.data,
+      ...unhandled ? void 0 : this.body
+    };
+  }
+};
+function isJSONSerializable(value, _type) {
+  if (value === null || value === void 0) return true;
+  if (_type !== "object") return _type === "boolean" || _type === "number" || _type === "string";
+  if (typeof value.toJSON === "function") return true;
+  if (Array.isArray(value)) return true;
+  if (typeof value.pipe === "function" || typeof value.pipeTo === "function") return false;
+  if (value instanceof NullProtoObj) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+const kNotFound = /* @__PURE__ */ Symbol.for("h3.notFound");
+const kHandled = /* @__PURE__ */ Symbol.for("h3.handled");
+function toResponse(val, event, config = {}) {
+  if (typeof val?.then === "function") return (val.catch?.((error) => error) || Promise.resolve(val)).then((resolvedVal) => toResponse(resolvedVal, event, config));
+  const response = prepareResponse(val, event, config);
+  if (typeof response?.then === "function") return toResponse(response, event, config);
+  const { onResponse } = config;
+  return onResponse ? Promise.resolve(onResponse(response, event)).then(() => response) : response;
+}
+var HTTPResponse = class {
+  #headers;
+  #init;
+  body;
+  constructor(body, init) {
+    this.body = body;
+    this.#init = init;
+  }
+  get status() {
+    return this.#init?.status || 200;
+  }
+  get statusText() {
+    return this.#init?.statusText || "OK";
+  }
+  get headers() {
+    return this.#headers ||= new Headers(this.#init?.headers);
+  }
+};
+function prepareResponse(val, event, config, nested) {
+  if (val === kHandled) return new NodeResponse(null);
+  if (val === kNotFound) val = new HTTPError({
+    status: 404,
+    message: `Cannot find any route matching [${event.req.method}] ${event.url}`
+  });
+  if (val && val instanceof Error) {
+    const isHTTPError = HTTPError.isError(val);
+    const error = isHTTPError ? val : new HTTPError(val);
+    if (!isHTTPError) {
+      error.unhandled = true;
+      if (val?.stack) error.stack = val.stack;
+    }
+    if (error.unhandled && !config.silent) console.error(error);
+    const { onError } = config;
+    return onError && !nested ? Promise.resolve(onError(error, event)).catch((error2) => error2).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
+  }
+  const preparedRes = event[kEventRes];
+  const preparedHeaders = preparedRes?.[kEventResHeaders];
+  event[kEventRes] = void 0;
+  if (!(val instanceof Response)) {
+    const res = prepareResponseBody(val, event, config);
+    const status = res.status || preparedRes?.status;
+    return new NodeResponse(nullBody(event.req.method, status) ? null : res.body, {
+      status,
+      statusText: res.statusText || preparedRes?.statusText,
+      headers: res.headers && preparedHeaders ? mergeHeaders$1(res.headers, preparedHeaders) : res.headers || preparedHeaders
+    });
+  }
+  if (!preparedHeaders || nested || !val.ok) return val;
+  try {
+    mergeHeaders$1(val.headers, preparedHeaders, val.headers);
+    return val;
+  } catch {
+    return new NodeResponse(nullBody(event.req.method, val.status) ? null : val.body, {
+      status: val.status,
+      statusText: val.statusText,
+      headers: mergeHeaders$1(val.headers, preparedHeaders)
+    });
+  }
+}
+function mergeHeaders$1(base, overrides, target = new Headers(base)) {
+  for (const [name, value] of overrides) if (name === "set-cookie") target.append(name, value);
+  else target.set(name, value);
+  return target;
+}
+const frozen = (name) => (...args) => {
+  throw new Error(`Headers are frozen (${name} ${args.join(", ")})`);
+};
+var FrozenHeaders = class extends Headers {
+  set = frozen("set");
+  append = frozen("append");
+  delete = frozen("delete");
+};
+const emptyHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-length": "0" });
+const jsonHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-type": "application/json;charset=UTF-8" });
+function prepareResponseBody(val, event, config) {
+  if (val === null || val === void 0) return {
+    body: "",
+    headers: emptyHeaders
+  };
+  const valType = typeof val;
+  if (valType === "string") return { body: val };
+  if (val instanceof Uint8Array) {
+    event.res.headers.set("content-length", val.byteLength.toString());
+    return { body: val };
+  }
+  if (val instanceof HTTPResponse || val?.constructor?.name === "HTTPResponse") return val;
+  if (isJSONSerializable(val, valType)) return {
+    body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
+    headers: jsonHeaders
+  };
+  if (valType === "bigint") return {
+    body: val.toString(),
+    headers: jsonHeaders
+  };
+  if (val instanceof Blob) {
+    const headers = new Headers({
+      "content-type": val.type,
+      "content-length": val.size.toString()
+    });
+    let filename = val.name;
+    if (filename) {
+      filename = encodeURIComponent(filename);
+      headers.set("content-disposition", `filename="${filename}"; filename*=UTF-8''${filename}`);
+    }
+    return {
+      body: val.stream(),
+      headers
+    };
+  }
+  if (valType === "symbol") return { body: val.toString() };
+  if (valType === "function") return { body: `${val.name}()` };
+  return { body: val };
+}
+function nullBody(method, status) {
+  return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
+}
+function errorResponse(error, debug) {
+  return new NodeResponse(JSON.stringify({
+    ...error.toJSON(),
+    stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
+  }, void 0, debug ? 2 : void 0), {
+    status: error.status,
+    statusText: error.statusText,
+    headers: error.headers ? mergeHeaders$1(jsonHeaders, error.headers) : new Headers(jsonHeaders)
+  });
+}
+new TextEncoder();
+export {
+  H3Event as H,
+  toResponse as t
+};