365DevNet/Tiber365
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

full site update

Browse Source
This commit is contained in:
Richard Bergsma
2025-07-24 18:46:24 +02:00
parent bfe2b90d8d
commit 37a6e0ab31
6912 changed files with 540482 additions and 361712 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
node_modules/oniguruma-to-es/dist/esm/generate.d.ts generated vendored
View File

@@ -1,15 +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 {import('./transform.js').RegexAst} ast
@param {import('.').OnigurumaToEsOptions} [options]
@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: import("./transform.js").RegexAst, options?: import(".").OnigurumaToEsOptions): {
export function generate(ast: RegexPlusAst, options?: ToRegExpOptions): {
pattern: string;
flags: string;
options: any;
_captureTransfers: Map<number, Array<number>>;
_hiddenCaptures: Array<number>;
};
import type { RegexPlusAst } from './transform.js';
import type { ToRegExpOptions } from './index.js';

61
node_modules/oniguruma-to-es/dist/esm/index.d.ts generated vendored
View File

@@ -1,9 +1,10 @@
export type OnigurumaToEsOptions = {
export type ToRegExpOptions = {
accuracy?: "default" | "strict";
avoidSubclass?: boolean;
flags?: string;
global?: boolean;
hasIndices?: boolean;
lazyCompileLength?: number;
rules?: {
allowOrphanBackrefs?: boolean;
asciiWordBoundaries?: boolean;
@@ -16,12 +17,16 @@ export type OnigurumaToEsOptions = {
};
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;
@@ -31,45 +36,29 @@ import { EmulatedRegExp } from './subclass.js';
};
target?: keyof Target;
verbose?: boolean;
}} OnigurumaToEsOptions
}} ToRegExpOptions
*/
/**
Accepts an Oniguruma pattern and returns the details needed to construct an equivalent JavaScript `RegExp`.
@param {string} pattern Oniguruma regex pattern.
@param {OnigurumaToEsOptions} [options]
@returns {{
pattern: string;
flags: string;
options?: import('./subclass.js').EmulatedRegExpOptions;
}}
*/
export function toDetails(pattern: string, options?: OnigurumaToEsOptions): {
pattern: string;
flags: string;
options?: import("./subclass.js").EmulatedRegExpOptions;
};
/**
Returns an Oniguruma AST generated from an Oniguruma pattern.
@param {string} pattern Oniguruma regex pattern.
@param {{
flags?: string;
rules?: {
captureGroup?: boolean;
};
}} [options]
@returns {import('./parse.js').OnigurumaAst}
*/
export function toOnigurumaAst(pattern: string, options?: {
flags?: string;
rules?: {
captureGroup?: boolean;
};
}): import("./parse.js").OnigurumaAst;
/**
Accepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.
@param {string} pattern Oniguruma regex pattern.
@param {OnigurumaToEsOptions} [options]
@param {ToRegExpOptions} [options]
@returns {RegExp | EmulatedRegExp}
*/
export function toRegExp(pattern: string, options?: OnigurumaToEsOptions): 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 };

2776
node_modules/oniguruma-to-es/dist/esm/index.js generated vendored
View File

File diff suppressed because it is too large Load Diff

8
node_modules/oniguruma-to-es/dist/esm/index.js.map generated vendored
View File

File diff suppressed because one or more lines are too long

7
node_modules/oniguruma-to-es/dist/esm/options.d.ts generated vendored
View File

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

198
node_modules/oniguruma-to-es/dist/esm/parse.d.ts generated vendored
View File

