astro-md-editor 0.0.1

package/.output/server/_libs/json-schema-traverse.mjs

@@ -0,0 +1,91 @@
+var jsonSchemaTraverse = { exports: {} };
+var hasRequiredJsonSchemaTraverse;
+function requireJsonSchemaTraverse() {
+  if (hasRequiredJsonSchemaTraverse) return jsonSchemaTraverse.exports;
+  hasRequiredJsonSchemaTraverse = 1;
+  var traverse = jsonSchemaTraverse.exports = function(schema, opts, cb) {
+    if (typeof opts == "function") {
+      cb = opts;
+      opts = {};
+    }
+    cb = opts.cb || cb;
+    var pre = typeof cb == "function" ? cb : cb.pre || function() {
+    };
+    var post = cb.post || function() {
+    };
+    _traverse(opts, pre, post, schema, "", schema);
+  };
+  traverse.keywords = {
+    additionalItems: true,
+    items: true,
+    contains: true,
+    additionalProperties: true,
+    propertyNames: true,
+    not: true,
+    if: true,
+    then: true,
+    else: true
+  };
+  traverse.arrayKeywords = {
+    items: true,
+    allOf: true,
+    anyOf: true,
+    oneOf: true
+  };
+  traverse.propsKeywords = {
+    $defs: true,
+    definitions: true,
+    properties: true,
+    patternProperties: true,
+    dependencies: true
+  };
+  traverse.skipKeywords = {
+    default: true,
+    enum: true,
+    const: true,
+    required: true,
+    maximum: true,
+    minimum: true,
+    exclusiveMaximum: true,
+    exclusiveMinimum: true,
+    multipleOf: true,
+    maxLength: true,
+    minLength: true,
+    pattern: true,
+    format: true,
+    maxItems: true,
+    minItems: true,
+    uniqueItems: true,
+    maxProperties: true,
+    minProperties: true
+  };
+  function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+    if (schema && typeof schema == "object" && !Array.isArray(schema)) {
+      pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      for (var key in schema) {
+        var sch = schema[key];
+        if (Array.isArray(sch)) {
+          if (key in traverse.arrayKeywords) {
+            for (var i = 0; i < sch.length; i++)
+              _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
+          }
+        } else if (key in traverse.propsKeywords) {
+          if (sch && typeof sch == "object") {
+            for (var prop in sch)
+              _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+          }
+        } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
+          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+        }
+      }
+      post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+    }
+  }
+  function escapeJsonPtr(str) {
+    return str.replace(/~/g, "~0").replace(/\//g, "~1");
+  }
+  return jsonSchemaTraverse.exports;
+}
+export {
+  requireJsonSchemaTraverse as r
+};

package/.output/server/_libs/kind-of.mjs

