@autometa/cucumber-expressions 0.4.3 → 1.0.0-rc.0

package/dist/index.js

@@ -1,582 +1,309 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AnyParam: () => AnyParam,
-  BoolParam: () => BoolParam,
-  BooleanParam: () => BooleanParam,
-  DateParam: () => DateParam,
-  DifferentStepTypeMatch: () => DifferentStepTypeMatch,
-  FuzzySearchReport: () => FuzzySearchReport,
-  NumberParam: () => NumberParam,
-  OrdinalParam: () => OrdinalParam,
-  PrimitiveParam: () => PrimitiveParam,
-  SameStepTypeMatch: () => SameStepTypeMatch,
-  TextParam: () => TextParam,
-  UnknownParam: () => UnknownParam,
-  buildFuzzySearchReport: () => buildFuzzySearchReport,
-  checkMatch: () => checkMatch,
-  defineParameterType: () => defineParameterType,
-  getDiff: () => getDiff,
-  getDiffs: () => getDiffs,
-  isExpressionCandidate: () => isExpressionCandidate,
-  limitDiffs: () => limitDiffs,
-  refineDiff: () => refineDiff
-});
-module.exports = __toCommonJS(src_exports);
+import { ParameterType, Argument } from '@cucumber/cucumber-expressions';
 