@@ -1,198 +0,0 @@
export type OnigurumaAst = {
type: "Regex";
parent: null;
pattern: any;
flags: any;
};
export namespace AstAbsentFunctionKinds {
let repeater: string;
}
export namespace AstAssertionKinds {
let line_end: string;
let line_start: string;
let lookahead: string;
let lookbehind: string;
let search_start: string;
let string_end: string;
let string_end_newline: string;
let string_start: string;
let word_boundary: string;
}
export const AstCharacterSetKinds: {
any: string;
digit: string;
dot: string;
hex: string;
non_newline: string;
posix: string;
property: string;
space: string;
word: string;
};
export const AstDirectiveKinds: {
flags: string;
keep: string;
};
export namespace AstTypes {
let AbsentFunction: string;
let Alternative: string;
let Assertion: string;
let Backreference: string;
let CapturingGroup: string;
let Character: string;
let CharacterClass: string;
let CharacterClassIntersection: string;
let CharacterClassRange: string;
let CharacterSet: string;
let Directive: string;
let Flags: string;
let Group: string;
let Pattern: string;
let Quantifier: string;
let Regex: string;
let Subroutine: string;
let VariableLengthCharacterSet: string;
let Recursion: string;
}
export namespace AstVariableLengthCharacterSetKinds {
let grapheme: string;
let newline: string;
}
export function createAbsentFunction(kind: any): {
type: string;
kind: any;
alternatives: {
type: string;
elements: any[];
}[];
};
export function createAlternative(): {
type: string;
elements: any[];
};
export function createAssertion(kind: any, options: any): {
negate: boolean;
type: string;
kind: any;
};
export function createBackreference(ref: any, options: any): {
ref: any;
orphan: true;
type: string;
};
export function createCapturingGroup(number: any, name: any): {
alternatives: {
type: string;
elements: any[];
}[];
name: any;
type: string;
number: any;
};
export function createCharacter(charCode: any, options: any): {
type: string;
value: any;
};
export function createCharacterClass(options: any): any;
export function createCharacterClassIntersection(): any;
export function createCharacterClassRange(min: any, max: any): {
type: string;
min: any;
max: any;
};
export function createCharacterSet(kind: any, { negate }: {
negate: any;
}): {
type: string;
kind: any;
};
export function createFlags({ ignoreCase, dotAll, extended, digitIsAscii, spaceIsAscii, wordIsAscii }: {
ignoreCase: any;
dotAll: any;
extended: any;
digitIsAscii: any;
spaceIsAscii: any;
wordIsAscii: any;
}): {
type: string;
ignoreCase: any;
dotAll: any;
extended: any;
digitIsAscii: any;
spaceIsAscii: any;
wordIsAscii: any;
};
export function createGroup(options: any): {
alternatives: {
type: string;
elements: any[];
}[];
flags: any;
atomic: any;
type: string;
};
export function createLookaround(options: any): {
type: string;
kind: string;
negate: any;
alternatives: {
type: string;
elements: any[];
}[];
};
export function createPattern(): {
type: string;
alternatives: {
type: string;
elements: any[];
}[];
};
export function createQuantifier(element: any, min: any, max: any, greedy?: boolean, possessive?: boolean): {
type: string;
min: any;
max: any;
greedy: boolean;
possessive: boolean;
element: any;
};
export function createRegex(pattern: any, flags: any): {
type: string;
pattern: any;
flags: any;
};
export function createSubroutine(ref: any): {
type: string;
ref: any;
};
export function createUnicodeProperty(value: any, options: any): {
type: string;
kind: string;
value: any;
negate: any;
};
export function createVariableLengthCharacterSet(kind: any): {
type: string;
kind: any;
};
/**
@typedef {{
type: 'Regex';
parent: null;
pattern: Object;
flags: Object;
}} OnigurumaAst
*/
/**
@param {import('./tokenize.js').TokenizerResult} tokenizerResult
@param {{
skipBackrefValidation?: boolean;
skipPropertyNameValidation?: boolean;
verbose?: boolean;
}} [options]
@returns {OnigurumaAst}
*/
export function parse({ tokens, flags, rules }: import("./tokenize.js").TokenizerResult, options?: {
skipBackrefValidation?: boolean;
skipPropertyNameValidation?: boolean;
verbose?: boolean;
}): OnigurumaAst;

25
node_modules/oniguruma-to-es/dist/esm/subclass.d.ts generated vendored
View File

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

90
node_modules/oniguruma-to-es/dist/esm/tokenize.d.ts generated vendored
View File

@@ -1,90 +0,0 @@
export type Token = {
type: "Alternator" | "Assertion" | "Backreference" | "Character" | "CharacterClassClose" | "CharacterClassHyphen" | "CharacterClassIntersector" | "CharacterClassOpen" | "CharacterSet" | "Directive" | "GroupClose" | "GroupOpen" | "Subroutine" | "Quantifier" | "VariableLengthCharacterSet" | "EscapedNumber";
raw: string;
[key: string]: string | number | boolean;
};
export type TokenizerResult = {
tokens: Array<Token>;
flags: {
dotAll: boolean;
extended: boolean;
ignoreCase: boolean;
};
rules: {
captureGroup: boolean;
singleline: boolean;
};
};
/**
@typedef {{
type: keyof TokenTypes;
raw: string;
[key: string]: string | number | boolean;
}} Token
@typedef {{
tokens: Array<Token>;
flags: {
dotAll: boolean;
extended: boolean;
ignoreCase: boolean;
};
rules: {
captureGroup: boolean;
singleline: boolean;
};
}} TokenizerResult
*/
/**
@param {string} pattern Oniguruma pattern.
@param {string} [flags] Oniguruma flags.
@param {{
captureGroup?: boolean;
singleline?: boolean;
}} [rules] Oniguruma compile-time options.
@returns {TokenizerResult}
*/
export function tokenize(pattern: string, flags?: string, rules?: {
captureGroup?: boolean;
singleline?: boolean;
}): TokenizerResult;
export namespace TokenCharacterSetKinds {
let any: string;
let digit: string;
let dot: string;
let hex: string;
let non_newline: string;
let posix: string;
let property: string;
let space: string;
let word: string;
}
export namespace TokenDirectiveKinds {
let flags: string;
let keep: string;
}
export namespace TokenGroupKinds {
let absent_repeater: string;
let atomic: string;
let capturing: string;
let group: string;
let lookahead: string;
let lookbehind: string;
}
export namespace TokenTypes {
let Alternator: "Alternator";
let Assertion: "Assertion";
let Backreference: "Backreference";
let Character: "Character";
let CharacterClassClose: "CharacterClassClose";
let CharacterClassHyphen: "CharacterClassHyphen";
let CharacterClassIntersector: "CharacterClassIntersector";
let CharacterClassOpen: "CharacterClassOpen";
let CharacterSet: "CharacterSet";
let Directive: "Directive";
let GroupClose: "GroupClose";
let GroupOpen: "GroupOpen";
let Subroutine: "Subroutine";
let Quantifier: "Quantifier";
let VariableLengthCharacterSet: "VariableLengthCharacterSet";
let EscapedNumber: "EscapedNumber";
}

