@bilal-fazlani/mock-server 0.2.1 → 0.3.0

package/.next/standalone/node_modules/regex-recursion/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "regex-recursion",
+  "version": "6.0.2",
+  "description": "Recursive matching plugin for Regex+",
+  "author": "Steven Levithan",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./src/index.js"
+    }
+  },
+  "browser": "./dist/regex-recursion.min.js",
+  "types": "./types/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "types"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slevithan/regex-recursion.git"
+  },
+  "keywords": [
+    "recursion",
+    "regex",
+    "regexp"
+  ],
+  "dependencies": {
+    "regex-utilities": "^2.3.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.2",
+    "jasmine": "^5.5.0",
+    "regex": "^6.0.1",
+    "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "bundle:global": "esbuild src/index.js --global-name=Regex.plugins --bundle --minify --sourcemap --outfile=dist/regex-recursion.min.js",
+    "types": "tsc src/index.js --rootDir src --declaration --allowJs --emitDeclarationOnly --outDir types",
+    "prebuild": "rm -rf dist/* types/*",
+    "build": "pnpm run bundle:global && pnpm run types",
+    "pretest": "pnpm run build",
+    "test": "jasmine"
+  }
+}

package/.next/standalone/node_modules/regex-recursion/src/index.js

@@ -0,0 +1,365 @@
+import {Context, forEachUnescaped, getGroupContents, hasUnescaped, replaceUnescaped} from 'regex-utilities';
+
+const r = String.raw;
+const gRToken = r`\\g<(?<gRNameOrNum>[^>&]+)&R=(?<gRDepth>[^>]+)>`;
+const recursiveToken = r`\(\?R=(?<rDepth>[^\)]+)\)|${gRToken}`;
+const namedCaptureDelim = r`\(\?<(?![=!])(?<captureName>[^>]+)>`;
+const captureDelim = r`${namedCaptureDelim}|(?<unnamed>\()(?!\?)`;
+const token = new RegExp(r`${namedCaptureDelim}|${recursiveToken}|\(\?|\\?.`, 'gsu');
+const overlappingRecursionMsg = 'Cannot use multiple overlapping recursions';
+
+/**
+@param {string} pattern
+@param {{
+  flags?: string;
+  captureTransfers?: Map<number, Array<number>>;
+  hiddenCaptures?: Array<number>;
+  mode?: 'plugin' | 'external';
+}} [data]
+@returns {{
+  pattern: string;
+  captureTransfers: Map<number, Array<number>>;
+  hiddenCaptures: Array<number>;
+}}
+*/
+function recursion(pattern, data) {
+  const {hiddenCaptures, mode} = {
+    hiddenCaptures: [],
+    mode: 'plugin',
+    ...data,
+  };
+  // Capture transfer is used by <github.com/slevithan/oniguruma-to-es>
+  let captureTransfers = data?.captureTransfers ?? new Map();
+  // Keep the initial fail-check (which avoids unneeded processing) as fast as possible by testing
+  // without the accuracy improvement of using `hasUnescaped` with `Context.DEFAULT`
+  if (!(new RegExp(recursiveToken, 'su').test(pattern))) {
+    return {
+      pattern,
+      captureTransfers,
+      hiddenCaptures,
+    };
+  }
+  if (mode === 'plugin' && hasUnescaped(pattern, r`\(\?\(DEFINE\)`, Context.DEFAULT)) {
+    throw new Error('DEFINE groups cannot be used with recursion');
+  }
+
+  const addedHiddenCaptures = [];
+  const hasNumberedBackref = hasUnescaped(pattern, r`\\[1-9]`, Context.DEFAULT);
+  const groupContentsStartPos = new Map();
+  const openGroups = [];
+  let hasRecursed = false;
+  let numCharClassesOpen = 0;
+  let numCapturesPassed = 0;
+  let match;
+  token.lastIndex = 0;
+  while ((match = token.exec(pattern))) {
+    const {0: m, groups: {captureName, rDepth, gRNameOrNum, gRDepth}} = match;
+    if (m === '[') {
+      numCharClassesOpen++;
+    } else if (!numCharClassesOpen) {
+
+      // `(?R=N)`
+      if (rDepth) {
+        assertMaxInBounds(rDepth);
+        if (hasRecursed) {
+          throw new Error(overlappingRecursionMsg);
+        }
+        if (hasNumberedBackref) {
+          // Could add support for numbered backrefs with extra effort, but it's probably not worth
+          // it. To trigger this error, the regex must include recursion and one of the following:
+          // - An interpolated regex that contains a numbered backref (since other numbered
+          //   backrefs are prevented by implicit flag n).
+          // - A numbered backref, when flag n is explicitly disabled.
+          // Note that Regex+'s extended syntax (atomic groups and sometimes subroutines) can also
+          // add numbered backrefs, but those work fine because external plugins like this one run
+          // *before* the transformation of built-in syntax extensions
+          throw new Error(
+            // When used in `external` mode by transpilers other than Regex+, backrefs might have
+            // gone through conversion from named to numbered, so avoid a misleading error
+            `${mode === 'external' ? 'Backrefs' : 'Numbered backrefs'} cannot be used with global recursion`
+          );
+        }
+        const left = pattern.slice(0, match.index);
+        const right = pattern.slice(token.lastIndex);
+        if (hasUnescaped(right, recursiveToken, Context.DEFAULT)) {
+          throw new Error(overlappingRecursionMsg);
+        }
+        const reps = +rDepth - 1;
+        pattern = makeRecursive(
+          left,
+          right,
+          reps,
+          false,
+          hiddenCaptures,
+          addedHiddenCaptures,
+          numCapturesPassed
+        );
+        captureTransfers = mapCaptureTransfers(
+          captureTransfers,
+          left,
+          reps,
+          addedHiddenCaptures.length,
+          0,
+          numCapturesPassed
+        );
+        // No need to parse further
+        break;
+      // `\g<name&R=N>`, `\g<number&R=N>`
+      } else if (gRNameOrNum) {
+        assertMaxInBounds(gRDepth);
+        let isWithinReffedGroup = false;
+        for (const g of openGroups) {
+          if (g.name === gRNameOrNum || g.num === +gRNameOrNum) {
+            isWithinReffedGroup = true;
+            if (g.hasRecursedWithin) {
+              throw new Error(overlappingRecursionMsg);
+            }
+            break;
+          }
+        }
+        if (!isWithinReffedGroup) {
+          throw new Error(r`Recursive \g cannot be used outside the referenced group "${
+            mode === 'external' ? gRNameOrNum : r`\g<${gRNameOrNum}&R=${gRDepth}>`
+          }"`);
+        }
+        const startPos = groupContentsStartPos.get(gRNameOrNum);
+        const groupContents = getGroupContents(pattern, startPos);
+        if (
+          hasNumberedBackref &&
+          hasUnescaped(groupContents, r`${namedCaptureDelim}|\((?!\?)`, Context.DEFAULT)
+        ) {
+          throw new Error(
+            // When used in `external` mode by transpilers other than Regex+, backrefs might have
+            // gone through conversion from named to numbered, so avoid a misleading error
+            `${mode === 'external' ? 'Backrefs' : 'Numbered backrefs'} cannot be used with recursion of capturing groups`
+          );
+        }
+        const groupContentsLeft = pattern.slice(startPos, match.index);
+        const groupContentsRight = groupContents.slice(groupContentsLeft.length + m.length);
+        const numAddedHiddenCapturesPreExpansion = addedHiddenCaptures.length;
+        const reps = +gRDepth - 1;
+        const expansion = makeRecursive(
+          groupContentsLeft,
+          groupContentsRight,
+          reps,
+          true,
+          hiddenCaptures,
+          addedHiddenCaptures,
+          numCapturesPassed
+        );
+        captureTransfers = mapCaptureTransfers(
+          captureTransfers,
+          groupContentsLeft,
+          reps,
+          addedHiddenCaptures.length - numAddedHiddenCapturesPreExpansion,
+          numAddedHiddenCapturesPreExpansion,
+          numCapturesPassed
+        );
+        const pre = pattern.slice(0, startPos);
+        const post = pattern.slice(startPos + groupContents.length);
+        // Modify the string we're looping over
+        pattern = `${pre}${expansion}${post}`;
+        // Step forward for the next loop iteration
+        token.lastIndex += expansion.length - m.length - groupContentsLeft.length - groupContentsRight.length;
+        openGroups.forEach(g => g.hasRecursedWithin = true);
+        hasRecursed = true;
+      } else if (captureName) {
+        numCapturesPassed++;
+        groupContentsStartPos.set(String(numCapturesPassed), token.lastIndex);
+        groupContentsStartPos.set(captureName, token.lastIndex);
+        openGroups.push({
+          num: numCapturesPassed,
+          name: captureName,
+        });
+      } else if (m[0] === '(') {
+        const isUnnamedCapture = m === '(';
+        if (isUnnamedCapture) {
+          numCapturesPassed++;
+          groupContentsStartPos.set(String(numCapturesPassed), token.lastIndex);
+        }
+        openGroups.push(isUnnamedCapture ? {num: numCapturesPassed} : {});
+      } else if (m === ')') {
+        openGroups.pop();
+      }
+
+    } else if (m === ']') {
+      numCharClassesOpen--;
+    }
+  }
+
+  hiddenCaptures.push(...addedHiddenCaptures);
+
+  return {
+    pattern,
+    captureTransfers,
+    hiddenCaptures,
+  };
+}
+
+/**
+@param {string} max
+*/
+function assertMaxInBounds(max) {
+  const errMsg = `Max depth must be integer between 2 and 100; used ${max}`;
+  if (!/^[1-9]\d*$/.test(max)) {
+    throw new Error(errMsg);
+  }
+  max = +max;
+  if (max < 2 || max > 100) {
+    throw new Error(errMsg);
+  }
+}
+
+/**
+@param {string} left
+@param {string} right
+@param {number} reps
+@param {boolean} isSubpattern
+@param {Array<number>} hiddenCaptures
+@param {Array<number>} addedHiddenCaptures
+@param {number} numCapturesPassed
+@returns {string}
+*/
+function makeRecursive(
+  left,
+  right,
+  reps,
+  isSubpattern,
+  hiddenCaptures,
+  addedHiddenCaptures,
+  numCapturesPassed
+) {
+  const namesInRecursed = new Set();
+  // Can skip this work if not needed
+  if (isSubpattern) {
+    forEachUnescaped(left + right, namedCaptureDelim, ({groups: {captureName}}) => {
+      namesInRecursed.add(captureName);
+    }, Context.DEFAULT);
+  }
+  const rest = [
+    reps,
+    isSubpattern ? namesInRecursed : null,
+    hiddenCaptures,
+    addedHiddenCaptures,
+    numCapturesPassed,
+  ];
+  // Depth 2: 'left(?:left(?:)right)right'
+  // Depth 3: 'left(?:left(?:left(?:)right)right)right'
+  // Empty group in the middle separates tokens and absorbs a following quantifier if present
+  return `${left}${
+    repeatWithDepth(`(?:${left}`, 'forward', ...rest)
+  }(?:)${
+    repeatWithDepth(`${right})`, 'backward', ...rest)
+  }${right}`;
+}
+
+/**
+@param {string} pattern
+@param {'forward' | 'backward'} direction
+@param {number} reps
+@param {Set<string> | null} namesInRecursed
+@param {Array<number>} hiddenCaptures
+@param {Array<number>} addedHiddenCaptures
+@param {number} numCapturesPassed
+@returns {string}
+*/
+function repeatWithDepth(
+  pattern,
+  direction,
+  reps,
+  namesInRecursed,
+  hiddenCaptures,
+  addedHiddenCaptures,
+  numCapturesPassed
+) {
+  const startNum = 2;
+  const getDepthNum = i => direction === 'forward' ? (i + startNum) : (reps - i + startNum - 1);
+  let result = '';
+  for (let i = 0; i < reps; i++) {
+    const depthNum = getDepthNum(i);
+    result += replaceUnescaped(
+      pattern,
+      r`${captureDelim}|\\k<(?<backref>[^>]+)>`,
+      ({0: m, groups: {captureName, unnamed, backref}}) => {
+        if (backref && namesInRecursed && !namesInRecursed.has(backref)) {
+          // Don't alter backrefs to groups outside the recursed subpattern
+          return m;
+        }
+        const suffix = `_$${depthNum}`;
+        if (unnamed || captureName) {
+          const addedCaptureNum = numCapturesPassed + addedHiddenCaptures.length + 1;
+          addedHiddenCaptures.push(addedCaptureNum);
+          incrementIfAtLeast(hiddenCaptures, addedCaptureNum);
+          return unnamed ? m : `(?<${captureName}${suffix}>`;
+        }
+        return r`\k<${backref}${suffix}>`;
+      },
+      Context.DEFAULT
+    );
+  }
+  return result;
+}
+
+/**
+Updates the array in place by incrementing each value greater than or equal to the threshold.
+@param {Array<number>} arr
+@param {number} threshold
+*/
+function incrementIfAtLeast(arr, threshold) {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] >= threshold) {
+      arr[i]++;
+    }
+  }
+}
+
+/**
+@param {Map<number, Array<number>>} captureTransfers
+@param {string} left
+@param {number} reps
+@param {number} numCapturesAddedInExpansion
+@param {number} numAddedHiddenCapturesPreExpansion
+@param {number} numCapturesPassed
+@returns {Map<number, Array<number>>}
+*/
+function mapCaptureTransfers(captureTransfers, left, reps, numCapturesAddedInExpansion, numAddedHiddenCapturesPreExpansion, numCapturesPassed) {
+  if (captureTransfers.size && numCapturesAddedInExpansion) {
+    let numCapturesInLeft = 0;
+    forEachUnescaped(left, captureDelim, () => numCapturesInLeft++, Context.DEFAULT);
+    // Is 0 for global recursion
+    const recursionDelimCaptureNum = numCapturesPassed - numCapturesInLeft + numAddedHiddenCapturesPreExpansion;
+    const newCaptureTransfers = new Map();
+    captureTransfers.forEach((from, to) => {
+      const numCapturesInRight = (numCapturesAddedInExpansion - (numCapturesInLeft * reps)) / reps;
+      const numCapturesAddedInLeft = numCapturesInLeft * reps;
+      const newTo = to > (recursionDelimCaptureNum + numCapturesInLeft) ? to + numCapturesAddedInExpansion : to;
+      const newFrom = [];
+      for (const f of from) {
+        // Before the recursed subpattern
+        if (f <= recursionDelimCaptureNum) {
+          newFrom.push(f);
+        // After the recursed subpattern
+        } else if (f > (recursionDelimCaptureNum + numCapturesInLeft + numCapturesInRight)) {
+          newFrom.push(f + numCapturesAddedInExpansion);
+        // Within the recursed subpattern, on the left of the recursion token
+        } else if (f <= (recursionDelimCaptureNum + numCapturesInLeft)) {
+          for (let i = 0; i <= reps; i++) {
+            newFrom.push(f + (numCapturesInLeft * i));
+          }
+        // Within the recursed subpattern, on the right of the recursion token
+        } else {
+          for (let i = 0; i <= reps; i++) {
+            newFrom.push(f + numCapturesAddedInLeft + (numCapturesInRight * i));
+          }
+        }
+      }
+      newCaptureTransfers.set(newTo, newFrom);
+    });
+    return newCaptureTransfers;
+  }
+  return captureTransfers;
+}
+
+export {
+  recursion,
+};

