full site update

node_modules/oniguruma-parser/dist/parser/node-utils.d.ts

@@ -0,0 +1,14 @@
+import type { AlternativeContainerNode, Node, ParentNode, QuantifiableNode } from './parse.js';
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Props = {
+    [key in KeysOfUnion<Node>]?: any;
+} & {
+    type?: Node['type'];
+};
+declare function hasOnlyChild(node: ParentNode & {
+    body: Array<Node>;
+}, props?: Props): boolean;
+declare function isAlternativeContainer(node: Node): node is AlternativeContainerNode;
+declare function isQuantifiable(node: Node): node is QuantifiableNode;
+export { hasOnlyChild, isAlternativeContainer, isQuantifiable, };
+//# sourceMappingURL=node-utils.d.ts.map

node_modules/oniguruma-parser/dist/parser/node-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-utils.d.ts","sourceRoot":"","sources":["../../src/parser/node-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,wBAAwB,EAAE,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAE7F,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,GAAE,KAAK,CAAC;AACnD,KAAK,KAAK,GAAG;KAAE,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG;CAAC,GAAG;IAAC,IAAI,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;CAAC,CAAC;AAExE,iBAAS,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG;IAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,CASpF;AAED,iBAAS,sBAAsB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,wBAAwB,CAQ5E;AASD,iBAAS,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,gBAAgB,CAE5D;AAaD,OAAO,EACL,YAAY,EACZ,sBAAsB,EACtB,cAAc,GACf,CAAC"}

node_modules/oniguruma-parser/dist/parser/node-utils.js

@@ -0,0 +1,2 @@
+"use strict";function o(e,t){if(!Array.isArray(e.body))throw new Error("Expected node with body array");if(e.body.length!==1)return!1;const r=e.body[0];return!t||Object.keys(t).every(n=>t[n]===r[n])}function a(e){return!(!i.has(e.type)||e.type==="AbsenceFunction"&&e.kind!=="repeater")}const i=new Set(["AbsenceFunction","CapturingGroup","Group","LookaroundAssertion","Regex"]);function s(e){return y.has(e.type)}const y=new Set(["AbsenceFunction","Backreference","CapturingGroup","Character","CharacterClass","CharacterSet","Group","Quantifier","Subroutine"]);export{o as hasOnlyChild,a as isAlternativeContainer,s as isQuantifiable};
+//# sourceMappingURL=node-utils.js.map

node_modules/oniguruma-parser/dist/parser/node-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/parser/node-utils.ts"],
+  "sourcesContent": ["import type {AlternativeContainerNode, Node, ParentNode, QuantifiableNode} from './parse.js';\n\ntype KeysOfUnion<T> = T extends T ? keyof T: never;\ntype Props = {[key in KeysOfUnion<Node>]?: any} & {type?: Node['type']};\n\nfunction hasOnlyChild(node: ParentNode & {body: Array<Node>}, props?: Props): boolean {\n  if (!Array.isArray(node.body)) {\n    throw new Error('Expected node with body array');\n  }\n  if (node.body.length !== 1) {\n    return false;\n  }\n  const kid = node.body[0] as Props;\n  return !props || Object.keys(props).every(key => props[key as keyof Props] === kid[key as keyof Props]);\n}\n\nfunction isAlternativeContainer(node: Node): node is AlternativeContainerNode {\n  if (\n    !alternativeContainerTypes.has(node.type) ||\n    (node.type === 'AbsenceFunction' && node.kind !== 'repeater')\n  ) {\n    return false;\n  }\n  return true;\n}\nconst alternativeContainerTypes = new Set<Node['type']>([\n  'AbsenceFunction',\n  'CapturingGroup',\n  'Group',\n  'LookaroundAssertion',\n  'Regex',\n]);\n\nfunction isQuantifiable(node: Node): node is QuantifiableNode {\n  return quantifiableTypes.has(node.type);\n}\nconst quantifiableTypes = new Set<Node['type']>([\n  'AbsenceFunction',\n  'Backreference',\n  'CapturingGroup',\n  'Character',\n  'CharacterClass',\n  'CharacterSet',\n  'Group',\n  'Quantifier',\n  'Subroutine',\n]);\n\nexport {\n  hasOnlyChild,\n  isAlternativeContainer,\n  isQuantifiable,\n};\n"],
+  "mappings": "aAKA,SAASA,EAAaC,EAAwCC,EAAwB,CACpF,GAAI,CAAC,MAAM,QAAQD,EAAK,IAAI,EAC1B,MAAM,IAAI,MAAM,+BAA+B,EAEjD,GAAIA,EAAK,KAAK,SAAW,EACvB,MAAO,GAET,MAAME,EAAMF,EAAK,KAAK,CAAC,EACvB,MAAO,CAACC,GAAS,OAAO,KAAKA,CAAK,EAAE,MAAME,GAAOF,EAAME,CAAkB,IAAMD,EAAIC,CAAkB,CAAC,CACxG,CAEA,SAASC,EAAuBJ,EAA8C,CAC5E,MACE,GAACK,EAA0B,IAAIL,EAAK,IAAI,GACvCA,EAAK,OAAS,mBAAqBA,EAAK,OAAS,WAKtD,CACA,MAAMK,EAA4B,IAAI,IAAkB,CACtD,kBACA,iBACA,QACA,sBACA,OACF,CAAC,EAED,SAASC,EAAeN,EAAsC,CAC5D,OAAOO,EAAkB,IAAIP,EAAK,IAAI,CACxC,CACA,MAAMO,EAAoB,IAAI,IAAkB,CAC9C,kBACA,gBACA,iBACA,YACA,iBACA,eACA,QACA,aACA,YACF,CAAC,EAED,OACER,KAAA,aACAK,KAAA,uBACAE,KAAA",
+  "names": ["hasOnlyChild", "node", "props", "kid", "key", "isAlternativeContainer", "alternativeContainerTypes", "isQuantifiable", "quantifiableTypes"]
+}