46
node_modules/oniguruma-to-es/dist/esm/transform.d.ts generated vendored
View File

@@ -1,20 +1,30 @@
export type RegexAst = {
type: "Regex";
parent: null;
pattern: any;
flags: any;
options: any;
export type RegexPlusAst = OnigurumaAst & {
options: {
disable: {
[key: string]: boolean;
};
force: {
[key: string]: boolean;
};
};
_originMap: Map<CapturingGroupNode, CapturingGroupNode>;
_strategy: string | null;
};
/**
@typedef {{
type: 'Regex';
parent: null;
pattern: Object;
flags: Object;
options: Object;
_strategy: string | null;
}} RegexAst
@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.
@@ -25,18 +35,18 @@ to representing native ES2025 `RegExp` but with some added features (atomic grou
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 {import('./parse.js').OnigurumaAst} ast
@param {OnigurumaAst} ast
@param {{
accuracy?: keyof Accuracy;
asciiWordBoundaries?: boolean;
avoidSubclass?: boolean;
bestEffortTarget?: keyof Target;
}} [options]
@returns {RegexAst}
@returns {RegexPlusAst}
*/
export function transform(ast: import("./parse.js").OnigurumaAst, options?: {
export function transform(ast: createAlternative, options?: {
accuracy?: "default" | "strict";
asciiWordBoundaries?: boolean;
avoidSubclass?: boolean;
bestEffortTarget?: "auto" | "ES2025" | "ES2024" | "ES2018";
}): RegexAst;
}): RegexPlusAst;

1
node_modules/oniguruma-to-es/dist/esm/traverse.d.ts generated vendored
View File

@@ -1 +0,0 @@
export function traverse(path: any, state: any, visitor: any): void;

12
node_modules/oniguruma-to-es/dist/esm/unicode.d.ts generated vendored
View File

@@ -1,8 +1,6 @@
export const asciiSpaceChar: "[\t-\r ]";
export const defaultWordChar: string;
export function getIgnoreCaseMatchChars(char: any): any[];
export const JsUnicodeProperties: any;
export const JsUnicodePropertiesMap: any;
export const JsUnicodePropertiesOfStringsMap: any;
export const PosixClassesMap: any;
export const PosixProperties: any;
export function slug(name: any): any;
export const UnicodePropertiesWithSpecificCase: any;
export const JsUnicodePropertyMap: Map<any, string>;
export const PosixClassMap: Map<string, string>;
export const UnicodePropertiesWithSpecificCase: Set<string>;

14
node_modules/oniguruma-to-es/dist/esm/utils-ast.d.ts generated vendored
View File

@@ -1,14 +0,0 @@
export function hasOnlyChild({ alternatives }: {
alternatives: any;
}, kidFn: any): any;
export function isAlwaysNonZeroLength(node: any): any;
export function isAlwaysZeroLength({ type }: {
type: any;
}): boolean;
export function isConsumptiveGroup({ type }: {
type: any;
}): boolean;
export function isLookaround({ type, kind }: {
type: any;
kind: any;
}): boolean;

16
node_modules/oniguruma-to-es/dist/esm/utils.d.ts generated vendored
View File

@@ -1,6 +1,8 @@
export const cp: any;
export const envSupportsFlagGroups: boolean;
export const envSupportsFlagV: boolean;
export const cp: (...codePoints: number[]) => string;
export namespace envFlags {
let bugFlagVLiteralHyphenIsRange: boolean;
let bugNestedClassIgnoresNegation: boolean;
}
export function getNewCurrentFlags(current: any, { enable, disable }: {
enable: any;
disable: any;
@@ -8,12 +10,14 @@ export function getNewCurrentFlags(current: any, { enable, disable }: {
dotAll: boolean;
ignoreCase: boolean;
};
export function getOrCreate(map: any, key: any, defaultValue: any): any;
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: any;
export function throwIfNot(value: any, msg: any): any;
export const r: (template: {
raw: readonly string[] | ArrayLike<string>;
}, ...substitutions: any[]) => string;
export function throwIfNullish(value: any, msg: any): any;