-// src/step-matcher.ts
-var import_diff = require("diff");
-var import_closest_match = require("closest-match");
-function checkMatch(text, it) {
-  return it.matches(text);
+// src/parameter-types.ts
+var transformSymbol = Symbol("autometa:cucumber:transform");
+var extensionsApplied = false;
+var originalTransform;
+var originalGetValue;
+function attachTransform(parameterType, transform) {
+  parameterType[transformSymbol] = transform;
 }
-function limitDiffs(sameStepType, differentStepType, max) {
-  const sameDistances = sameStepType.map((it) => it.distance);
-  const maxSameStepDistance = Math.max(...sameDistances);
-  const otherStepDistance = differentStepType.map((it) => it.distance);
-  const minDifferentStepDistance = Math.min(...otherStepDistance);
-  if (maxSameStepDistance > minDifferentStepDistance) {
-    const filter = sameStepType.filter(
-      (it) => it.distance <= minDifferentStepDistance
-    );
-    if (filter.length >= max) {
-      return { same: filter.slice(0, max), other: [] };
-    }
-    const diff = max - filter.length;
-    const sameSlice = sameStepType.slice(0, diff);
-    const differentSlice = differentStepType.slice(0, max - diff);
-    return { same: sameSlice, other: differentSlice };
-  }
-  const maxIndex = Math.min(max, sameStepType.length);
-  return { same: sameStepType.slice(0, maxIndex), other: [] };
-}
-function removeWhitespaceFromQuotedSubstrings(inputString) {
-  const regex = /(["'])([^"']*?)\1/g;
-  let modifiedString = inputString;
-  let match;
-  while (match = regex.exec(inputString)) {
-    const quotedSubstring = match[0];
-    const strippedSubstring = match[2].replace(/\s+/g, "");
-    modifiedString = modifiedString.replace(
-      quotedSubstring,
-      `${match[1]}${strippedSubstring}${match[1]}`
-    );
+function applyCucumberExtensions() {
+  if (extensionsApplied) {
+    return;
   }
-  return modifiedString;
-}
-function getDiffs(text, maxResults, step) {
-  const sorted = step.map((it) => {
-    if (checkMatch(text, it)) {
-      return { merged: text, step: it, gherkin: text, distance: 0 };
+  originalTransform = originalTransform ?? ParameterType.prototype.transform;
+  ParameterType.prototype.transform = function transform(thisObj, groupValues) {
+    const transformFn = this[transformSymbol];
+    if (transformFn) {
+      return transformFn(groupValues ?? null, {
+        world: thisObj,
+        parameterType: this
+      });
     }
-    const collapsed = removeWhitespaceFromQuotedSubstrings(text);
-    const diff = getDiff(collapsed, it);
-    const refined = refineDiff(diff);
-    const dist = (0, import_closest_match.distance)(collapsed, refined);
-    return { merged: refined, step: it, gherkin: text, distance: dist };
-  }).sort((a, b) => a.distance - b.distance);
-  const max = Math.min(maxResults, sorted.length);
-  return sorted.slice(0, max);
-}
-function getDiff(text, it) {
-  return (0, import_diff.diffWordsWithSpace)(text, it.expression.source);
-}
-function refineDiff(diff) {
-  const strings = [];
-  for (let index = 0; index < diff.length; index++) {
-    const gherkinChange = diff[index];
-    const scopeChange = diff[index + 1];
-    if (isExpressionCandidate(gherkinChange, scopeChange)) {
-      strings.push(gherkinChange.value);
-      const extra = extractTextAfterPlaceholder(scopeChange.value);
-      if (extra) {
-        strings.push(extra);
+    const normalized = groupValues ? [...groupValues] : [];
+    if (!originalTransform) {
+      throw new Error("Cucumber extensions have not been initialised correctly");
+    }
+    return originalTransform.call(this, thisObj, normalized);
+  };
+  originalGetValue = originalGetValue ?? Argument.prototype.getValue;
+  Argument.prototype.getValue = function getValue(context) {
+    const group = this.group;
+    let values = null;
+    if (group) {
+      const childValues = group.children?.map((child) => child.value).filter((value) => value !== void 0);
+      if (childValues && childValues.length > 0) {
+        values = childValues;
+      } else if (group.value !== void 0 && group.value !== null) {
+        values = [group.value];
+      } else if (group.values) {
+        values = group.values;
       }
-      index++;
-      continue;
     }
-    if (gherkinChange.removed === true) {
-      continue;
+    const parameterType = this.parameterType;
+    const transformFn = parameterType?.[transformSymbol];
+    if (transformFn && parameterType) {
+      return transformFn(values, {
+        world: context,
+        parameterType
+      });
     }
-    if (gherkinChange.value) {
-      strings.push(gherkinChange.value);
-      continue;
+    if (!originalGetValue) {
+      throw new Error("Cucumber extensions have not been initialised correctly");
     }
-  }
-  return strings.join("");
+    return originalGetValue.call(this, context);
+  };
+  extensionsApplied = true;
 }
-function extractTextAfterPlaceholder(inputString) {
-  const regex = /\{[^{}]+\}(.+)?/;
-  const match = regex.exec(inputString);
-  if (match && match[1]) {
-    return match[1];
-  } else {
-    return null;
+function resetCucumberExtensions() {
+  if (!extensionsApplied) {
+    return;
   }
-}
-function isExpressionCandidate(change1, change2) {
-  if (change1 && change1.removed && change2 && change2.added) {
-    const scopeText = change2.value;
-    return /{.*}/.test(scopeText);
+  if (originalTransform) {
+    ParameterType.prototype.transform = originalTransform;
   }
-  return false;
+  if (originalGetValue) {
+    Argument.prototype.getValue = originalGetValue;
+  }
+  extensionsApplied = false;
 }
 
-// src/search-report.ts
-var import_colors_cli = __toESM(require("colors-cli"), 1);
-var SameStepTypeMatch = class {
-  constructor(diff) {
-    this.keyword = diff.step.keyword;
-    this.text = diff.merged;
-    this.source = diff.step.expression.source;
-    this.distance = diff.distance;
-  }
-  toString() {
-    const keyword = import_colors_cli.default.green(this.keyword);
-    const text = import_colors_cli.default.white(this.source);
-    const distance2 = import_colors_cli.default.blue(`[${this.distance}]`);
-    return `${distance2} ${keyword} ${text}`;
-  }
-};
-var DifferentStepTypeMatch = class {
-  constructor(diff) {
-    this.keyword = diff.step.keyword;
-    this.text = diff.merged;
-    this.source = diff.step.expression.source;
-    this.distance = diff.distance;
-  }
-  toString() {
-    const keywordColor = import_colors_cli.default.cyan_bt;
-    const keyword = keywordColor(this.keyword);
-    const text = import_colors_cli.default.white(this.source);
-    const distance2 = import_colors_cli.default.blue(`[${this.distance}]`);
-    return `${distance2} ${keyword} ${text}`;
-  }
-};
-var _sameMatchTypes, sameMatchTypes_get, _differentMatchTypes, differentMatchTypes_get;
-var FuzzySearchReport = class {
-  constructor(depth = 0) {
-    this.depth = depth;
-    __privateAdd(this, _sameMatchTypes);
-    __privateAdd(this, _differentMatchTypes);
-    this.matches = [];
-    this.children = [];
-  }
-  get length() {
-    const childLength = this.children.map((it) => it.length).reduce((a, b) => a + b, 0);
-    return this.matches.length + childLength;
-  }
-  addHeading(headingText) {
-    this.headingText = headingText;
-    return this;
-  }
-  addMatch(match) {
-    this.matches.push(match);
-    return this;
-  }
-  addChild(child) {
-    this.children.push(child);
-    return this;
-  }
-  toString() {
-    if (this.length === 0) {
-      return "";
-    }
-    const same = __privateGet(this, _sameMatchTypes, sameMatchTypes_get).filter((it) => it.distance < 10).map((it) => it.toString()).join("\n");
-    const sameMessage = same.length > 0 ? import_colors_cli.default.italic(`Steps with matching step type:`) : "";
-    const different = __privateGet(this, _differentMatchTypes, differentMatchTypes_get).filter((it) => it.distance < 10).map((it) => it.toString()).join("\n");
-    const differentMessage = different.length > 0 ? import_colors_cli.default.italic(`Steps with different step type:`) : "";
-    const messageArray = [];
-    appendSubMessage(messageArray, sameMessage);
-    appendSubMessage(messageArray, same);
-    appendSubMessage(messageArray, differentMessage);
-    appendSubMessage(messageArray, different);
-    const children = [];
-    this.children.forEach((child) => {
-      appendChild(children, child);
-    });
-    const formatChildren = children.map((it) => it.toString()).join("\n");
-    const message = messageArray.join(`
-`).trim();
-    const heading = this.headingText && import_colors_cli.default.black(this.headingText);
-    return `${heading ?? ""}
-${message.replace(/\r\n|\n|\r/gm, `
-${TAB}`)}
-${formatChildren.replace(/\r\n|\n|\r/gm, `
-${TAB}`)}`;
+// src/parameter-types.ts
+function toPatternArray(pattern) {
+  return Array.isArray(pattern) ? [...pattern] : [pattern];
+}
+function buildDefaultValue(rawValues) {
+  if (rawValues.length === 0) {
+    return void 0;
   }
-};
-_sameMatchTypes = new WeakSet();
-sameMatchTypes_get = function() {
-  return this.matches.filter(
-    (it) => it instanceof SameStepTypeMatch
-  );
-};
-_differentMatchTypes = new WeakSet();
-differentMatchTypes_get = function() {
-  return this.matches.filter(
-    (it) => it instanceof DifferentStepTypeMatch
-  );
-};
-function appendSubMessage(arr, message, prefix) {
-  if (message && message.length > 0) {
-    const str = prefix ? `${prefix ?? ""}${message ?? ""}` : message ?? "";
-    arr.push(str);
+  if (rawValues.length === 1) {
+    return rawValues[0];
   }
+  return [...rawValues];
 }
-function appendChild(arr, message) {
-  if (message) {
-    arr.push(message);
+function resolveScopedName(name, namespace) {
+  if (!name || !namespace) {
+    return name;
   }
+  return `${namespace}:${name}`;
 }
-var SPACE = " ";
-var TAB = SPACE.repeat(2);
-function buildFuzzySearchReport({ same, other }, depth) {
-  const report = new FuzzySearchReport(depth);
-  same.forEach((diff) => {
-    report.addMatch(new SameStepTypeMatch(diff));
-  });
-  other.forEach((diff) => {
-    report.addMatch(new DifferentStepTypeMatch(diff));
-  });
-  return report;
-}
-
-// src/parameters.ts
-var import_cucumber_expressions = require("@cucumber/cucumber-expressions");
-var import_overloaded = require("@autometa/overloaded");
-import_cucumber_expressions.ParameterType.prototype.transform = function transform(value, app) {
-  return this.transformFn.apply(this, [...value ?? [], app]);
-};
-import_cucumber_expressions.Argument.prototype.getValue = function getValue(app) {
-  if (this.group.children.length > 0) {
-    const value = this.group.children.filter((it) => it.value !== void 0).map((child) => child.value);
-    if (value.length > 0) {
-      return this.parameterType.transform(value, app);
+function buildTransform(definition, scopedName, options) {
+  return (values, runtime) => {
+    const rawValues = values ?? [];
+    const resolved = buildDefaultValue(rawValues);
+    if (definition.transform) {
+      const context = {
+        raw: rawValues,
+        world: runtime.world,
+        name: scopedName,
+        originalName: definition.name,
+        parameterType: runtime.parameterType,
+        definition,
+        ...options?.namespace !== void 0 ? { namespace: options.namespace } : {}
+      };
+      return definition.transform(resolved, context);
     }
-  }
-  const groupValues = this.group ? this.group.value ? [this.group.value] : this.group.values : null;
-  return this.parameterType.transform(groupValues, app);
-};
-var regexp = (0, import_overloaded.instance)(RegExp).or((0, import_overloaded.array)([(0, import_overloaded.instance)(RegExp)]));
-function defineParameterType(registry, ...params) {
-  params.forEach((param) => {
-    const { name, regex, regexpPattern, transform: transform2, type, primitive } = param;
-    return registerParameterType(
-      registry,
-      name,
-      regexpPattern ?? regex,
-      transform2,
-      type,
-      primitive
-    );
-  });
+    return resolved;
+  };
 }
-function registerParameterType(registry, name, regexpPattern, transform2, type, primitive) {
-  return (0, import_overloaded.overloads)(
-    (0, import_overloaded.def)(
-      (0, import_overloaded.string)(),
-      regexp,
-      (0, import_overloaded.func)("type"),
-      (0, import_overloaded.func)("transform"),
-      (0, import_overloaded.func)("primitive")
-    ).matches((name2, regexp2, type2, transform3, primitive2) => {
-      const primitivePrototype = primitive2;
-      const typePrototype = type2;
-      const wrapper = (val) => {
-        const asPrimitive = primitivePrototype(val);
-        const asType = new typePrototype(asPrimitive);
-        return transform3(asType);
-      };
-      const param = new import_cucumber_expressions.ParameterType(name2, regexp2, type2, wrapper);
-      registry.defineParameterType(param);
-    }),
-    import_overloaded.def`allTransforms`(
-      (0, import_overloaded.string)(),
-      regexp,
-      (0, import_overloaded.func)("type"),
-      (0, import_overloaded.func)("transform"),
-      (0, import_overloaded.nil)("primitive")
-    ).matches((name2, regexp2, type2, transform3) => {
-      const typePrototype = type2;
-      const wrapper = (val) => {
-        const asType = new typePrototype(val);
-        return transform3(asType);
-      };
-      const param = new import_cucumber_expressions.ParameterType(name2, regexp2, type2, wrapper);
-      registry.defineParameterType(param);
-    }),
-    import_overloaded.def`transformPrimitive`(
-      (0, import_overloaded.string)(),
-      regexp,
-      (0, import_overloaded.nil)("type"),
-      (0, import_overloaded.func)("transform"),
-      (0, import_overloaded.func)("primitive")
-    ).matches((name2, regexp2, _, transform3, primitive2) => {
-      const primitivePrototype = primitive2;
-      const wrapper = (val) => {
-        const asPrimitive = fromPrimitive(val, primitivePrototype);
-        return transform3(asPrimitive);
-      };
-      const param = new import_cucumber_expressions.ParameterType(name2, regexp2, primitive2, wrapper);
-      registry.defineParameterType(param);
-    }),
-    import_overloaded.def`encapsulatePrimitive`(
-      (0, import_overloaded.string)(),
-      regexp,
-      (0, import_overloaded.func)("type"),
-      (0, import_overloaded.nil)("transform"),
-      (0, import_overloaded.func)("primitive")
-    ).matches((name2, regexp2, type2, _, primitive2) => {
-      const primitivePrototype = primitive2;
-      const typePrototype = type2;
-      const wrapper = (val) => {
-        const asPrimitive = fromPrimitive(val, primitivePrototype);
-        return new typePrototype(asPrimitive);
-      };
-      const param = new import_cucumber_expressions.ParameterType(name2, regexp2, type2, wrapper);
-      registry.defineParameterType(param);
-    }),
-    import_overloaded.def`makeType`((0, import_overloaded.string)(), regexp, (0, import_overloaded.func)("type"), (0, import_overloaded.nil)(), (0, import_overloaded.nil)()).matches(
-      (name2, pattern, type2) => {
-        const prototype = type2;
-        const transform3 = (val) => new prototype(val);
-        const param = new import_cucumber_expressions.ParameterType(name2, pattern, null, transform3);
-        registry.defineParameterType(param);
-      }
-    ),
-    import_overloaded.def`makePrimitive`(
-      (0, import_overloaded.string)(),
-      regexp,
-      (0, import_overloaded.nil)(),
-      (0, import_overloaded.nil)(),
-      (0, import_overloaded.func)("primitive")
-    ).matches((name2, pattern, _, __, primitive2) => {
-      const prototype = primitive2;
-      const transform3 = (val) => fromPrimitive(val, prototype);
-      const param = new import_cucumber_expressions.ParameterType(name2, pattern, null, transform3);
-      registry.defineParameterType(param);
-    }),
-    import_overloaded.def`transformValue`(
-      (0, import_overloaded.string)(),
-      regexp,
-      (0, import_overloaded.nil)(),
-      (0, import_overloaded.func)("transform"),
-      (0, import_overloaded.nil)()
-    ).matches((name2, pattern, _, transform3, __) => {
-      const param = new import_cucumber_expressions.ParameterType(name2, pattern, null, transform3);
-      registry.defineParameterType(param);
-    }),
-    import_overloaded.def`default`((0, import_overloaded.string)(), (0, import_overloaded.instance)(RegExp), (0, import_overloaded.nil)(), (0, import_overloaded.nil)(), (0, import_overloaded.nil)()).matches(
-      (name2, pattern, _, __, ___) => {
-        const transform3 = (val) => val;
-        const param = new import_cucumber_expressions.ParameterType(name2, pattern, null, transform3);
-        registry.defineParameterType(param);
-      }
-    )
-  ).use([name, regexpPattern, type, transform2, primitive]);
+function firstValue(input) {
+  return Array.isArray(input) ? input[0] : input;
 }
-function fromPrimitive(value, primitive) {
-  if (primitive === String) {
-    return value;
+function firstString(input) {
+  const value = firstValue(input);
+  if (value === void 0 || value === null) {
+    return void 0;
   }
-  if (primitive === Number) {
-    return parseFloat(value);
-  }
-  if (primitive === Boolean) {
-    return value === "true";
+  return String(value);
+}
+function parseNumberValue(input, parser) {
+  const raw = firstString(input);
+  if (raw === void 0) {
+    return null;
   }
-  return primitive(value);
+  const numeric = parser(raw);
+  return Number.isNaN(numeric) ? null : numeric;
 }
-
-// src/default.parameters.ts
-var import_overloaded2 = require("@autometa/overloaded");
-var import_datetime = require("@autometa/datetime");
-var import_asserters = require("@autometa/asserters");
-var import_luxon = require("luxon");
-var strNum = /['"]-?\d+['"]/;
-var isodateRegexp = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/;
-var shortDateRegex = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\d)/;
-var boolTypesActive = ["active", "inactive"];
-var boolTypesEnabled = ["enabled", "disabled"];
-var boolTypes = ["true", "false"];
-var OrdinalParam = {
-  name: "ordinal",
-  regex: /(\d+)(?:st|nd|rd|th)/,
-  transform: (value) => parseInt(value, 10)
-};
-var NumberParam = {
-  name: "number",
-  regex: /\d+/,
-  primitive: Number
-};
-var AnyParam = {
-  name: "any",
-  regex: /.*/
-};
-var UnknownParam = {
-  name: "unknown",
-  regex: /.*/
-};
-var TextParam = {
-  name: "text",
-  regex: /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/,
-  primitive: String,
-  transform: (value) => {
-    const asStr = value;
-    return asStr.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
+function parseBigIntValue(input) {
+  const raw = firstString(input);
+  if (raw === void 0) {
+    return null;
   }
-};
-var BooleanParam = {
-  name: "boolean",
-  regex: /true|false/,
-  primitive: Boolean
-};
-var BoolParam = {
-  name: "bool",
-  regex: /true|false/,
-  primitive: Boolean
-};
-var DateParam = {
-  name: "date",
-  regex: [isodateRegexp, shortDateRegex],
-  type: Date
-};
-var PrimitiveParam = {
-  name: "primitive",
-  regex: [
-    /true|false/,
-    /enabled|disabled/,
-    /active|inactive/,
-    /null/,
-    /empty/,
-    /undefined|missing/,
-    /NaN/,
-    /Infinity/,
-    /-Infinity/,
-    isodateRegexp,
-    shortDateRegex,
-    /-?(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)/,
-    // Comma delimited number, e.g. "1", "1,000", "1,000.00"
-    /-?(\d*,?\d+|\d{1,3}(.\d{3})*(,\d+))/,
-    // Period delimited number, e.g. "1", "1.000,00"
-    /"([^"]*)"/,
-    /'([^']*)'/
-  ],
-  transform: (value) => {
-    return (0, import_overloaded2.overloads)(
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "null" })).matches((_) => null),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ in: ["undefined", "missing"] })).matches((_) => void 0),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ in: boolTypes })).matches((val) => val === "true"),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "NaN" })).matches((_) => NaN),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "Infinity" })).matches((_) => Infinity),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "-Infinity" })).matches((_) => -Infinity),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ pattern: isodateRegexp })).matches(parseIso),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ pattern: shortDateRegex })).matches(parseDate),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ pattern: strNum })).matches(trimQuotes),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ pattern: /^-?(\d{1,3}(,\d{3})*(\.\d+)?)/ })).matches(
-        (val) => {
-          const asStr = val.replace(/,/g, "");
-          return parseFloat(asStr);
-        }
-      ),
-      // def(string({ pattern: /-?(\d{1,3}(\.\d{3})*(,\d+)?)/ })).matches(
-      //   (val) =>{
-      //     const asStr = val.replace(/\./g, "").replace(/,/g, ".");
-      //     return Number(asStr);
-      //   }
-      // ),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ in: boolTypesEnabled })).matches(boolEnabled),
-      (0, import_overloaded2.def)((0, import_overloaded2.string)({ in: boolTypesActive })).matches(boolActive),
-      (0, import_overloaded2.fallback)((val) => {
-        (0, import_asserters.AssertIs)(val, "string");
-        const fromPhrase = import_datetime.Dates.fromPhrase(val);
-        if (fromPhrase && !isNaN(fromPhrase.getTime())) {
-          return fromPhrase;
-        }
-        return val.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
-      })
-    ).use([value]);
+  try {
+    return BigInt(raw);
+  } catch {
+    return null;
   }