package/.next/standalone/node_modules/regex-utilities/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "regex-utilities",
+  "version": "2.3.0",
+  "description": "Tiny helpers for processing regex syntax",
+  "author": "Steven Levithan",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./src/index.js"
+    }
+  },
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "types": "tsc src/index.js --rootDir src --declaration --allowJs --emitDeclarationOnly --outdir types",
+    "prebuild": "rm -rf types/*",
+    "build": "npm run types",
+    "pretest": "npm run build",
+    "test": "jasmine",
+    "prepare": "npm test"
+  },
+  "files": [
+    "src",
+    "types"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slevithan/regex-utilities.git"
+  },
+  "devDependencies": {
+    "jasmine": "^5.2.0",
+    "typescript": "5.5.4"
+  }
+}

package/.next/standalone/node_modules/regex-utilities/src/index.js

@@ -0,0 +1,170 @@
+// Constant properties for tracking regex syntax context
+export const Context = Object.freeze({
+  DEFAULT: 'DEFAULT',
+  CHAR_CLASS: 'CHAR_CLASS',
+});
+
+/**
+Replaces all unescaped instances of a regex pattern in the given context, using a replacement
+string or callback.
+
+Doesn't skip over complete multicharacter tokens (only `\` plus its folowing char) so must be used
+with knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.
+@param {string} expression Search target
+@param {string} needle Search as a regex pattern, with flags `su` applied
+@param {string | (match: RegExpExecArray, details: {
+  context: 'DEFAULT' | 'CHAR_CLASS';
+  negated: boolean;
+}) => string} replacement
+@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified
+@returns {string} Updated expression
+@example
+const str = '.\\.\\\\.[[\\.].].';
+replaceUnescaped(str, '\\.', '@');
+// → '@\\.\\\\@[[\\.]@]@'
+replaceUnescaped(str, '\\.', '@', Context.DEFAULT);
+// → '@\\.\\\\@[[\\.].]@'
+replaceUnescaped(str, '\\.', '@', Context.CHAR_CLASS);
+// → '.\\.\\\\.[[\\.]@].'
+*/
+export function replaceUnescaped(expression, needle, replacement, context) {
+  const re = new RegExp(String.raw`${needle}|(?<$skip>\[\^?|\\?.)`, 'gsu');
+  const negated = [false];
+  let numCharClassesOpen = 0;
+  let result = '';
+  for (const match of expression.matchAll(re)) {
+    const {0: m, groups: {$skip}} = match;
+    if (!$skip && (!context || (context === Context.DEFAULT) === !numCharClassesOpen)) {
+      if (replacement instanceof Function) {
+        result += replacement(match, {
+          context: numCharClassesOpen ? Context.CHAR_CLASS : Context.DEFAULT,
+          negated: negated[negated.length - 1],
+        });
+      } else {
+        result += replacement;
+      }
+      continue;
+    }
+    if (m[0] === '[') {
+      numCharClassesOpen++;
+      negated.push(m[1] === '^');
+    } else if (m === ']' && numCharClassesOpen) {
+      numCharClassesOpen--;
+      negated.pop();
+    }
+    result += m;
+  }
+  return result;
+}
+
+/**
+Runs a callback for each unescaped instance of a regex pattern in the given context.
+
+Doesn't skip over complete multicharacter tokens (only `\` plus its folowing char) so must be used
+with knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.
+@param {string} expression Search target
+@param {string} needle Search as a regex pattern, with flags `su` applied
+@param {(match: RegExpExecArray, details: {
+  context: 'DEFAULT' | 'CHAR_CLASS';
+  negated: boolean;
+}) => void} callback
+@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified
+*/
+export function forEachUnescaped(expression, needle, callback, context) {
+  // Do this the easy way
+  replaceUnescaped(expression, needle, callback, context);
+}
+
+/**
+Returns a match object for the first unescaped instance of a regex pattern in the given context, or
+`null`.
+
+Doesn't skip over complete multicharacter tokens (only `\` plus its folowing char) so must be used
+with knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.
+@param {string} expression Search target
+@param {string} needle Search as a regex pattern, with flags `su` applied
+@param {number} [pos] Offset to start the search
+@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified
+@returns {RegExpExecArray | null}
+*/
+export function execUnescaped(expression, needle, pos = 0, context) {
+  // Quick partial test; avoid the loop if not needed
+  if (!(new RegExp(needle, 'su').test(expression))) {
+    return null;
+  }
+  const re = new RegExp(`${needle}|(?<$skip>\\\\?.)`, 'gsu');
+  re.lastIndex = pos;
+  let numCharClassesOpen = 0;
+  let match;
+  while (match = re.exec(expression)) {
+    const {0: m, groups: {$skip}} = match;
+    if (!$skip && (!context || (context === Context.DEFAULT) === !numCharClassesOpen)) {
+      return match;
+    }
+    if (m === '[') {
+      numCharClassesOpen++;
+    } else if (m === ']' && numCharClassesOpen) {
+      numCharClassesOpen--;
+    }
+    // Avoid an infinite loop on zero-length matches
+    if (re.lastIndex == match.index) {
+      re.lastIndex++;
+    }
+  }
+  return null;
+}
+
+/**
+Checks whether an unescaped instance of a regex pattern appears in the given context.
+
+Doesn't skip over complete multicharacter tokens (only `\` plus its folowing char) so must be used
+with knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.
+@param {string} expression Search target
+@param {string} needle Search as a regex pattern, with flags `su` applied
+@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified
+@returns {boolean} Whether the pattern was found
+*/
+export function hasUnescaped(expression, needle, context) {
+  // Do this the easy way
+  return !!execUnescaped(expression, needle, 0, context);
+}
+
+/**
+Extracts the full contents of a group (subpattern) from the given expression, accounting for
+escaped characters, nested groups, and character classes. The group is identified by the position
+where its contents start (the string index just after the group's opening delimiter). Returns the
+rest of the string if the group is unclosed.
+
+Assumes UnicodeSets-mode syntax.
+@param {string} expression Search target
+@param {number} contentsStartPos
+@returns {string}
+*/
+export function getGroupContents(expression, contentsStartPos) {
+  const token = /\\?./gsu;
+  token.lastIndex = contentsStartPos;
+  let contentsEndPos = expression.length;
+  let numCharClassesOpen = 0;
+  // Starting search within an open group, after the group's opening
+  let numGroupsOpen = 1;
+  let match;
+  while (match = token.exec(expression)) {
+    const [m] = match;
+    if (m === '[') {
+      numCharClassesOpen++;
+    } else if (!numCharClassesOpen) {
+      if (m === '(') {
+        numGroupsOpen++;
+      } else if (m === ')') {
+        numGroupsOpen--;
+        if (!numGroupsOpen) {
+          contentsEndPos = match.index;
+          break;
+        }
+      }
+    } else if (m === ']') {
+      numCharClassesOpen--;
+    }
+  }
+  return expression.slice(contentsStartPos, contentsEndPos);
+}

