@bilal-fazlani/mock-server 0.2.1 → 0.3.0

package/.next/standalone/node_modules/property-information/lib/util/info.js

@@ -0,0 +1,32 @@
+/**
+ * @import {Info as InfoType} from 'property-information'
+ */
+
+/** @type {InfoType} */
+export class Info {
+  /**
+   * @param {string} property
+   *   Property.
+   * @param {string} attribute
+   *   Attribute.
+   * @returns
+   *   Info.
+   */
+  constructor(property, attribute) {
+    this.attribute = attribute
+    this.property = property
+  }
+}
+
+Info.prototype.attribute = ''
+Info.prototype.booleanish = false
+Info.prototype.boolean = false
+Info.prototype.commaOrSpaceSeparated = false
+Info.prototype.commaSeparated = false
+Info.prototype.defined = false
+Info.prototype.mustUseProperty = false
+Info.prototype.number = false
+Info.prototype.overloadedBoolean = false
+Info.prototype.property = ''
+Info.prototype.spaceSeparated = false
+Info.prototype.space = undefined

package/.next/standalone/node_modules/property-information/lib/util/merge.js

@@ -0,0 +1,27 @@
+/**
+ * @import {Info, Space} from 'property-information'
+ */
+
+import {Schema} from './schema.js'
+
+/**
+ * @param {ReadonlyArray<Schema>} definitions
+ *   Definitions.
+ * @param {Space | undefined} [space]
+ *   Space.
+ * @returns {Schema}
+ *   Schema.
+ */
+export function merge(definitions, space) {
+  /** @type {Record<string, Info>} */
+  const property = {}
+  /** @type {Record<string, string>} */
+  const normal = {}
+
+  for (const definition of definitions) {
+    Object.assign(property, definition.property)
+    Object.assign(normal, definition.normal)
+  }
+
+  return new Schema(property, normal, space)
+}

package/.next/standalone/node_modules/property-information/lib/util/schema.js

@@ -0,0 +1,29 @@
+/**
+ * @import {Schema as SchemaType, Space} from 'property-information'
+ */
+
+/** @type {SchemaType} */
+export class Schema {
+  /**
+   * @param {SchemaType['property']} property
+   *   Property.
+   * @param {SchemaType['normal']} normal
+   *   Normal.
+   * @param {Space | undefined} [space]
+   *   Space.
+   * @returns
+   *   Schema.
+   */
+  constructor(property, normal, space) {
+    this.normal = normal
+    this.property = property
+
+    if (space) {
+      this.space = space
+    }
+  }
+}
+
+Schema.prototype.normal = {}
+Schema.prototype.property = {}
+Schema.prototype.space = undefined

package/.next/standalone/node_modules/property-information/lib/util/types.js

@@ -0,0 +1,13 @@
+let powers = 0
+
+export const boolean = increment()
+export const booleanish = increment()
+export const overloadedBoolean = increment()
+export const number = increment()
+export const spaceSeparated = increment()
+export const commaSeparated = increment()
+export const commaOrSpaceSeparated = increment()
+
+function increment() {
+  return 2 ** ++powers
+}

package/.next/standalone/node_modules/property-information/lib/xlink.js

@@ -0,0 +1,17 @@
+import {create} from './util/create.js'
+
+export const xlink = create({
+  properties: {
+    xLinkActuate: null,
+    xLinkArcRole: null,
+    xLinkHref: null,
+    xLinkRole: null,
+    xLinkShow: null,
+    xLinkTitle: null,
+    xLinkType: null
+  },
+  space: 'xlink',
+  transform(_, property) {
+    return 'xlink:' + property.slice(5).toLowerCase()
+  }
+})

package/.next/standalone/node_modules/property-information/lib/xml.js

@@ -0,0 +1,9 @@
+import {create} from './util/create.js'
+
+export const xml = create({
+  properties: {xmlBase: null, xmlLang: null, xmlSpace: null},
+  space: 'xml',
+  transform(_, property) {
+    return 'xml:' + property.slice(3).toLowerCase()
+  }
+})

package/.next/standalone/node_modules/property-information/lib/xmlns.js

@@ -0,0 +1,9 @@
+import {create} from './util/create.js'
+import {caseInsensitiveTransform} from './util/case-insensitive-transform.js'
+
+export const xmlns = create({
+  attributes: {xmlnsxlink: 'xmlns:xlink'},
+  properties: {xmlnsXLink: null, xmlns: null},
+  space: 'xmlns',
+  transform: caseInsensitiveTransform
+})

