Astro+Directus(Visual-Editing)+Snipcart Test-Stack

node_modules/oniguruma-to-es/dist/esm/generate.d.ts

@@ -0,0 +1,27 @@
+/**
+@import {ToRegExpOptions} from './index.js';
+@import {RegexPlusAst} from './transform.js';
+@import {AlternativeNode, AssertionNode, BackreferenceNode, CapturingGroupNode, CharacterClassNode, CharacterClassRangeNode, CharacterNode, CharacterSetNode, FlagsNode, GroupNode, LookaroundAssertionNode, Node, QuantifierNode, SubroutineNode} from 'oniguruma-parser/parser';
+@import {Visitor} from 'oniguruma-parser/traverser';
+*/
+/**
+Generates a Regex+ compatible `pattern`, `flags`, and `options` from a Regex+ AST.
+@param {RegexPlusAst} ast
+@param {ToRegExpOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+  options: Object;
+  _captureTransfers: Map<number, Array<number>>;
+  _hiddenCaptures: Array<number>;
+}}
+*/
+export function generate(ast: RegexPlusAst, options?: ToRegExpOptions): {
+    pattern: string;
+    flags: string;
+    options: Object;
+    _captureTransfers: Map<number, Array<number>>;
+    _hiddenCaptures: Array<number>;
+};
+import type { RegexPlusAst } from './transform.js';
+import type { ToRegExpOptions } from './index.js';

node_modules/oniguruma-to-es/dist/esm/index.d.ts

@@ -0,0 +1,64 @@
+export type ToRegExpOptions = {
+    accuracy?: "default" | "strict";
+    avoidSubclass?: boolean;
+    flags?: string;
+    global?: boolean;
+    hasIndices?: boolean;
+    lazyCompileLength?: number;
+    rules?: {
+        allowOrphanBackrefs?: boolean;
+        asciiWordBoundaries?: boolean;
+        captureGroup?: boolean;
+        recursionLimit?: number;
+        singleline?: boolean;
+    };
+    target?: "auto" | "ES2025" | "ES2024" | "ES2018";
+    verbose?: boolean;
+};
+import { EmulatedRegExp } from './subclass.js';
+/**
+@import {EmulatedRegExpOptions} from './subclass.js';
+*/
+/**
+@typedef {{
+  accuracy?: keyof Accuracy;
+  avoidSubclass?: boolean;
+  flags?: string;
+  global?: boolean;
+  hasIndices?: boolean;
+  lazyCompileLength?: number;
+  rules?: {
+    allowOrphanBackrefs?: boolean;
+    asciiWordBoundaries?: boolean;
+    captureGroup?: boolean;
+    recursionLimit?: number;
+    singleline?: boolean;
+  };
+  target?: keyof Target;
+  verbose?: boolean;
+}} ToRegExpOptions
+*/
+/**
+Accepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.
+@param {string} pattern Oniguruma regex pattern.
+@param {ToRegExpOptions} [options]
+@returns {RegExp | EmulatedRegExp}
+*/
+export function toRegExp(pattern: string, options?: ToRegExpOptions): RegExp | EmulatedRegExp;
+/**
+Accepts an Oniguruma pattern and returns the details for an equivalent JavaScript `RegExp`.
+@param {string} pattern Oniguruma regex pattern.
+@param {ToRegExpOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+  options?: EmulatedRegExpOptions;
+}}
+*/
+export function toRegExpDetails(pattern: string, options?: ToRegExpOptions): {
+    pattern: string;
+    flags: string;
+    options?: EmulatedRegExpOptions;
+};
+import type { EmulatedRegExpOptions } from './subclass.js';
+export { EmulatedRegExp };

