regex-wand/dist/index.js

Typed regular expressions without giving up readable regex authoring.

// src/index.ts
import {
  createRegExp as createMagicRegExp,
  exactly as magicExactly
} from "magic-regexp";
import {
  anyOf,
  carriageReturn,
  caseInsensitive,
  char,
  charIn,
  charNotIn,
  digit,
  dotAll,
  exactly,
  global,
  letter,
  linefeed,
  maybe,
  multiline,
  not,
  oneOrMore,
  sticky,
  tab,
  unicode,
  whitespace,
  withIndices,
  word,
  wordBoundary,
  wordChar
} from "magic-regexp";
function fromMagic(magic) {
  const ark = new RegExp(magic.source, magic.flags);
  return Object.assign(ark, {
    magic,
    ark,
    toRegExp: () => new RegExp(magic.source, magic.flags)
  });
}
function fromMagicAs(magic) {
  return fromMagic(magic);
}
function defineRegex(options) {
  const { flags, match = "contains" } = options;
  const inputs = "inputs" in options ? options.inputs : options.pattern;
  if (flags !== void 0) {
    return match === "exact" ? createExactRegExpWithFlags(inputs, flags) : createRegExpWithFlags(inputs, flags);
  }
  return match === "exact" ? createExactRegExp(...inputs) : createRegExp(...inputs);
}
function createRegExp(...inputs) {
  return fromMagic(createMagicRegExp(...inputs));
}
function createRegExpWithFlags(inputs, ...flags) {
  const flagInput = normalizeFlagInput(flags);
  const magic = createMagicRegExpWithFlagInput(inputs, flagInput);
  return fromMagic(magic);
}
function createExactRegExp(...inputs) {
  return fromMagic(
    createMagicRegExp(
      magicExactly(...inputs).at.lineStart().at.lineEnd()
    )
  );
}
function createExactRegExpWithFlags(inputs, ...flags) {
  const anchored = magicExactly(...inputs).at.lineStart().at.lineEnd();
  const flagInput = normalizeFlagInput(flags);
  const magic = createMagicRegExpWithFlagInput([anchored], flagInput);
  return fromMagic(magic);
}
function normalizeFlagInput(flags) {
  if (flags.length !== 1) {
    return [...flags];
  }
  const candidate = flags[0];
  if (typeof candidate === "string") {
    return [...candidate];
  }
  return candidate;
}
function createMagicRegExpWithFlagInput(inputs, flagInput) {
  return createMagicRegExp(...inputs, flagInput);
}
export {
  anyOf,
  carriageReturn,
  caseInsensitive,
  char,
  charIn,
  charNotIn,
  createExactRegExp,
  createExactRegExpWithFlags,
  createRegExp,
  createRegExpWithFlags,
  defineRegex,
  digit,
  dotAll,
  exactly,
  fromMagic,
  fromMagicAs,
  global,
  letter,
  linefeed,
  maybe,
  multiline,
  not,
  oneOrMore,
  sticky,
  tab,
  unicode,
  whitespace,
  withIndices,
  word,
  wordBoundary,
  wordChar
};
//# sourceMappingURL=index.js.map