@lvce-editor/server 0.0.30 → 0.0.33

package/static/b576f0e/static/js/ansi-styles.js

@@ -0,0 +1,148 @@
+import colorConvert from "./color-convert.js";
+function createCommonjsModule(fn, basedir, module) {
+  return module = {
+    path: basedir,
+    exports: {},
+    require: function(path, base) {
+      return commonjsRequire(path, base === void 0 || base === null ? module.path : base);
+    }
+  }, fn(module, module.exports), module.exports;
+}
+function commonjsRequire() {
+  throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs");
+}
+var ansiStyles = createCommonjsModule(function(module) {
+  const wrapAnsi16 = (fn, offset) => function() {
+    const code = fn.apply(colorConvert, arguments);
+    return `[${code + offset}m`;
+  };
+  const wrapAnsi256 = (fn, offset) => function() {
+    const code = fn.apply(colorConvert, arguments);
+    return `[${38 + offset};5;${code}m`;
+  };
+  const wrapAnsi16m = (fn, offset) => function() {
+    const rgb = fn.apply(colorConvert, arguments);
+    return `[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+  };
+  function assembleStyles() {
+    const codes = new Map();
+    const styles = {
+      modifier: {
+        reset: [0, 0],
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        gray: [90, 39],
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        bgBlackBright: [100, 49],
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    styles.color.grey = styles.color.gray;
+    for (const groupName of Object.keys(styles)) {
+      const group = styles[groupName];
+      for (const styleName of Object.keys(group)) {
+        const style = group[styleName];
+        styles[styleName] = {
+          open: `[${style[0]}m`,
+          close: `[${style[1]}m`
+        };
+        group[styleName] = styles[styleName];
+        codes.set(style[0], style[1]);
+      }
+      Object.defineProperty(styles, groupName, {
+        value: group,
+        enumerable: false
+      });
+      Object.defineProperty(styles, "codes", {
+        value: codes,
+        enumerable: false
+      });
+    }
+    const ansi2ansi = (n) => n;
+    const rgb2rgb = (r, g, b) => [r, g, b];
+    styles.color.close = "";
+    styles.bgColor.close = "";
+    styles.color.ansi = {
+      ansi: wrapAnsi16(ansi2ansi, 0)
+    };
+    styles.color.ansi256 = {
+      ansi256: wrapAnsi256(ansi2ansi, 0)
+    };
+    styles.color.ansi16m = {
+      rgb: wrapAnsi16m(rgb2rgb, 0)
+    };
+    styles.bgColor.ansi = {
+      ansi: wrapAnsi16(ansi2ansi, 10)
+    };
+    styles.bgColor.ansi256 = {
+      ansi256: wrapAnsi256(ansi2ansi, 10)
+    };
+    styles.bgColor.ansi16m = {
+      rgb: wrapAnsi16m(rgb2rgb, 10)
+    };
+    for (let key of Object.keys(colorConvert)) {
+      if (typeof colorConvert[key] !== "object") {
+        continue;
+      }
+      const suite = colorConvert[key];
+      if (key === "ansi16") {
+        key = "ansi";
+      }
+      if ("ansi16" in suite) {
+        styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+        styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+      }
+      if ("ansi256" in suite) {
+        styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+        styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+      }
+      if ("rgb" in suite) {
+        styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+        styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+      }
+    }
+    return styles;
+  }
+  Object.defineProperty(module, "exports", {
+    enumerable: true,
+    get: assembleStyles
+  });
+});
+export default ansiStyles;

package/static/b576f0e/static/js/babel-code-frame.js

@@ -0,0 +1,355 @@
+import _highlight from "./babel-highlight.js";
+function defaultSetTimout() {
+  throw new Error("setTimeout has not been defined");
+}
+function defaultClearTimeout() {
+  throw new Error("clearTimeout has not been defined");
+}
+var cachedSetTimeout = defaultSetTimout;
+var cachedClearTimeout = defaultClearTimeout;
+var globalContext;
+if (typeof window !== "undefined") {
+  globalContext = window;
+} else if (typeof self !== "undefined") {
+  globalContext = self;
+} else {
+  globalContext = {};
+}
+if (typeof globalContext.setTimeout === "function") {
+  cachedSetTimeout = setTimeout;
+}
+if (typeof globalContext.clearTimeout === "function") {
+  cachedClearTimeout = clearTimeout;
+}
+function runTimeout(fun) {
+  if (cachedSetTimeout === setTimeout) {
+    return setTimeout(fun, 0);
+  }
+  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+    cachedSetTimeout = setTimeout;
+    return setTimeout(fun, 0);
+  }
+  try {
+    return cachedSetTimeout(fun, 0);
+  } catch (e) {
+    try {
+      return cachedSetTimeout.call(null, fun, 0);
+    } catch (e2) {
+      return cachedSetTimeout.call(this, fun, 0);
+    }
+  }
+}
+function runClearTimeout(marker) {
+  if (cachedClearTimeout === clearTimeout) {
+    return clearTimeout(marker);
+  }
+  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+    cachedClearTimeout = clearTimeout;
+    return clearTimeout(marker);
+  }
+  try {
+    return cachedClearTimeout(marker);
+  } catch (e) {
+    try {
+      return cachedClearTimeout.call(null, marker);
+    } catch (e2) {
+      return cachedClearTimeout.call(this, marker);
+    }
+  }
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+function cleanUpNextTick() {
+  if (!draining || !currentQueue) {
+    return;
+  }
+  draining = false;
+  if (currentQueue.length) {
+    queue = currentQueue.concat(queue);
+  } else {
+    queueIndex = -1;
+  }
+  if (queue.length) {
+    drainQueue();
+  }
+}
+function drainQueue() {
+  if (draining) {
+    return;
+  }
+  var timeout = runTimeout(cleanUpNextTick);
+  draining = true;
+  var len = queue.length;
+  while (len) {
+    currentQueue = queue;
+    queue = [];
+    while (++queueIndex < len) {
+      if (currentQueue) {
+        currentQueue[queueIndex].run();
+      }
+    }
+    queueIndex = -1;
+    len = queue.length;
+  }
+  currentQueue = null;
+  draining = false;
+  runClearTimeout(timeout);
+}
+function nextTick(fun) {
+  var args = new Array(arguments.length - 1);
+  if (arguments.length > 1) {
+    for (var i = 1; i < arguments.length; i++) {
+      args[i - 1] = arguments[i];
+    }
+  }
+  queue.push(new Item(fun, args));
+  if (queue.length === 1 && !draining) {
+    runTimeout(drainQueue);
+  }
+}
+function Item(fun, array) {
+  this.fun = fun;
+  this.array = array;
+}
+Item.prototype.run = function() {
+  this.fun.apply(null, this.array);
+};
+var title = "browser";
+var platform = "browser";
+var browser = true;
+var argv = [];
+var version = "";
+var versions = {};
+var release = {};
+var config = {};
+function noop() {
+}
+var on = noop;
+var addListener = noop;
+var once = noop;
+var off = noop;
+var removeListener = noop;
+var removeAllListeners = noop;
+var emit = noop;
+function binding(name) {
+  throw new Error("process.binding is not supported");
+}
+function cwd() {
+  return "/";
+}
+function chdir(dir) {
+  throw new Error("process.chdir is not supported");
+}
+function umask() {
+  return 0;
+}
+var performance = globalContext.performance || {};
+var performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function() {
+  return new Date().getTime();
+};
+function hrtime(previousTimestamp) {
+  var clocktime = performanceNow.call(performance) * 1e-3;
+  var seconds = Math.floor(clocktime);
+  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
+  if (previousTimestamp) {
+    seconds = seconds - previousTimestamp[0];
+    nanoseconds = nanoseconds - previousTimestamp[1];
+    if (nanoseconds < 0) {
+      seconds--;
+      nanoseconds += 1e9;
+    }
+  }
+  return [seconds, nanoseconds];
+}
+var startTime = new Date();
+function uptime() {
+  var currentTime = new Date();
+  var dif = currentTime - startTime;
+  return dif / 1e3;
+}
+var process = {
+  nextTick,
+  title,
+  browser,
+  env: {NODE_ENV: "production"},
+  argv,
+  version,
+  versions,
+  on,
+  addListener,
+  once,
+  off,
+  removeListener,
+  removeAllListeners,
+  emit,
+  binding,
+  cwd,
+  chdir,
+  umask,
+  hrtime,
+  platform,
+  release,
+  config,
+  uptime
+};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function createCommonjsModule(fn, basedir, module) {
+  return module = {
+    path: basedir,
+    exports: {},
+    require: function(path, base) {
+      return commonjsRequire(path, base === void 0 || base === null ? module.path : base);
+    }
+  }, fn(module, module.exports), module.exports;
+}
+function commonjsRequire() {
+  throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs");
+}
+var lib = createCommonjsModule(function(module, exports) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.codeFrameColumns = codeFrameColumns2;
+  exports.default = _default;
+  let deprecationWarningShown = false;
+  function getDefs(chalk) {
+    return {
+      gutter: chalk.grey,
+      marker: chalk.red.bold,
+      message: chalk.red.bold
+    };
+  }
+  const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+  function getMarkerLines(loc, source, opts) {
+    const startLoc = Object.assign({
+      column: 0,
+      line: -1
+    }, loc.start);
+    const endLoc = Object.assign({}, startLoc, loc.end);
+    const {
+      linesAbove = 2,
+      linesBelow = 3
+    } = opts || {};
+    const startLine = startLoc.line;
+    const startColumn = startLoc.column;
+    const endLine = endLoc.line;
+    const endColumn = endLoc.column;
+    let start = Math.max(startLine - (linesAbove + 1), 0);
+    let end = Math.min(source.length, endLine + linesBelow);
+    if (startLine === -1) {
+      start = 0;
+    }
+    if (endLine === -1) {
+      end = source.length;
+    }
+    const lineDiff = endLine - startLine;
+    const markerLines = {};
+    if (lineDiff) {
+      for (let i = 0; i <= lineDiff; i++) {
+        const lineNumber = i + startLine;
+        if (!startColumn) {
+          markerLines[lineNumber] = true;
+        } else if (i === 0) {
+          const sourceLength = source[lineNumber - 1].length;
+          markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+        } else if (i === lineDiff) {
+          markerLines[lineNumber] = [0, endColumn];
+        } else {
+          const sourceLength = source[lineNumber - i].length;
+          markerLines[lineNumber] = [0, sourceLength];
+        }
+      }
+    } else {
+      if (startColumn === endColumn) {
+        if (startColumn) {
+          markerLines[startLine] = [startColumn, 0];
+        } else {
+          markerLines[startLine] = true;
+        }
+      } else {
+        markerLines[startLine] = [startColumn, endColumn - startColumn];
+      }
+    }
+    return {
+      start,
+      end,
+      markerLines
+    };
+  }
+  function codeFrameColumns2(rawLines, loc, opts = {}) {
+    const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
+    const chalk = (0, _highlight.getChalk)(opts);
+    const defs = getDefs(chalk);
+    const maybeHighlight = (chalkFn, string) => {
+      return highlighted ? chalkFn(string) : string;
+    };
+    const lines = rawLines.split(NEWLINE);
+    const {
+      start,
+      end,
+      markerLines
+    } = getMarkerLines(loc, lines, opts);
+    const hasColumns = loc.start && typeof loc.start.column === "number";
+    const numberMaxWidth = String(end).length;
+    const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
+    let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+      const number = start + 1 + index;
+      const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+      const gutter = ` ${paddedNumber} |`;
+      const hasMarker = markerLines[number];
+      const lastMarkerLine = !markerLines[number + 1];
+      if (hasMarker) {
+        let markerLine = "";
+        if (Array.isArray(hasMarker)) {
+          const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+          const numberOfMarkers = hasMarker[1] || 1;
+          markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
+          if (lastMarkerLine && opts.message) {
+            markerLine += " " + maybeHighlight(defs.message, opts.message);
+          }
+        }
+        return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+      } else {
+        return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+      }
+    }).join("\n");
+    if (opts.message && !hasColumns) {
+      frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}
+${frame}`;
+    }
+    if (highlighted) {
+      return chalk.reset(frame);
+    } else {
+      return frame;
+    }
+  }
+  function _default(rawLines, lineNumber, colNumber, opts = {}) {
+    if (!deprecationWarningShown) {
+      deprecationWarningShown = true;
+      const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+      if (process.emitWarning) {
+        process.emitWarning(message, "DeprecationWarning");
+      } else {
+        const deprecationError = new Error(message);
+        deprecationError.name = "DeprecationWarning";
+        console.warn(new Error(message));
+      }
+    }
+    colNumber = Math.max(colNumber, 0);
+    const location = {
+      start: {
+        column: colNumber,
+        line: lineNumber
+      }
+    };
+    return codeFrameColumns2(rawLines, location, opts);
+  }
+});
+var __pika_web_default_export_for_treeshaking__ = /* @__PURE__ */ getDefaultExportFromCjs(lib);
+var codeFrameColumns = lib.codeFrameColumns;
+export default __pika_web_default_export_for_treeshaking__;
+export {lib as __moduleExports, codeFrameColumns};