node_modules/oniguruma-to-es/dist/esm/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils.js", "../../src/options.js", "../../src/unicode.js", "../../src/transform.js", "../../src/generate.js", "../../src/subclass.js", "../../src/index.js"],
+  "sourcesContent": ["import {EsVersion, Target} from './options.js';\n\nconst cp = String.fromCodePoint;\nconst r = String.raw;\n\nconst envFlags = {};\n// Use `globalThis` to prevent env-testing fns from being replaced with constants during bundling\n// with Rolldown; see <github.com/slevithan/oniguruma-to-es/issues/42>\nconst globalRegExp = globalThis.RegExp;\nenvFlags.flagGroups = (() => {\n  try {\n    new globalRegExp('(?i:)');\n  } catch {\n    return false;\n  }\n  return true;\n})();\nenvFlags.unicodeSets = (() => {\n  try {\n    // Check for flag v support and also that nested classes can be parsed\n    // See <github.com/slevithan/oniguruma-to-es/pull/41>\n    new globalRegExp('[[]]', 'v');\n  } catch {\n    return false;\n  }\n  return true;\n})();\n// Detect WebKit bug: <github.com/slevithan/oniguruma-to-es/issues/30>\nenvFlags.bugFlagVLiteralHyphenIsRange = envFlags.unicodeSets ? (() => {\n  try {\n    new globalRegExp(r`[\\d\\-a]`, 'v');\n  } catch {\n    return true;\n  }\n  return false;\n})() : false;\n// Detect WebKit bug: <github.com/slevithan/oniguruma-to-es/issues/38>\nenvFlags.bugNestedClassIgnoresNegation = envFlags.unicodeSets && new globalRegExp('[[^a]]', 'v').test('a');\n\nfunction getNewCurrentFlags(current, {enable, disable}) {\n  return {\n    dotAll: !disable?.dotAll && !!(enable?.dotAll || current.dotAll),\n    ignoreCase: !disable?.ignoreCase && !!(enable?.ignoreCase || current.ignoreCase),\n  };\n}\n\nfunction getOrInsert(map, key, defaultValue) {\n  if (!map.has(key)) {\n    map.set(key, defaultValue);\n  }\n  return map.get(key);\n}\n\n/**\n@param {keyof Target} target\n@param {keyof Target} min\n@returns {boolean}\n*/\nfunction isMinTarget(target, min) {\n  return EsVersion[target] >= EsVersion[min];\n}\n\nfunction throwIfNullish(value, msg) {\n  if (value == null) {\n    throw new Error(msg ?? 'Value expected');\n  }\n  return value;\n}\n\nexport {\n  cp,\n  envFlags,\n  getNewCurrentFlags,\n  getOrInsert,\n  isMinTarget,\n  r,\n  throwIfNullish,\n};\n", "import {envFlags} from './utils.js';\n/**\n@import {ToRegExpOptions} from './index.js';\n*/\n\nconst Accuracy = /** @type {const} */ ({\n  default: 'default',\n  strict: 'strict',\n});\n\nconst EsVersion = {\n  ES2025: 2025,\n  ES2024: 2024,\n  ES2018: 2018,\n};\n\nconst Target = /** @type {const} */ ({\n  auto: 'auto',\n  ES2025: 'ES2025',\n  ES2024: 'ES2024',\n  ES2018: 'ES2018',\n});\n\n/**\nReturns a complete set of options, with default values set for options that weren't provided.\n@param {ToRegExpOptions} [options]\n@returns {Required<ToRegExpOptions>}\n*/\nfunction getOptions(options = {}) {\n  if ({}.toString.call(options) !== '[object Object]') {\n    throw new Error('Unexpected options');\n  }\n  if (options.target !== undefined && !Target[options.target]) {\n    throw new Error(`Unexpected target \"${options.target}\"`)\n  }\n  // Set default values\n  const opts = {\n    // Sets the level of emulation rigor/strictness.\n    accuracy: 'default',\n    // Disables advanced emulation that relies on returning a `RegExp` subclass, resulting in\n    // certain patterns not being emulatable.\n    avoidSubclass: false,\n    // Oniguruma flags; a string with `i`, `m`, `x`, `D`, `S`, `W`, `y{g}` in any order (all\n    // optional). Oniguruma's `m` is equivalent to JavaScript's `s` (`dotAll`).\n    flags: '',\n    // Include JavaScript flag `g` (`global`) in the result.\n    global: false,\n    // Include JavaScript flag `d` (`hasIndices`) in the result.\n    hasIndices: false,\n    // Delay regex construction until first use if the transpiled pattern is at least this length.\n    lazyCompileLength: Infinity,\n    // JavaScript version used for generated regexes. Using `auto` detects the best value based on\n    // your environment. Later targets allow faster processing, simpler generated source, and\n    // support for additional features.\n    target: 'auto',\n    // Disables minifications that simplify the pattern without changing the meaning.\n    verbose: false,\n    ...options,\n    // Advanced options that override standard behavior, error checking, and flags when enabled.\n    rules: {\n      // Useful with TextMate grammars that merge backreferences across patterns.\n      allowOrphanBackrefs: false,\n      // Use ASCII `\\b` and `\\B`, which increases search performance of generated regexes.\n      asciiWordBoundaries: false,\n      // Allow unnamed captures and numbered calls (backreferences and subroutines) when using\n      // named capture. This is Oniguruma option `ONIG_OPTION_CAPTURE_GROUP`; on by default in\n      // `vscode-oniguruma`.\n      captureGroup: false,\n      // Change the recursion depth limit from Oniguruma's `20` to an integer `2`\u2013`20`.\n      recursionLimit: 20,\n      // `^` as `\\A`; `$` as`\\Z`. Improves search performance of generated regexes without changing\n      // the meaning if searching line by line. This is Oniguruma option `ONIG_OPTION_SINGLELINE`.\n      singleline:Line truncated
+  "mappings": "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 truncated
+  "names": ["range", "slug", "node", "recursion", "createAlternative", "createCharacter", "createGroup", "traverse", "atomic", "parse"]
+}