package/.next/standalone/node_modules/property-information/package.json

@@ -0,0 +1,84 @@
+{
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "bugs": "https://github.com/wooorm/property-information/issues",
+  "contributors": [
+    "Andrew Burgess <andrew@andrewburgess.io>",
+    "Dustin Deus <deusdustin@gmail.com> (http://starptech.de)",
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "description": "Info on the properties and attributes of the web platform",
+  "devDependencies": {
+    "@types/mdast": "^4.0.0",
+    "@types/node": "^25.0.0",
+    "alpha-sort": "^5.0.0",
+    "c8": "^11.0.0",
+    "html-element-attributes": "^3.0.0",
+    "html-event-attributes": "^2.0.0",
+    "mdast-zone": "^6.0.0",
+    "prettier": "^3.0.0",
+    "remark-cli": "^12.0.0",
+    "remark-preset-wooorm": "^11.0.0",
+    "svg-element-attributes": "^2.0.0",
+    "svg-event-attributes": "^2.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^6.0.0",
+    "unist-builder": "^4.0.0",
+    "xo": "^2.0.0"
+  },
+  "exports": "./index.js",
+  "files": [
+    "index.d.ts",
+    "index.js",
+    "lib/"
+  ],
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/wooorm"
+  },
+  "keywords": [
+    "aria",
+    "attribute",
+    "html",
+    "information",
+    "info",
+    "property",
+    "svg"
+  ],
+  "license": "MIT",
+  "name": "property-information",
+  "overrides": {
+    "c8": {
+      "yargs": "^18.0.0"
+    }
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm",
+      "./script/list.js"
+    ]
+  },
+  "repository": "wooorm/property-information",
+  "scripts": {
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark --frail --output --quiet -- . && prettier --log-level warn --write -- . && xo --fix",
+    "generate": "node --conditions development script/generate-react.js && node --conditions development script/generate-exceptions.js",
+    "test-api": "node --conditions development test.js",
+    "test-coverage": "c8 --100 --reporter lcov -- npm run test-api",
+    "test": "npm run generate && npm run build && npm run format && npm run test-coverage"
+  },
+  "sideEffects": false,
+  "typeCoverage": {
+    "atLeast": 100,
+    "ignoreCatch": true
+  },
+  "type": "module",
+  "version": "7.2.0"
+}

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

@@ -0,0 +1,60 @@
+{
+  "name": "regex",
+  "version": "6.1.0",
+  "description": "Regex template tag with extended syntax, context-aware interpolation, and always-on best practices",
+  "author": "Steven Levithan",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/regex.d.ts",
+        "default": "./dist/esm/regex.js"
+      },
+      "require": {
+        "types": "./dist/cjs/regex.d.ts",
+        "default": "./dist/cjs/regex.js"
+      }
+    },
+    "./internals": {
+      "types": "./dist/esm/internals.d.ts",
+      "import": "./src/internals.js"
+    }
+  },
+  "browser": "./dist/regex.min.js",
+  "main": "./dist/cjs/regex.js",
+  "types": "./dist/cjs/regex.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slevithan/regex.git"
+  },
+  "keywords": [
+    "regex",
+    "regexp"
+  ],
+  "dependencies": {
+    "regex-utilities": "^2.3.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "esbuild": "^0.27.1",
+    "expect-type": "^1.3.0",
+    "jasmine": "^5.13.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "bundle:global": "esbuild src/regex.js --global-name=Regex --bundle --minify --sourcemap --outfile=dist/regex.min.js",
+    "bundle:esm": "esbuild src/regex.js --format=esm --bundle --sourcemap --outfile=dist/esm/regex.js",
+    "bundle:cjs": "esbuild src/regex.js --format=cjs --bundle --sourcemap --outfile=dist/cjs/regex.js",
+    "types": "tsc src/regex.js src/internals.js --rootDir src --declaration --allowJs --emitDeclarationOnly --outDir types",
+    "prebuild": "rm -rf dist/* types/*",
+    "build": "pnpm run bundle:global && pnpm run bundle:esm && pnpm run bundle:cjs && pnpm run types",
+    "postbuild": "node scripts/postbuild.js",
+    "pretest": "pnpm run build",
+    "test": "jasmine && tsc --project spec/types/tsconfig.test.json && attw --pack . --entrypoints ."
+  }
+}