package/.next/standalone/node_modules/shiki/dist/bundle-full.mjs

@@ -0,0 +1,41 @@
+import { t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+import { t as engine_oniguruma_exports } from "./engine-oniguruma.mjs";
+import { i as bundledLanguagesInfo, n as bundledLanguagesAlias, r as bundledLanguagesBase, t as bundledLanguages } from "./langs-bundle-full-4noeO3oH.mjs";
+import { bundledThemes, bundledThemesInfo } from "./themes.mjs";
+import { createBundledHighlighter, createSingletonShorthands, guessEmbeddedLanguages } from "@shikijs/core";
+export * from "@shikijs/core";
+//#region src/bundle-full.ts
+var bundle_full_exports = /* @__PURE__ */ __exportAll({
+	bundledLanguages: () => bundledLanguages,
+	bundledLanguagesAlias: () => bundledLanguagesAlias,
+	bundledLanguagesBase: () => bundledLanguagesBase,
+	bundledLanguagesInfo: () => bundledLanguagesInfo,
+	bundledThemes: () => bundledThemes,
+	bundledThemesInfo: () => bundledThemesInfo,
+	codeToHast: () => codeToHast,
+	codeToHtml: () => codeToHtml,
+	codeToTokens: () => codeToTokens,
+	codeToTokensBase: () => codeToTokensBase,
+	codeToTokensWithThemes: () => codeToTokensWithThemes,
+	createHighlighter: () => createHighlighter,
+	getLastGrammarState: () => getLastGrammarState,
+	getSingletonHighlighter: () => getSingletonHighlighter
+});
+/**
+* Initiate a highlighter instance and load the specified languages and themes.
+* Later it can be used synchronously to highlight code.
+*
+* Importing this function will bundle all languages and themes.
+* @see https://shiki.style/guide/bundles#shiki-bundle-full
+*
+* For granular control over the bundle, check:
+* @see https://shiki.style/guide/bundles#fine-grained-bundle
+*/
+const createHighlighter = /* @__PURE__ */ createBundledHighlighter({
+	langs: bundledLanguages,
+	themes: bundledThemes,
+	engine: () => (0, engine_oniguruma_exports.createOnigurumaEngine)(import("shiki/wasm"))
+});
+const { codeToHtml, codeToHast, codeToTokens, codeToTokensBase, codeToTokensWithThemes, getSingletonHighlighter, getLastGrammarState } = /* @__PURE__ */ createSingletonShorthands(createHighlighter, { guessEmbeddedLanguages });
+//#endregion
+export { bundledLanguages, bundledLanguagesAlias, bundledLanguagesBase, bundledLanguagesInfo, bundledThemes, bundledThemesInfo, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighter, getLastGrammarState, getSingletonHighlighter, bundle_full_exports as t };

package/.next/standalone/node_modules/shiki/dist/engine-oniguruma.mjs

@@ -0,0 +1,8 @@
+import { n as __reExport, t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+export * from "@shikijs/engine-oniguruma";
+//#region src/engine-oniguruma.ts
+var engine_oniguruma_exports = /* @__PURE__ */ __exportAll({});
+import * as import__shikijs_engine_oniguruma from "@shikijs/engine-oniguruma";
+__reExport(engine_oniguruma_exports, import__shikijs_engine_oniguruma);
+//#endregion
+export { engine_oniguruma_exports as t };