node_modules/oniguruma-parser/dist/parser/parse.d.ts

@@ -0,0 +1,208 @@
+import type { FlagGroupModifiers, FlagProperties, TokenCharacterSetKind, TokenDirectiveKind, TokenNamedCalloutKind, TokenQuantifierKind } from '../tokenizer/tokenize.js';
+import { hasOnlyChild, isAlternativeContainer, isQuantifiable } from './node-utils.js';
+type Node = AbsenceFunctionNode | AlternativeNode | AssertionNode | BackreferenceNode | CapturingGroupNode | CharacterNode | CharacterClassNode | CharacterClassRangeNode | CharacterSetNode | DirectiveNode | FlagsNode | GroupNode | LookaroundAssertionNode | NamedCalloutNode | QuantifierNode | RegexNode | SubroutineNode;
+type OnigurumaAst = RegexNode;
+type ParentNode = AlternativeContainerNode | AlternativeNode | CharacterClassNode | CharacterClassRangeNode | QuantifierNode;
+type AlternativeContainerNode = AbsenceFunctionNode | // Some sub-kinds aren't alternative containers
+CapturingGroupNode | GroupNode | LookaroundAssertionNode | RegexNode;
+type AlternativeElementNode = AbsenceFunctionNode | AssertionNode | BackreferenceNode | CapturingGroupNode | CharacterNode | CharacterClassNode | CharacterSetNode | DirectiveNode | GroupNode | LookaroundAssertionNode | NamedCalloutNode | QuantifierNode | SubroutineNode;
+type CharacterClassElementNode = CharacterNode | CharacterClassNode | CharacterClassRangeNode | CharacterSetNode;
+type QuantifiableNode = AbsenceFunctionNode | BackreferenceNode | CapturingGroupNode | CharacterNode | CharacterClassNode | CharacterSetNode | GroupNode | QuantifierNode | SubroutineNode;
+type NodeAbsenceFunctionKind = 'repeater';
+type NodeAssertionKind = 'line_end' | 'line_start' | 'search_start' | 'string_end' | 'string_end_newline' | 'string_start' | 'text_segment_boundary' | 'word_boundary';
+type NodeCharacterClassKind = 'union' | 'intersection';
+type NodeCharacterSetKind = TokenCharacterSetKind;
+type NodeDirectiveKind = TokenDirectiveKind;
+type NodeLookaroundAssertionKind = 'lookahead' | 'lookbehind';
+type NodeNamedCalloutKind = TokenNamedCalloutKind;
+type NodeQuantifierKind = TokenQuantifierKind;
+type UnicodePropertyMap = Map<string, string>;
+type ParseOptions = {
+    flags?: string;
+    normalizeUnknownPropertyNames?: boolean;
+    rules?: {
+        captureGroup?: boolean;
+        singleline?: boolean;
+    };
+    skipBackrefValidation?: boolean;
+    skipLookbehindValidation?: boolean;
+    skipPropertyNameValidation?: boolean;
+    unicodePropertyMap?: UnicodePropertyMap | null;
+};
+declare function parse(pattern: string, options?: ParseOptions): OnigurumaAst;
+type AbsenceFunctionNode = {
+    type: 'AbsenceFunction';
+    kind: NodeAbsenceFunctionKind;
+    body: Array<AlternativeNode>;
+};
+declare function createAbsenceFunction(kind: NodeAbsenceFunctionKind, options?: {
+    body?: Array<AlternativeNode>;
+}): AbsenceFunctionNode;
+type AlternativeNode = {
+    type: 'Alternative';
+    body: Array<AlternativeElementNode>;
+};
+declare function createAlternative(options?: {
+    body?: Array<AlternativeElementNode>;
+}): AlternativeNode;
+type AssertionNode = {
+    type: 'Assertion';
+    kind: NodeAssertionKind;
+    negate?: boolean;
+};
+declare function createAssertion(kind: NodeAssertionKind, options?: {
+    negate?: boolean;
+}): AssertionNode;
+type BackreferenceNode = {
+    type: 'Backreference';
+    ref: string | number;
+    orphan?: boolean;
+};
+declare function createBackreference(ref: string | number, options?: {
+    orphan?: boolean;
+}): BackreferenceNode;
+type CapturingGroupNode = {
+    type: 'CapturingGroup';
+    kind?: never;
+    number: number;
+    name?: string;
+    isSubroutined?: boolean;
+    body: Array<AlternativeNode>;
+};
+declare function createCapturingGroup(number: number, options?: {
+    name?: string;
+    isSubroutined?: boolean;
+    body?: Array<AlternativeNode>;
+}): CapturingGroupNode;
+type CharacterNode = {
+    type: 'Character';
+    value: number;
+};
+declare function createCharacter(charCode: number, options?: {
+    useLastValid?: boolean;
+}): CharacterNode;
+type CharacterClassNode = {
+    type: 'CharacterClass';
+    kind: NodeCharacterClassKind;
+    negate: boolean;
+    body: Array<CharacterClassElementNode>;
+};
+declare function createCharacterClass(options?: {
+    kind?: NodeCharacterClassKind;
+    negate?: boolean;
+    body?: Array<CharacterClassElementNode>;
+}): CharacterClassNode;
+type CharacterClassRangeNode = {
+    type: 'CharacterClassRange';
+    min: CharacterNode;
+    max: CharacterNode;
+};
+declare function createCharacterClassRange(min: CharacterNode, max: CharacterNode): CharacterClassRangeNode;
+type NamedCharacterSetNode = {
+    type: 'CharacterSet';
+    kind: 'posix' | 'property';
+    value: string;
+    negate: boolean;
+    variableLength?: never;
+};
+type UnnamedCharacterSetNode = {
+    type: 'CharacterSet';
+    kind: Exclude<NodeCharacterSetKind, NamedCharacterSetNode['kind']>;
+    value?: never;
+    negate?: boolean;
+    variableLength?: boolean;
+};
+type CharacterSetNode = NamedCharacterSetNode | UnnamedCharacterSetNode;
+/**
+Use `createUnicodeProperty` and `createPosixClass` for `kind` values `'property'` and `'posix'`.
+*/
+declare function createCharacterSet(kind: UnnamedCharacterSetNode['kind'], options?: {
+    negate?: boolean;
+}): UnnamedCharacterSetNode;
+type DirectiveNode = {
+    type: 'Directive';
+} & ({
+    kind: 'keep';
+    flags?: never;
+} | {
+    kind: 'flags';
+    flags: FlagGroupModifiers;
+});
+declare function createDirective(kind: NodeDirectiveKind, options?: {
+    flags?: FlagGroupModifiers;
+}): DirectiveNode;
+type FlagsNode = {
+    type: 'Flags';
+} & FlagProperties;
+declare function createFlags(flags: FlagProperties): FlagsNode;
+type GroupNode = {
+    type: 'Group';
+    kind?: never;
+    atomic?: boolean;
+    flags?: FlagGroupModifiers;
+    body: Array<AlternativeNode>;
+};
+declare function createGroup(options?: {
+    atomic?: boolean;
+    flags?: FlagGroupModifiers;
+    body?: Array<AlternativeNode>;
+}): GroupNode;
+type LookaroundAssertionNode = {
+    type: 'LookaroundAssertion';
+    kind: NodeLookaroundAssertionKind;
+    negate: boolean;
+    body: Array<AlternativeNode>;
+};
+declare function createLookaroundAssertion(options?: {
+    behind?: boolean;
+    negate?: boolean;
+    body?: Array<AlternativeNode>;
+}): LookaroundAssertionNode;
+type NamedCalloutNode = {
+    type: 'NamedCallout';
+    kind: NodeNamedCalloutKind;
+    tag: string | null;
+    arguments: Array<string | number> | null;
+};
+declare function createNamedCallout(kind: NodeNamedCalloutKind, tag: string | null, args: Array<string | number> | null): NamedCalloutNode;
+declare function createPosixClass(name: string, options?: {
+    negate?: boolean;
+}): NamedCharacterSetNode & {
+    kind: 'posix';
+};
+type QuantifierNode = {
+    type: 'Quantifier';
+    kind: NodeQuantifierKind;
+    min: number;
+    max: number;
+    body: QuantifiableNode;
+};
+declare function createQuantifier(kind: NodeQuantifierKind, min: number, max: number, body: QuantifiableNode): QuantifierNode;
+type RegexNode = {
+    type: 'Regex';
+    body: Array<AlternativeNode>;
+    flags: FlagsNode;
+};
+declare function createRegex(flags: FlagsNode, options?: {
+    body?: Array<AlternativeNode>;
+}): RegexNode;
+type SubroutineNode = {
+    type: 'Subroutine';
+    ref: string | number;
+};
+declare function createSubroutine(ref: string | number): SubroutineNode;
+type CreateUnicodePropertyOptions = {
+    negate?: boolean;
+    normalizeUnknownPropertyNames?: boolean;
+    skipPropertyNameValidation?: boolean;
+    unicodePropertyMap?: UnicodePropertyMap | null;
+};
+declare function createUnicodeProperty(name: string, options?: CreateUnicodePropertyOptions): NamedCharacterSetNode & {
+    kind: 'property';
+};
+/**
+Generates a Unicode property lookup name: lowercase, without spaces, hyphens, or underscores.
+*/
+declare function slug(name: string): string;
+export { type AbsenceFunctionNode, type AlternativeNode, type AlternativeContainerNode, type AlternativeElementNode, type AssertionNode, type BackreferenceNode, type CapturingGroupNode, type CharacterClassElementNode, type CharacterClassNode, type CharacterClassRangeNode, type CharacterNode, type CharacterSetNode, type DirectiveNode, type FlagsNode, type GroupNode, type LookaroundAssertionNode, type NamedCalloutNode, type Node, type NodeAbsenceFunctionKind, type NodeAssertionKind, type NodeCharacterClassKind, type NodeCharacterSetKind, type NodeDirectiveKind, type NodeLookaroundAssertionKind, type NodeQuantifierKind, type OnigurumaAst, type ParentNode, type ParseOptions, type QuantifiableNode, type QuantifierNode, type RegexNode, type SubroutineNode, type UnicodePropertyMap, createAbsenceFunction, createAlternative, createAssertion, createBackreference, createCapturingGroup, createCharacter, createCharacterClass, createCharacterClassRange, createCharacterSet, createDirective, createFlags, createGroup, createLookaroundAssertion, createNamedCallout, createPosixClass, createQuantifier, createRegex, createSubroutine, createUnicodeProperty, hasOnlyChild, isAlternativeContainer, isQuantifiable, parse, slug, };
+//# sourceMappingURL=parse.d.ts.map