-};
-function boolActive(val) {
-  return val === "active";
-}
-function boolEnabled(val) {
-  return val === "enabled";
 }
-function parseDate(val) {
-  return new Date(Date.parse(val));
-}
-function trimQuotes(val) {
-  return val.slice(1, -1);
+function createParameterTypes(options) {
+  applyCucumberExtensions();
+  const define = (registry, definition) => {
+    const patterns = toPatternArray(definition.pattern);
+    const scopedName = resolveScopedName(definition.name, options?.namespace);
+    const transform = buildTransform(definition, scopedName, options);
+    const parameterType = new ParameterType(
+      scopedName,
+      patterns,
+      null,
+      // The original transform is overridden by applyCucumberExtensions.
+      (...matches) => matches.length <= 1 ? matches[0] : matches,
+      definition.useForSnippets,
+      definition.preferForRegexpMatch,
+      definition.builtin
+    );
+    attachTransform(parameterType, transform);
+    registry.defineParameterType(parameterType);
+    return parameterType;
+  };
+  define.many = (registry, ...definitions) => {
+    const list = definitions.length === 1 && Array.isArray(definitions[0]) ? definitions[0] : definitions;
+    list.forEach((definition) => {
+      define(registry, definition);
+    });
+    return registry;
+  };
+  return define;
 }
-function parseIso(val) {
-  return import_luxon.DateTime.fromISO(val).toJSDate();
+var defineParameterType = createParameterTypes();
+var INTEGER_REGEXPS = [/-?\d+/, /\d+/];
+var FLOAT_REGEXP = /(?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][+-]?\d+)?/;
+var WORD_REGEXP = /[^\s]+/;
+var STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/;
+var ANONYMOUS_REGEXP = /.*/;
+function createDefaultParameterTypes(options) {
+  const define = createParameterTypes(options);
+  return (registry) => {
+    const defaults = [
+      {
+        name: "int",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseNumberValue(value, (raw) => parseInt(raw, 10)),
+        useForSnippets: true,
+        preferForRegexpMatch: true,
+        builtin: true
+      },
+      {
+        name: "float",
+        pattern: FLOAT_REGEXP,
+        transform: (value) => parseNumberValue(value, (raw) => parseFloat(raw)),
+        useForSnippets: true,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "number",
+        pattern: FLOAT_REGEXP,
+        transform: (value) => parseNumberValue(value, (raw) => parseFloat(raw)),
+        useForSnippets: true,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "word",
+        pattern: WORD_REGEXP,
+        transform: (value) => firstString(value) ?? "",
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "string",
+        pattern: STRING_REGEXP,
+        transform: (_value, context) => {
+          const [doubleQuoted, singleQuoted] = context.raw;
+          const captured = doubleQuoted ?? singleQuoted ?? "";
+          return captured.replace(/\\"/g, '"').replace(/\\'/g, "'");
+        },
+        useForSnippets: true,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "",
+        pattern: ANONYMOUS_REGEXP,
+        transform: (_value, context) => context.raw[0] ?? "",
+        useForSnippets: false,
+        preferForRegexpMatch: true,
+        builtin: true
+      },
+      {
+        name: "double",
+        pattern: FLOAT_REGEXP,
+        transform: (value) => parseNumberValue(value, (raw) => parseFloat(raw)),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "bigdecimal",
+        pattern: FLOAT_REGEXP,
+        transform: (value) => {
+          const text = firstString(value);
+          return text ?? null;
+        },
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "byte",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseNumberValue(value, (raw) => parseInt(raw, 10)),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "short",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseNumberValue(value, (raw) => parseInt(raw, 10)),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "long",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseNumberValue(value, (raw) => parseInt(raw, 10)),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "biginteger",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseBigIntValue(value),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      }
+    ];
+    const prepared = defaults.map(
+      (definition) => options?.namespace && definition.preferForRegexpMatch ? { ...definition, preferForRegexpMatch: false } : definition
+    );
+    const toRegister = [];
+    prepared.forEach((definition) => {
+      const scopedName = resolveScopedName(
+        definition.name,
+        options?.namespace
+      );
+      const existing = registry.lookupByTypeName(scopedName);
+      if (existing) {
+        const transform = buildTransform(definition, scopedName, options);
+        attachTransform(existing, transform);
+        return;
+      }
+      toRegister.push(definition);
+    });
+    if (toRegister.length > 0) {
+      define.many(registry, ...toRegister);
+    }
+    return registry;
+  };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnyParam,
-  BoolParam,
-  BooleanParam,
-  DateParam,
-  DifferentStepTypeMatch,
-  FuzzySearchReport,
-  NumberParam,
-  OrdinalParam,
-  PrimitiveParam,
-  SameStepTypeMatch,
-  TextParam,
-  UnknownParam,
-  buildFuzzySearchReport,
-  checkMatch,
-  defineParameterType,
-  getDiff,
-  getDiffs,
-  isExpressionCandidate,
-  limitDiffs,
-  refineDiff
-});
+var defineDefaultParameterTypes = createDefaultParameterTypes();
+
+export { applyCucumberExtensions, attachTransform, createDefaultParameterTypes, createParameterTypes, defineDefaultParameterTypes, defineParameterType, resetCucumberExtensions };
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map