package/.next/standalone/node_modules/regex/src/atomic.js

@@ -0,0 +1,224 @@
+import {incrementIfAtLeast, noncapturingDelim, spliceStr} from './utils-internals.js';
+import {Context, replaceUnescaped} from 'regex-utilities';
+/**
+@import {PluginData, PluginResult} from './regex.js';
+*/
+
+const atomicPluginToken = new RegExp(String.raw`(?<noncapturingStart>${noncapturingDelim})|(?<capturingStart>\((?:\?<[^>]+>)?)|\\?.`, 'gsu');
+
+/**
+Apply transformations for atomic groups: `(?>…)`.
+@param {string} expression
+@param {PluginData} [data]
+@returns {Required<PluginResult>}
+*/
+function atomic(expression, data) {
+  const hiddenCaptures = data?.hiddenCaptures ?? [];
+  // Capture transfer is used by <github.com/slevithan/oniguruma-to-es>
+  let captureTransfers = data?.captureTransfers ?? new Map();
+  if (!/\(\?>/.test(expression)) {
+    return {
+      pattern: expression,
+      captureTransfers,
+      hiddenCaptures,
+    };
+  }
+
+  const aGDelim = '(?>';
+  const emulatedAGDelim = '(?:(?=(';
+  const captureNumMap = [0];
+  const addedHiddenCaptures = [];
+  let numCapturesBeforeAG = 0;
+  let numAGs = 0;
+  let aGPos = NaN;
+  let hasProcessedAG;
+  do {
+    hasProcessedAG = false;
+    let numCharClassesOpen = 0;
+    let numGroupsOpenInAG = 0;
+    let inAG = false;
+    let match;
+    atomicPluginToken.lastIndex = Number.isNaN(aGPos) ? 0 : aGPos + emulatedAGDelim.length;
+    while (match = atomicPluginToken.exec(expression)) {
+      const {0: m, index, groups: {capturingStart, noncapturingStart}} = match;
+      if (m === '[') {
+        numCharClassesOpen++;
+      } else if (!numCharClassesOpen) {
+
+        if (m === aGDelim && !inAG) {
+          aGPos = index;
+          inAG = true;
+        } else if (inAG && noncapturingStart) {
+          numGroupsOpenInAG++;
+        } else if (capturingStart) {
+          if (inAG) {
+            numGroupsOpenInAG++;
+          } else {
+            numCapturesBeforeAG++;
+            captureNumMap.push(numCapturesBeforeAG + numAGs);
+          }
+        } else if (m === ')' && inAG) {
+          if (!numGroupsOpenInAG) {
+            numAGs++;
+            const addedCaptureNum = numCapturesBeforeAG + numAGs;
+            // Replace `expression` and use `<$$N>` as a temporary wrapper for the backref so it
+            // can avoid backref renumbering afterward. Wrap the whole substitution (including the
+            // lookahead and following backref) in a noncapturing group to handle following
+            // quantifiers and literal digits
+            expression = `${expression.slice(0, aGPos)}${emulatedAGDelim}${
+                expression.slice(aGPos + aGDelim.length, index)
+              }))<$$${addedCaptureNum}>)${expression.slice(index + 1)}`;
+            hasProcessedAG = true;
+            addedHiddenCaptures.push(addedCaptureNum);
+            incrementIfAtLeast(hiddenCaptures, addedCaptureNum);
+            if (captureTransfers.size) {
+              const newCaptureTransfers = new Map();
+              captureTransfers.forEach((from, to) => {
+                newCaptureTransfers.set(
+                  to >= addedCaptureNum ? to + 1 : to,
+                  from.map(f => f >= addedCaptureNum ? f + 1 : f)
+                );
+              });
+              captureTransfers = newCaptureTransfers;
+            }
+            break;
+          }
+          numGroupsOpenInAG--;
+        }
+
+      } else if (m === ']') {
+        numCharClassesOpen--;
+      }
+    }
+  // Start over from the beginning of the atomic group's contents, in case the processed group
+  // contains additional atomic groups
+  } while (hasProcessedAG);
+
+  hiddenCaptures.push(...addedHiddenCaptures);
+
+  // Second pass to adjust numbered backrefs
+  expression = replaceUnescaped(
+    expression,
+    String.raw`\\(?<backrefNum>[1-9]\d*)|<\$\$(?<wrappedBackrefNum>\d+)>`,
+    ({0: m, groups: {backrefNum, wrappedBackrefNum}}) => {
+      if (backrefNum) {
+        const bNum = +backrefNum;
+        if (bNum > captureNumMap.length - 1) {
+          throw new Error(`Backref "${m}" greater than number of captures`);
+        }
+        return `\\${captureNumMap[bNum]}`;
+      }
+      return `\\${wrappedBackrefNum}`;
+    },
+    Context.DEFAULT
+  );
+
+  return {
+    pattern: expression,
+    captureTransfers,
+    hiddenCaptures,
+  };
+}
+
+const baseQuantifier = String.raw`(?:[?*+]|\{\d+(?:,\d*)?\})`;
+// Complete tokenizer for base syntax; doesn't (need to) know about character-class-only syntax
+const possessivePluginToken = new RegExp(String.raw`
+\\(?: \d+
+  | c[A-Za-z]
+  | [gk]<[^>]+>
+  | [pPu]\{[^\}]+\}
+  | u[A-Fa-f\d]{4}
+  | x[A-Fa-f\d]{2}
+  )
+| \((?: \? (?: [:=!>]
+  | <(?:[=!]|[^>]+>)
+  | [A-Za-z\-]+:
+  | \(DEFINE\)
+  ))?
+| (?<qBase>${baseQuantifier})(?<qMod>[?+]?)(?<invalidQ>[?*+\{]?)
+| \\?.
+`.replace(/\s+/g, ''), 'gsu');
+
+/**
+Transform posessive quantifiers into atomic groups. The posessessive quantifiers are:
+`?+`, `*+`, `++`, `{N}+`, `{N,}+`, `{N,N}+`.
+This follows Java, PCRE, Perl, and Python.
+Possessive quantifiers in Oniguruma and Onigmo are only: `?+`, `*+`, `++`.
+@param {string} expression
+@returns {PluginResult}
+*/
+function possessive(expression) {
+  if (!(new RegExp(`${baseQuantifier}\\+`).test(expression))) {
+    return {
+      pattern: expression,
+    };
+  }
+
+  const openGroupIndices = [];
+  let lastGroupIndex = null;
+  let lastCharClassIndex = null;
+  let lastToken = '';
+  let numCharClassesOpen = 0;
+  let match;
+  possessivePluginToken.lastIndex = 0;
+  while (match = possessivePluginToken.exec(expression)) {
+    const {0: m, index, groups: {qBase, qMod, invalidQ}} = match;
+    if (m === '[') {
+      if (!numCharClassesOpen) {
+        lastCharClassIndex = index;
+      }
+      numCharClassesOpen++;
+    } else if (m === ']') {
+      if (numCharClassesOpen) {
+        numCharClassesOpen--;
+      // Unmatched `]`
+      } else {
+        lastCharClassIndex = null;
+      }
+    } else if (!numCharClassesOpen) {
+
+      if (qMod === '+' && lastToken && !lastToken.startsWith('(')) {
+        // Invalid following quantifier would become valid via the wrapping group
+        if (invalidQ) {
+          throw new Error(`Invalid quantifier "${m}"`);
+        }
+        let charsAdded = -1; // -1 for removed trailing `+`
+        // Possessivizing fixed repetition quantifiers like `{2}` does't change their behavior, so
+        // avoid doing so (convert them to greedy)
+        if (/^\{\d+\}$/.test(qBase)) {
+          expression = spliceStr(expression, index + qBase.length, qMod, '');
+        } else {
+          if (lastToken === ')' || lastToken === ']') {
+            const nodeIndex = lastToken === ')' ? lastGroupIndex : lastCharClassIndex;
+            // Unmatched `)` would break out of the wrapping group and mess with handling.
+            // Unmatched `]` wouldn't be a problem, but it's unnecessary to have dedicated support
+            // for unescaped `]++` since this won't work with flag u or v anyway
+            if (nodeIndex === null) {
+              throw new Error(`Invalid unmatched "${lastToken}"`);
+            }
+            expression = `${expression.slice(0, nodeIndex)}(?>${expression.slice(nodeIndex, index)}${qBase})${expression.slice(index + m.length)}`;
+          } else {
+            expression = `${expression.slice(0, index - lastToken.length)}(?>${lastToken}${qBase})${expression.slice(index + m.length)}`;
+          }
+          charsAdded += 4; // `(?>)`
+        }
+        possessivePluginToken.lastIndex += charsAdded;
+      } else if (m[0] === '(') {
+        openGroupIndices.push(index);
+      } else if (m === ')') {
+        lastGroupIndex = openGroupIndices.length ? openGroupIndices.pop() : null;
+      }
+
+    }
+    lastToken = m;
+  }
+
+  return {
+    pattern: expression,
+  };
+}
+
+export {
+  atomic,
+  possessive,
+};

package/.next/standalone/node_modules/regex/src/internals.js

@@ -0,0 +1,2 @@
+export {atomic, possessive} from './atomic.js';
+export {RegExpSubclass} from './subclass.js';

package/.next/standalone/node_modules/regex/src/subclass.js

@@ -0,0 +1,98 @@
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but automatically
+adjusts subpattern matches and indices (with flag `d`) to account for captures added as part of
+emulating extended syntax.
+*/
+class RegExpSubclass extends RegExp {
+  // Avoid `#private` to allow for subclassing
+  /**
+  @private
+  @type {Map<number, {
+    hidden: true;
+  }>}
+  */
+  _captureMap;
+  /**
+  @overload
+  @param {string} expression
+  @param {string} [flags]
+  @param {{
+    hiddenCaptures?: Array<number>;
+  }} [options]
+  */
+  /**
+  @overload
+  @param {RegExpSubclass} expression
+  @param {string} [flags]
+  */
+  constructor(expression, flags, options) {
+    // Argument `options` isn't provided when regexes are copied via `new RegExpSubclass(regexp)`,
+    // including as part of the internal handling of string methods `matchAll` and `split`
+    if (expression instanceof RegExp) {
+      if (options) {
+        throw new Error('Cannot provide options when copying a regexp');
+      }
+      super(expression, flags);
+      if (expression instanceof RegExpSubclass) {
+        this._captureMap = expression._captureMap;
+      } else {
+        this._captureMap = new Map();
+      }
+    } else {
+      super(expression, flags);
+      const hiddenCaptures = options?.hiddenCaptures ?? [];
+      this._captureMap = createCaptureMap(hiddenCaptures);
+    }
+  }
+  /**
+  Called internally by all String/RegExp methods that use regexes.
+  @override
+  @param {string} str
+  @returns {RegExpExecArray | null}
+  */
+  exec(str) {
+    const match = super.exec(str);
+    if (!match || !this._captureMap.size) {
+      return match;
+    }
+    const matchCopy = [...match];
+    // Empty all but the first value of the array while preserving its other properties
+    match.length = 1;
+    let indicesCopy;
+    if (this.hasIndices) {
+      indicesCopy = [...match.indices];
+      match.indices.length = 1;
+    }
+    for (let i = 1; i < matchCopy.length; i++) {
+      if (!this._captureMap.get(i)?.hidden) {
+        match.push(matchCopy[i]);
+        if (this.hasIndices) {
+          match.indices.push(indicesCopy[i]);
+        }
+      }
+    }
+    return match;
+  }
+}
+
+/**
+Build the capturing group map, with hidden captures marked to indicate their submatches shouldn't
+appear in match results.
+@param {Array<number>} hiddenCaptures
+@returns {Map<number, {
+  hidden: true;
+}>}
+*/
+function createCaptureMap(hiddenCaptures) {
+  const captureMap = new Map();
+  for (const num of hiddenCaptures) {
+    captureMap.set(num, {
+      hidden: true,
+    });
+  }
+  return captureMap;
+}
+
+export {
+  RegExpSubclass,
+};

package/.next/standalone/node_modules/regex/src/utils-internals.js

@@ -0,0 +1,33 @@
+// Separating some utils for improved tree shaking of the `./internals` export
+
+const noncapturingDelim = String.raw`\(\?(?:[:=!>A-Za-z\-]|<[=!]|\(DEFINE\))`;
+
+/**
+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 {string} str
+@param {number} pos
+@param {string} oldValue
+@param {string} newValue
+@returns {string}
+*/
+function spliceStr(str, pos, oldValue, newValue) {
+  return str.slice(0, pos) + newValue + str.slice(pos + oldValue.length);
+}
+
+export {
+  incrementIfAtLeast,
+  noncapturingDelim,
+  spliceStr,
+};