@@ -0,0 +1,125 @@
+var kindOf;
+var hasRequiredKindOf;
+function requireKindOf() {
+  if (hasRequiredKindOf) return kindOf;
+  hasRequiredKindOf = 1;
+  var toString = Object.prototype.toString;
+  kindOf = function kindOf2(val) {
+    if (val === void 0) return "undefined";
+    if (val === null) return "null";
+    var type = typeof val;
+    if (type === "boolean") return "boolean";
+    if (type === "string") return "string";
+    if (type === "number") return "number";
+    if (type === "symbol") return "symbol";
+    if (type === "function") {
+      return isGeneratorFn(val) ? "generatorfunction" : "function";
+    }
+    if (isArray(val)) return "array";
+    if (isBuffer(val)) return "buffer";
+    if (isArguments(val)) return "arguments";
+    if (isDate(val)) return "date";
+    if (isError(val)) return "error";
+    if (isRegexp(val)) return "regexp";
+    switch (ctorName(val)) {
+      case "Symbol":
+        return "symbol";
+      case "Promise":
+        return "promise";
+      // Set, Map, WeakSet, WeakMap
+      case "WeakMap":
+        return "weakmap";
+      case "WeakSet":
+        return "weakset";
+      case "Map":
+        return "map";
+      case "Set":
+        return "set";
+      // 8-bit typed arrays
+      case "Int8Array":
+        return "int8array";
+      case "Uint8Array":
+        return "uint8array";
+      case "Uint8ClampedArray":
+        return "uint8clampedarray";
+      // 16-bit typed arrays
+      case "Int16Array":
+        return "int16array";
+      case "Uint16Array":
+        return "uint16array";
+      // 32-bit typed arrays
+      case "Int32Array":
+        return "int32array";
+      case "Uint32Array":
+        return "uint32array";
+      case "Float32Array":
+        return "float32array";
+      case "Float64Array":
+        return "float64array";
+    }
+    if (isGeneratorObj(val)) {
+      return "generator";
+    }
+    type = toString.call(val);
+    switch (type) {
+      case "[object Object]":
+        return "object";
+      // iterators
+      case "[object Map Iterator]":
+        return "mapiterator";
+      case "[object Set Iterator]":
+        return "setiterator";
+      case "[object String Iterator]":
+        return "stringiterator";
+      case "[object Array Iterator]":
+        return "arrayiterator";
+    }
+    return type.slice(8, -1).toLowerCase().replace(/\s/g, "");
+  };
+  function ctorName(val) {
+    return typeof val.constructor === "function" ? val.constructor.name : null;
+  }
+  function isArray(val) {
+    if (Array.isArray) return Array.isArray(val);
+    return val instanceof Array;
+  }
+  function isError(val) {
+    return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
+  }
+  function isDate(val) {
+    if (val instanceof Date) return true;
+    return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
+  }
+  function isRegexp(val) {
+    if (val instanceof RegExp) return true;
+    return typeof val.flags === "string" && typeof val.ignoreCase === "boolean" && typeof val.multiline === "boolean" && typeof val.global === "boolean";
+  }
+  function isGeneratorFn(name, val) {
+    return ctorName(name) === "GeneratorFunction";
+  }
+  function isGeneratorObj(val) {
+    return typeof val.throw === "function" && typeof val.return === "function" && typeof val.next === "function";
+  }
+  function isArguments(val) {
+    try {
+      if (typeof val.length === "number" && typeof val.callee === "function") {
+        return true;
+      }
+    } catch (err) {
+      if (err.message.indexOf("callee") !== -1) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function isBuffer(val) {
+    if (val.constructor && typeof val.constructor.isBuffer === "function") {
+      return val.constructor.isBuffer(val);
+    }
+    return false;
+  }
+  return kindOf;
+}
+export {
+  requireKindOf as r
+};

package/.output/server/_libs/lucide-react.mjs

@@ -0,0 +1,177 @@
+import { r as reactExports } from "./react.mjs";
+const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+  return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+}).join(" ").trim();
+const toKebabCase = (string) => string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+const toCamelCase = (string) => string.replace(
+  /^([A-Z])|[\s-_]+(\w)/g,
+  (match, p1, p2) => p2 ? p2.toUpperCase() : p1.toLowerCase()
+);
+const toPascalCase = (string) => {
+  const camelCase = toCamelCase(string);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+};
+var defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+const hasA11yProp = (props) => {
+  for (const prop in props) {
+    if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
+      return true;
+    }
+  }
+  return false;
+};
+const Icon = reactExports.forwardRef(
+  ({
+    color = "currentColor",
+    size = 24,
+    strokeWidth = 2,
+    absoluteStrokeWidth,
+    className = "",
+    children,
+    iconNode,
+    ...rest
+  }, ref) => reactExports.createElement(
+    "svg",
+    {
+      ref,
+      ...defaultAttributes,
+      width: size,
+      height: size,
+      stroke: color,
+      strokeWidth: absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth,
+      className: mergeClasses("lucide", className),
+      ...!children && !hasA11yProp(rest) && { "aria-hidden": "true" },
+      ...rest
+    },
+    [
+      ...iconNode.map(([tag, attrs]) => reactExports.createElement(tag, attrs)),
+      ...Array.isArray(children) ? children : [children]
+    ]
+  )
+);
+const createLucideIcon = (iconName, iconNode) => {
+  const Component = reactExports.forwardRef(
+    ({ className, ...props }, ref) => reactExports.createElement(Icon, {
+      ref,
+      iconNode,
+      className: mergeClasses(
+        `lucide-${toKebabCase(toPascalCase(iconName))}`,
+        `lucide-${iconName}`,
+        className
+      ),
+      ...props
+    })
+  );
+  Component.displayName = toPascalCase(iconName);
+  return Component;
+};
+const __iconNode$f = [
+  ["path", { d: "M8 2v4", key: "1cmpym" }],
+  ["path", { d: "M16 2v4", key: "4m81vk" }],
+  ["rect", { width: "18", height: "18", x: "3", y: "4", rx: "2", key: "1hopcy" }],
+  ["path", { d: "M3 10h18", key: "8toen8" }],
+  ["path", { d: "M8 14h.01", key: "6423bh" }],
+  ["path", { d: "M12 14h.01", key: "1etili" }],
+  ["path", { d: "M16 14h.01", key: "1gbofw" }],
+  ["path", { d: "M8 18h.01", key: "lrp35t" }],
+  ["path", { d: "M12 18h.01", key: "mhygvu" }],
+  ["path", { d: "M16 18h.01", key: "kzsmim" }]
+];
+const CalendarDays = createLucideIcon("calendar-days", __iconNode$f);
+const __iconNode$e = [["path", { d: "M20 6 9 17l-5-5", key: "1gmf2c" }]];
+const Check = createLucideIcon("check", __iconNode$e);
+const __iconNode$d = [["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]];
+const ChevronDown = createLucideIcon("chevron-down", __iconNode$d);
+const __iconNode$c = [["path", { d: "m15 18-6-6 6-6", key: "1wnfg3" }]];
+const ChevronLeft = createLucideIcon("chevron-left", __iconNode$c);
+const __iconNode$b = [["path", { d: "m9 18 6-6-6-6", key: "mthhwq" }]];
+const ChevronRight = createLucideIcon("chevron-right", __iconNode$b);
+const __iconNode$a = [["path", { d: "m18 15-6-6-6 6", key: "153udz" }]];
+const ChevronUp = createLucideIcon("chevron-up", __iconNode$a);
+const __iconNode$9 = [
+  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
+  ["path", { d: "M12 6v6h4", key: "135r8i" }]
+];
+const Clock3 = createLucideIcon("clock-3", __iconNode$9);
+const __iconNode$8 = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2", key: "1m3agn" }],
+  ["circle", { cx: "9", cy: "9", r: "2", key: "af1f0g" }],
+  ["path", { d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21", key: "1xmnt7" }]
+];
+const Image = createLucideIcon("image", __iconNode$8);
+const __iconNode$7 = [["path", { d: "M21 12a9 9 0 1 1-6.219-8.56", key: "13zald" }]];
+const LoaderCircle = createLucideIcon("loader-circle", __iconNode$7);
+const __iconNode$6 = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M9 3v18", key: "fh3hqa" }],
+  ["path", { d: "m16 15-3-3 3-3", key: "14y99z" }]
+];
+const PanelLeftClose = createLucideIcon("panel-left-close", __iconNode$6);
+const __iconNode$5 = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M9 3v18", key: "fh3hqa" }],
+  ["path", { d: "m14 9 3 3-3 3", key: "8010ee" }]
+];
+const PanelLeftOpen = createLucideIcon("panel-left-open", __iconNode$5);
+const __iconNode$4 = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M15 3v18", key: "14nvp0" }],
+  ["path", { d: "m8 9 3 3-3 3", key: "12hl5m" }]
+];
+const PanelRightClose = createLucideIcon("panel-right-close", __iconNode$4);
+const __iconNode$3 = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M15 3v18", key: "14nvp0" }],
+  ["path", { d: "m10 15-3-3 3-3", key: "1pgupc" }]
+];
+const PanelRightOpen = createLucideIcon("panel-right-open", __iconNode$3);
+const __iconNode$2 = [
+  [
+    "path",
+    {
+      d: "M15.2 3a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2z",
+      key: "1c8476"
+    }
+  ],
+  ["path", { d: "M17 21v-7a1 1 0 0 0-1-1H8a1 1 0 0 0-1 1v7", key: "1ydtos" }],
+  ["path", { d: "M7 3v4a1 1 0 0 0 1 1h7", key: "t51u73" }]
+];
+const Save = createLucideIcon("save", __iconNode$2);
+const __iconNode$1 = [
+  ["path", { d: "m21 21-4.34-4.34", key: "14j7rj" }],
+  ["circle", { cx: "11", cy: "11", r: "8", key: "4ej97u" }]
+];
+const Search = createLucideIcon("search", __iconNode$1);
+const __iconNode = [
+  ["path", { d: "M18 6 6 18", key: "1bl5f8" }],
+  ["path", { d: "m6 6 12 12", key: "d8bk6v" }]
+];
+const X = createLucideIcon("x", __iconNode);
+export {
+  ChevronDown as C,
+  Image as I,
+  LoaderCircle as L,
+  PanelLeftClose as P,
+  Save as S,
+  X,
+  PanelLeftOpen as a,
+  PanelRightClose as b,
+  PanelRightOpen as c,
+  Check as d,
+  CalendarDays as e,
+  Clock3 as f,
+  ChevronUp as g,
+  Search as h,
+  ChevronLeft as i,
+  ChevronRight as j
+};

package/.output/server/_libs/ohash.mjs

@@ -0,0 +1 @@
+