@qwik.dev/devtools 0.2.7 → 0.3.0-beta.3

package/dist/ui/node_modules/.pnpm/@shikijs_engine-javascript@4.0.2/node_modules/@shikijs/engine-javascript/dist/engine-compile.qwik.mjs

@@ -0,0 +1,36 @@
+import { t as JavaScriptScanner } from "./scanner-BFcBmQR1.qwik.mjs";
+import { toRegExp } from "../../../../../oniguruma-to-es@4.3.5/node_modules/oniguruma-to-es/dist/esm/index.qwik.mjs";
+function defaultJavaScriptRegexConstructor(pattern, options) {
+  return toRegExp(pattern, {
+    global: true,
+    hasIndices: true,
+    lazyCompileLength: 3e3,
+    rules: {
+      allowOrphanBackrefs: true,
+      asciiWordBoundaries: true,
+      captureGroup: true,
+      recursionLimit: 5,
+      singleline: true
+    },
+    ...options
+  });
+}
+function createJavaScriptRegexEngine(options = {}) {
+  const _options = Object.assign({
+    target: "auto",
+    cache: /* @__PURE__ */ new Map()
+  }, options);
+  _options.regexConstructor || (_options.regexConstructor = (pattern) => defaultJavaScriptRegexConstructor(pattern, { target: _options.target }));
+  return {
+    createScanner(patterns) {
+      return new JavaScriptScanner(patterns, _options);
+    },
+    createString(s) {
+      return { content: s };
+    }
+  };
+}
+export {
+  createJavaScriptRegexEngine,
+  defaultJavaScriptRegexConstructor
+};

package/dist/ui/node_modules/.pnpm/@shikijs_engine-javascript@4.0.2/node_modules/@shikijs/engine-javascript/dist/scanner-BFcBmQR1.qwik.mjs

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const MAX = 4294967295;
+var JavaScriptScanner = class {
+  constructor(patterns, options = {}) {
+    __publicField(this, "regexps");
+    this.patterns = patterns;
+    this.options = options;
+    const { forgiving = false, cache, regexConstructor } = options;
+    if (!regexConstructor) throw new Error("Option `regexConstructor` is not provided");
+    this.regexps = patterns.map((p) => {
+      if (typeof p !== "string") return p;
+      const cached = cache?.get(p);
+      if (cached) {
+        if (cached instanceof RegExp) return cached;
+        if (forgiving) return null;
+        throw cached;
+      }
+      try {
+        const regex = regexConstructor(p);
+        cache?.set(p, regex);
+        return regex;
+      } catch (e) {
+        cache?.set(p, e);
+        if (forgiving) return null;
+        throw e;
+      }
+    });
+  }
+  findNextMatchSync(string, startPosition, _options) {
+    const str = typeof string === "string" ? string : string.content;
+    const pending = [];
+    function toResult(index, match, offset = 0) {
+      return {
+        index,
+        captureIndices: match.indices.map((indice) => {
+          if (indice == null) return {
+            start: MAX,
+            end: MAX,
+            length: 0
+          };
+          return {
+            start: indice[0] + offset,
+            end: indice[1] + offset,
+            length: indice[1] - indice[0]
+          };
+        })
+      };
+    }
+    for (let i = 0; i < this.regexps.length; i++) {
+      const regexp = this.regexps[i];
+      if (!regexp) continue;
+      try {
+        regexp.lastIndex = startPosition;
+        const match = regexp.exec(str);
+        if (!match) continue;
+        if (match.index === startPosition) return toResult(i, match, 0);
+        pending.push([
+          i,
+          match,
+          0
+        ]);
+      } catch (e) {
+        if (this.options.forgiving) continue;
+        throw e;
+      }
+    }
+    if (pending.length) {
+      const minIndex = Math.min(...pending.map((m) => m[1].index));
+      for (const [i, match, offset] of pending) if (match.index === minIndex) return toResult(i, match, offset);
+    }
+    return null;
+  }
+};
+export {
+  JavaScriptScanner as t
+};