deno.land / x / uriware@v0.1.0 / RegExpUri.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460import { escapeStringRegexp } from "https://deno.land/x/escape_string_regexp@v0.0.1/mod.ts"import tlds from "./tlds.ts"
// <https://datatracker.ietf.org/doc/html/rfc3986#appendix-A>
const ALPHA = `a-zA-Z`const DIGIT = `0-9`const HEXDIG = `0-9a-fA-F`
const subDelims = `[!$&'()*+,;=]`// const genDelims = `[:/?#\\[\\]@]`// const reserved = `(?:${genDelims}|${subDelims})`const unreserved = `(?:[${ALPHA}]|[${DIGIT}]|-|\\.|_|~)`const pctEncoded = `%[${HEXDIG}][${HEXDIG}]`const pchar = `(?:${unreserved}|${pctEncoded}|${subDelims}|:|@)`
// const segmentNzNc = `(?:${unreserved}|${pctEncoded}|${subDelims}|@)+`const segmentNz = `(?:${pchar})+`const segment = `(?:${pchar})*`
const pathEmpty = ``const pathRootless = `${segmentNz}(?:/${segment})*`// const pathNoscheme = `${segmentNzNc}(?:/${segment})*`const pathAbsolute = `/(?:${segmentNz}(?:/${segment})*)?`// const pathAbempty = `(?:/${segment})*`// const pathNoauthority = `(?:${pathAbsolute}|${pathRootless}|${pathEmpty})`// const path = `(?:${pathAbempty}|${pathAbsolute}|${pathNoscheme}|${pathRootless}|${pathEmpty})`
const regName = `(?:${unreserved}|${pctEncoded}|${subDelims})*`
const decOctet = `(?:[${DIGIT}]|[1-9][${DIGIT}]|1[${DIGIT}]{2}|2[0-4][${DIGIT}]|25[0-5])`const ipv4Address = `${decOctet}.${decOctet}.${decOctet}.${decOctet}`const h16 = `[${HEXDIG}]{1,4}`const ls32 = `(?:${h16}:${h16}|${ipv4Address})`const ipv6Address = `(?:` + `(?:${h16}:){6}${ls32}|` + `::(?:${h16}:){5}${ls32}|` + `(?:${h16})?::(?:${h16}:){4}${ls32}|` + `(?:(?:${h16}:){,1}${h16})?::(?:${h16}:){3}${ls32}|` + `(?:(?:${h16}:){,2}${h16})?::(?:${h16}:){2}${ls32}|` + `(?:(?:${h16}:){,3}${h16})?::${h16}:${ls32}|` + `(?:(?:${h16}:){,4}${h16})?::${ls32}|` + `(?:(?:${h16}:){,5}${h16})?::${h16}|` + `(?:(?:${h16}:){,6}${h16})?::` + `)`const ipvFuture = `v[${HEXDIG}]+.(?:${unreserved}|${subDelims}|:)+`const ipLiteral = `\\[(?:${ipv6Address}|${ipvFuture})\\]`
// RFC1034 3.5. Preferred name syntaxconst letDig = `[${ALPHA}${DIGIT}]`const letDigHyp = `[${ALPHA}${DIGIT}-]`const ldhStr = `(?:${letDigHyp})+`const label = `[${ALPHA}](?:${ldhStr}(?:${letDig})?)?`const regNamePreferred = `(?:${label}\\.)+${label}`const regNamePreferredWithKnownTlds = `(?:${label}\\.)+(?:${tlds.join("|")})`
const normalizeOptions = ( options?: Partial< { preset: keyof typeof RegExpUri.presets } & RegExpUri.Options >,): RegExpUri.Options => { const preset = options?.preset ?? "canonical" const exact = options?.exact ?? false const groups = options?.groups ?? (exact ? "all" : "outmost") return { ...RegExpUri.presets[preset], ...options, exact, groups }}
const generatePatternScheme = (options: RegExpUri.Options): string => { let pattern = `[${ALPHA}][${ALPHA}${DIGIT}+-.]*` const { allow, disallow } = options.schemes const syntax = new RegExp(`^${pattern}$`) if (allow && !disallow) { const invalid = allow.filter(scheme => !syntax.test(scheme)) if (0 < invalid.length) throw new Error( `Some items in the scheme whitelist are in invalid syntax: ${invalid .map(scheme => `"${scheme}"`) .join(", ")}`, ) pattern = `(?:${allow.map(escapeStringRegexp).join("|")})` } else if (!allow && disallow) { // If zero, it allows everything if (disallow.length !== 0) { const invalid = disallow.filter(scheme => !syntax.test(scheme)) if (0 < invalid.length) throw new Error( `Some items in the scheme blacklist are in invalid syntax: ${invalid .map(scheme => `"${scheme}"`) .join(", ")}`, ) const negation = `(?:${disallow.map(escapeStringRegexp).join("|")})` pattern = `(?:(?!${negation})${pattern}|${pattern}(?<!${negation}))` } } else { throw new Error( "The scheme whitelisting/blacklisting option cannot contain the both `allow` and `disallow` properties at the same time.", ) } if (options.groups === "all") pattern = `(?<scheme>${pattern})` return pattern}
const generateRegName = (options: RegExpUri.Options): string => { let pattern = regName if (options.usePreferredDomainNameSyntax) { pattern = regNamePreferred if (options.allowKnownTldsOnly) { pattern = regNamePreferredWithKnownTlds } } const { allow, disallow } = options.domains const syntax = new RegExp(`^${pattern}$`) if (allow && !disallow) { const invalid = allow.filter(domain => !syntax.test(domain)) if (0 < invalid.length) throw new Error( `Some items in the domain whitelist are in invalid syntax: ${invalid .map(domain => `"${domain}"`) .join(", ")}`, ) pattern = `(?:${allow.map(escapeStringRegexp).join("|")})` } else if (!allow && disallow) { // If zero, it allows everything if (disallow.length !== 0) { const invalid = disallow.filter(domain => !syntax.test(domain)) if (0 < invalid.length) throw new Error( `Some items in the domain blacklist are in invalid syntax: ${invalid .map(domain => `"${domain}"`) .join(", ")}`, ) const negation = `(?:${disallow.map(escapeStringRegexp).join("|")})` pattern = `(?:(?!${negation})${pattern}|${pattern}(?<!${negation}))` } } else { throw new Error( "The domain whitelisting/blacklisting option cannot contain the both `allow` and `disallow` properties at the same time.", ) } return pattern}
const generatePatternHost = (options: RegExpUri.Options): string => { const regName = generateRegName(options) let pattern = `(?:${ipLiteral}|${ipv4Address}|${regName})` if (options.groups === "all") pattern = `(?<host>${pattern})` return pattern}
const generatePatternPort = (options: RegExpUri.Options): string => { let pattern = `[${DIGIT}]*` if (options.groups === "all") pattern = `(?<port>${pattern})` return pattern}
const generatePatternUserinfo = (options: RegExpUri.Options): string => { let pattern = `(?:${unreserved}|${pctEncoded}|${subDelims}|:)*` if (options.groups === "all") pattern = `(?<userinfo>${pattern})` return pattern}
const generatePatternAuthority = (options: RegExpUri.Options): string => { const host = generatePatternHost(options) const port = generatePatternPort(options) const userinfo = generatePatternUserinfo(options) let pattern = `(?:${userinfo}@)?${host}(?::${port})?` if (options.groups === "all") pattern = `(?<authority>${pattern})` return pattern}
const generatePatternPathAbempty = (options: RegExpUri.Options): string => { let pattern = `(?:/${segment})*` if (options.groups === "all") pattern = `(?<pathAbempty>${pattern})` return pattern}
const generatePatternPathNoauthority = (options: RegExpUri.Options): string => { let pattern = `(?:${pathAbsolute}|${pathRootless}|${pathEmpty})` if (options.groups === "all") pattern = `(?<pathNoauthority>${pattern})` return pattern}
const generatePatternSchemeHierPart = (options: RegExpUri.Options): string => { const scheme = generatePatternScheme(options) const authority = generatePatternAuthority(options) const pathAbempty = generatePatternPathAbempty(options) const pathNoauthority = generatePatternPathNoauthority(options) const { requireScheme, requireDoubleSlash, requireAuthority } = options switch (requireAuthority) { case "always": // authority switch (requireScheme) { case "always": // scheme return `${scheme}://${authority}${pathAbempty}` case "never": // scheme switch (requireDoubleSlash) { case "always": // double slash return `//${authority}${pathAbempty}` case "never": // double slash return `${authority}${pathAbempty}` default: // double slash return `(?://)?${authority}${pathAbempty}` } default: // scheme switch (requireDoubleSlash) { case "always": // double slash return `(?:${scheme}:)?//${authority}${pathAbempty}` case "never": // double slash return `(?:${scheme}://)?${authority}${pathAbempty}` default: // double slash return `(?:(?:${scheme}:)?//)?${authority}${pathAbempty}` } } case "never": // authority switch (requireScheme) { case "always": // scheme return `${scheme}:${pathNoauthority}` case "never": // scheme return `${pathNoauthority}` default: // scheme return `(?:${scheme}:)?${pathNoauthority}` } default: // authority switch (requireScheme) { case "always": // scheme return `${scheme}:(?://${authority}${pathAbempty}|${pathNoauthority})` case "never": // scheme switch (requireDoubleSlash) { case "always": // double slash return `(?://${authority}${pathAbempty}|${pathNoauthority})` case "never": // double slash return `(?:${authority}${pathAbempty}|${pathNoauthority})` default: // double slash return `(?:(?://)?${authority}${pathAbempty}|${pathNoauthority})` } default: // scheme switch (requireDoubleSlash) { case "always": // double slash return `(?:${scheme}:)?(?://${authority}${pathAbempty}|${pathNoauthority})` case "never": // double slash return `(?:${scheme}://)?(?:${authority}${pathAbempty}|${pathNoauthority})` default: // double slash return `(?:${scheme}://|//)?(?:${authority}${pathAbempty}|${pathNoauthority})` } } }}
const generatePatternQuery = (options: RegExpUri.Options): string => { let pattern = `(?:${pchar}|/|\\?)+` if (options.allowEmptyQuery) pattern = `(?:${pattern})?` if (options.groups === "all") pattern = `(?<query>${pattern})` return `(?:\\?${pattern})?`}
const generatePatternFragment = (options: RegExpUri.Options): string => { let pattern = `(?:${pchar}|/|\\?)+` if (options.allowEmptyFragment) pattern = `(?:${pattern})?` if (options.groups === "all") pattern = `(?<fragment>${pattern})` return `(?:#${pattern})?`}
const generatePatternUri = (options: RegExpUri.Options): string => { const schemeHierPart = generatePatternSchemeHierPart(options) const query = generatePatternQuery(options) const fragment = generatePatternFragment(options) let pattern = `${schemeHierPart}${query}${fragment}` if (options.groups !== "none") pattern = `(?<uri>${pattern})` return pattern}
const generatePattern = (options: RegExpUri.Options): string => { let pattern = generatePatternUri(options) if (options.exact) pattern = `^${pattern}$` return pattern}
class RegExpUri extends RegExp { options: RegExpUri.Options constructor( options?: | Partial<{ preset: keyof typeof RegExpUri.presets } & RegExpUri.Options> | RegExpUri, flags?: string, ) { const optionsDetailed = options instanceof RegExpUri ? options.options : normalizeOptions(options) super(generatePattern(optionsDetailed), flags) this.options = optionsDetailed } exec(string: string): RegExpExecArray | null { const result = RegExp.prototype.exec.call(this, string) if (result?.groups) { if (!this.options.allowEmpty && result[0] === "") return null if ( "pathAbempty" in result.groups || "pathNoauthority" in result.groups ) { const path = result.groups.pathAbempty ?? result.groups.pathNoauthority const query = result.groups.query const fragment = result.groups.fragment delete result.groups.pathAbempty delete result.groups.pathNoauthority delete result.groups.query delete result.groups.fragment result.groups.path = path result.groups.query = query result.groups.fragment = fragment } } return result }}
namespace RegExpUri { export type Options = { /** * A whitelist or a blacklist of schemes. * * Default: `{ disallow: [] }`. */ schemes: Whitelist<string> | Blacklist<string>
/** * A whitelist or a blacklist of domains. * * Default: `{ disallow: [] }`. */ domains: Whitelist<string> | Blacklist<string>
/** * Whether the scheme part must be present. `undefined` allows both cases. * * [RFC3986 ***does*** require](https://datatracker.ietf.org/doc/html/rfc3986#section-3), so setting this option to `"never"` or `undefined` shall get you out of the legal syntax of URI. * * Default: `"always"`. */ requireScheme: "always" | "never" | undefined
/** * Whether the double slash must be present, when the scheme part is missing but the authority part is present. `undefined` allows both cases. This setting is only meaningful when `requireScheme` is `"never"` or `undefined. * * [RFC3986 ***does*** require it as long as the authority part is present](https://datatracker.ietf.org/doc/html/rfc3986#section-3), so setting this option to `"never"` or `undefined` shall get you out of the legal syntax of URI. * * Default: `"always"`. */ requireDoubleSlash: "always" | "never" | undefined
/** * Whether the authority part must be present. `undefined` allows both cases. * * Default: `undefined`. */ requireAuthority: "always" | "never" | undefined
/** * Whether to use [RFC1034 3.5. Preferred name syntax](https://datatracker.ietf.org/doc/html/rfc1034#section-3.5). * * Default: `false`. */ usePreferredDomainNameSyntax: boolean
/** * Whether to verify given domain name has a well-known TLD in the IANA's list. Only meaningful when `usePreferredDomainNameSyntax` is `true`. * * Default: `false`. */ allowKnownTldsOnly: boolean
/** * Whether URIs can be relative reference. * * Default: `true`. */ allowRelative: boolean
/** * Whether to allow the query part to be without its content. * * Default: `true`. */ allowEmptyQuery: boolean
/** * Whether to allow the fragment part to be without its content. * * Default: `true`. */ allowEmptyFragment: boolean
/** * Allows matching to empty string. * * Default: `false`. */ allowEmpty: boolean
/** * Enables exact match pattern. It wraps the `RegExp` pattern with `^` and `$`. * * Default: `false`. */ exact: boolean
/** * Enables named capture groups. See {@link NamedCaptureGroups `RegExpUri.NamedCaptureGroups`} to know what's in the box. * * `"outmost"` should fit for some usage e.g. splitting a plaintext by URIs using [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split). * * Default: `"all"` if `exact` is `true`, `"outmost"` otherwise. */ groups: "all" | "outmost" | "none" }
export type NamedCaptureGroups = { uri: string scheme: string | undefined authority: string | undefined userinfo: string | undefined host: string | undefined port: string | undefined path: string | undefined query: string | undefined fragment: string | undefined }
export type Whitelist<T> = { allow: T[]; disallow?: never } export type Blacklist<T> = { allow?: never; disallow: T[] }
export const presets = { canonical: { schemes: { disallow: [] }, domains: { disallow: [] }, requireScheme: "always", requireDoubleSlash: "always", requireAuthority: undefined, usePreferredDomainNameSyntax: false, allowKnownTldsOnly: false, allowRelative: true, allowEmptyQuery: true, allowEmptyFragment: true, allowEmpty: false, } as Omit<Options, "exact" | "groups">, convenient: { schemes: { allow: ["https", "http"] }, domains: { disallow: [] }, requireScheme: undefined, requireDoubleSlash: "never", requireAuthority: "always", usePreferredDomainNameSyntax: true, allowKnownTldsOnly: true, allowRelative: false, allowEmptyQuery: false, allowEmptyFragment: false, allowEmpty: false, } as Omit<Options, "exact" | "groups">, } as const}
export default RegExpUri
uriware
Version Info
a year ago
External Dependencies
2 external dependencies