node_modules/oniguruma-to-es/dist/esm/options.d.ts

@@ -0,0 +1,26 @@
+export namespace Accuracy {
+    let _default: "default";
+    export { _default as default };
+    export let strict: "strict";
+}
+export namespace EsVersion {
+    let ES2025: number;
+    let ES2024: number;
+    let ES2018: number;
+}
+/**
+Returns a complete set of options, with default values set for options that weren't provided.
+@param {ToRegExpOptions} [options]
+@returns {Required<ToRegExpOptions>}
+*/
+export function getOptions(options?: ToRegExpOptions): Required<ToRegExpOptions>;
+export namespace Target {
+    export let auto: "auto";
+    let ES2025_1: "ES2025";
+    export { ES2025_1 as ES2025 };
+    let ES2024_1: "ES2024";
+    export { ES2024_1 as ES2024 };
+    let ES2018_1: "ES2018";
+    export { ES2018_1 as ES2018 };
+}
+import type { ToRegExpOptions } from './index.js';

node_modules/oniguruma-to-es/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/oniguruma-to-es/dist/esm/subclass.d.ts

@@ -0,0 +1,39 @@
+export type EmulatedRegExpOptions = {
+    hiddenCaptures?: Array<number>;
+    lazyCompile?: boolean;
+    strategy?: string | null;
+    transfers?: Array<[number, Array<number>]>;
+};
+/**
+@typedef {{
+  hiddenCaptures?: Array<number>;
+  lazyCompile?: boolean;
+  strategy?: string | null;
+  transfers?: Array<[number, Array<number>]>;
+}} EmulatedRegExpOptions
+*/
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but can be given
+results from `toRegExpDetails` to produce the same result as `toRegExp`.
+*/
+export class EmulatedRegExp extends RegExp {
+    /**
+     @overload
+     @param {string} pattern
+     @param {string} [flags]
+     @param {EmulatedRegExpOptions} [options]
+     */
+    constructor(pattern: string, flags?: string | undefined, options?: EmulatedRegExpOptions | undefined);
+    /**
+     @overload
+     @param {EmulatedRegExp} pattern
+     @param {string} [flags]
+     */
+    constructor(pattern: EmulatedRegExp, flags?: string | undefined);
+    /**
+    Can be used to serialize the instance.
+    @type {EmulatedRegExpOptions}
+    */
+    rawOptions: EmulatedRegExpOptions;
+    #private;
+}

node_modules/oniguruma-to-es/dist/esm/transform.d.ts

@@ -0,0 +1,54 @@
+export type RegexPlusAst = OnigurumaAst & {
+    options: {
+        disable: {
+            [key: string]: boolean;
+        };
+        force: {
+            [key: string]: boolean;
+        };
+    };
+    _originMap: Map<CapturingGroupNode, CapturingGroupNode>;
+    _strategy: string | null;
+};
+/**
+@import {CapturingGroupNode, OnigurumaAst, Node} from 'oniguruma-parser/parser';
+@import {Visitor} from 'oniguruma-parser/traverser';
+*/
+/**
+@typedef {
+  OnigurumaAst & {
+    options: {
+      disable: {[key: string]: boolean};
+      force: {[key: string]: boolean};
+    };
+    _originMap: Map<CapturingGroupNode, CapturingGroupNode>;
+    _strategy: string | null;
+  }
+} RegexPlusAst
+*/
+/**
+Transforms an Oniguruma AST in-place to a [Regex+](https://github.com/slevithan/regex) AST.
+Assumes target ES2025, expecting the generator to down-convert to the desired JS target version.
+
+Regex+'s syntax and behavior is a strict superset of native JavaScript, so the AST is very close
+to representing native ES2025 `RegExp` but with some added features (atomic groups, possessive
+quantifiers, recursion). The AST doesn't use some of Regex+'s extended features like flag x or
+subroutines because they follow PCRE behavior and work somewhat differently than in Oniguruma. The
+AST represents what's needed to precisely reproduce Oniguruma behavior using Regex+.
+@param {OnigurumaAst} ast
+@param {{
+  accuracy?: keyof Accuracy;
+  asciiWordBoundaries?: boolean;
+  avoidSubclass?: boolean;
+  bestEffortTarget?: keyof Target;
+}} [options]
+@returns {RegexPlusAst}
+*/
+export function transform(ast: OnigurumaAst, options?: {
+    accuracy?: "default" | "strict";
+    asciiWordBoundaries?: boolean;
+    avoidSubclass?: boolean;
+    bestEffortTarget?: "auto" | "ES2025" | "ES2024" | "ES2018";
+}): RegexPlusAst;
+import type { OnigurumaAst } from 'oniguruma-parser/parser';
+import type { CapturingGroupNode } from 'oniguruma-parser/parser';

node_modules/oniguruma-to-es/dist/esm/unicode.d.ts

@@ -0,0 +1,6 @@
+export const asciiSpaceChar: "[\t-\r ]";
+export const defaultWordChar: string;
+export function getIgnoreCaseMatchChars(char: any): any[];
+export const JsUnicodePropertyMap: Map<string, string>;
+export const PosixClassMap: Map<string, string>;
+export const UnicodePropertiesWithSpecificCase: Set<string>;

node_modules/oniguruma-to-es/dist/esm/utils.d.ts

@@ -0,0 +1,25 @@
+export const cp: (...codePoints: number[]) => string;
+export namespace envFlags {
+    let flagGroups: boolean;
+    let unicodeSets: boolean;
+    let bugFlagVLiteralHyphenIsRange: boolean;
+    let bugNestedClassIgnoresNegation: boolean;
+}
+export function getNewCurrentFlags(current: any, { enable, disable }: {
+    enable: any;
+    disable: any;
+}): {
+    dotAll: boolean;
+    ignoreCase: boolean;
+};
+export function getOrInsert(map: any, key: any, defaultValue: any): any;
+/**
+@param {keyof Target} target
+@param {keyof Target} min
+@returns {boolean}
+*/
+export function isMinTarget(target: "auto" | "ES2025" | "ES2024" | "ES2018", min: "auto" | "ES2025" | "ES2024" | "ES2018"): boolean;
+export const r: (template: {
+    raw: readonly string[] | ArrayLike<string>;
+}, ...substitutions: any[]) => string;
+export function throwIfNullish(value: any, msg: any): any;