Astro+Directus(Visual-Editing)+Snipcart Test-Stack
This commit is contained in:
till committed
commit
1459e99cb0
10119 files changed
+1499318
No files matched your search
+27
@@ -0,0 +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 {RegexPlusAst} ast
|
||||
@param {ToRegExpOptions} [options]
|
||||
@returns {{
|
||||
pattern: string;
|
||||
flags: string;
|
||||
options: Object;
|
||||
_captureTransfers: Map<number, Array<number>>;
|
||||
_hiddenCaptures: Array<number>;
|
||||
}}
|
||||
*/
|
||||
export function generate(ast: RegexPlusAst, options?: ToRegExpOptions): {
|
||||
pattern: string;
|
||||
flags: string;
|
||||
options: Object;
|
||||
_captureTransfers: Map<number, Array<number>>;
|
||||
_hiddenCaptures: Array<number>;
|
||||
};
|
||||
import type { RegexPlusAst } from './transform.js';
|
||||
import type { ToRegExpOptions } from './index.js';
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
export type ToRegExpOptions = {
|
||||
accuracy?: "default" | "strict";
|
||||
avoidSubclass?: boolean;
|
||||
flags?: string;
|
||||
global?: boolean;
|
||||
hasIndices?: boolean;
|
||||
lazyCompileLength?: number;
|
||||
rules?: {
|
||||
allowOrphanBackrefs?: boolean;
|
||||
asciiWordBoundaries?: boolean;
|
||||
captureGroup?: boolean;
|
||||
recursionLimit?: number;
|
||||
singleline?: boolean;
|
||||
};
|
||||
target?: "auto" | "ES2025" | "ES2024" | "ES2018";
|
||||
verbose?: boolean;
|
||||
};
|
||||
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;
|
||||
captureGroup?: boolean;
|
||||
recursionLimit?: number;
|
||||
singleline?: boolean;
|
||||
};
|
||||
target?: keyof Target;
|
||||
verbose?: boolean;
|
||||
}} ToRegExpOptions
|
||||
*/
|
||||
/**
|
||||
Accepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.
|
||||
@param {string} pattern Oniguruma regex pattern.
|
||||
@param {ToRegExpOptions} [options]
|
||||
@returns {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 };
|
||||
+3145
File diff suppressed because it is too large.
Load diff
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../src/index.js", "../../src/utils.js", "../../src/options.js", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/utils.ts", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/tokenizer/tokenize.ts", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/parser/node-utils.ts", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/parser/parse.ts", "../../src/unicode.js", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/traverser/traverse.ts", "../../src/transform.js", "../../src/generate.js", "../../src/subclass.js", "../../node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/utils-internals.js", "../../node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js", "../../node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/atomic.js", "../../node_modules/.pnpm/regex-recursion@6.0.2/node_modules/regex-recursion/src/index.js"],
|
||||
"sourcesContent": ["import {transform} from './transform.js';\nimport {generate} from './generate.js';\nimport {Accuracy, getOptions, Target} from './options.js';\nimport {EmulatedRegExp} from './subclass.js';\nimport {JsUnicodePropertyMap} from './unicode.js';\nimport {parse} from 'oniguruma-parser/parser';\nimport {atomic, possessive} from 'regex/internals';\nimport {recursion} from 'regex-recursion';\n/**\n@import {EmulatedRegExpOptions} from './subclass.js';\n*/\n\n// The validation and transformation for Oniguruma's unique syntax and behavior differences\n// compared to native JS RegExp is layered into all steps of the compilation process:\n// 1. Parser: Uses `oniguruma-parser` to build an Oniguruma AST, which accounts for many\n// differences between Oniguruma and JS.\n// 2. Transformer: Converts the Oniguruma AST to a Regex+ AST that preserves all Oniguruma\n// behavior. This is true even in cases of non-native-JS features that are supported by both\n// Regex+ and Oniguruma but with subtly different behavior in each (subroutines, flag x).\n// 3. Generator: Converts the Regex+ AST to a Regex+ pattern, flags, and options.\n// 4. Postprocessing: Regex+ internals and plugins are used to transpile several remaining features\n// (atomic groups, possessive quantifiers, recursion). Regex+ uses a strict superset of JS\n// RegExp syntax, so using it allows this library to benefit from not reinventing the wheel for\n// complex features that Regex+ already knows how to transpile to JS.\n\n/**\n@typedef {{\n accuracy?: keyof Accuracy;\n avoidSubclass?: boolean;\n flags?: string;\n global?: boolean;\n hasIndices?: boolean;\n lazyCompileLength?: number;\n rules?: {\n allowOrphanBackrefs?: boolean;\n asciiWordBoundaries?: boolean;\n captureGroup?: boolean;\n recursionLimit?: number;\n singleline?: boolean;\n };\n target?: keyof Target;\n verbose?: boolean;\n}} ToRegExpOptions\n*/\n\n/**\nAccepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.\n@param {string} pattern Oniguruma regex pattern.\n@param {ToRegExpOptions} [options]\n@returns {RegExp | EmulatedRegExp}\n*/\nfunction toRegExp(pattern, options) {\n const d = toRegExpDetails(pattern, options);\n if (d.options) {\n return new EmulatedRegExp(d.pattern, d.flags, d.options);\n }\n return new RegExp(d.pattern, d.flags);\n}\n\n/**\nAccepts an Oniguruma pattern and returns the details for an equivalent JavaScript `RegExp`.\n@param {string} pattern Oniguruma regex pattern.\n@param {ToRegExpOptions} [options]\n@returns {{\n pattern: string;\n flags: string;\n options?: EmulatedRegExpOptions;\n}}\n*/\nfunction toRegExpDetails(pattern, options) {\n const opts = getOptions(options);\n const onigurumaAst = parse(pattern, {\n flags: opts.flags,\n normalizeUnknownPropertyNames: true,\n rules: {\n captureGroup: opts.rules.captureGroup,\n singleline: opts.rules.singleline,\n },\n skipBackrefValidation: opts.rules.allowOrphanBackrefs,\n unicodePropertyMap: JsUnicodePropertyMap,\n });\n const regexPlusAst = transform(onigurumaAst, {\n accuracy: opts.accuracy,\n asciiWordBoundaries: opts.rules.asciiWordBoundaries,\n avoidSubclass: opts.avoidSubclass,\n bestEffortTarget: opts.target,\n });\n const generated = generate(regexPlusAst, opts);\n const recursionResult = recursion(generated.pattern, {\n captureTransfers: generated._captureTransfers,\n hiddenCaptures: generated._hiddenCaptures,\n mode: 'external',\n });\n const possessiveResult = possessive(recursionResult.pattern);\n const atomicResult = atomic(possessiveResult.pattern, {\n captureTransfers: recursionResult.captureTransfers,\n hiddenCaptures: recursionResult.hiddenCaptures,\n });\n const details = {\n pattern: atomicResult.pattern,\n flags: `${opts.hasIndices ? 'd' : ''}${opts.global ? 'g' : ''}${generated.flags}${generated.options.disable.v ? 'u' : 'v'}`,\n };\n if (opts.avoidSubclass) {\n if (opts.lazyCompileLength !== Infinity) {\n throw new Error('Lazy compilation requires subclass');\n }\n } else {\n // Sort isn't required; only for readability when serialized\n const hiddenCaptures = atomicResult.hiddenCaptures.sort((a, b) => a - b);\n // Change the map to the `EmulatedRegExp` format, serializable as JSON\n const transfers = Array.from(atomicResult.captureTransfers);\n const strategy = regexPlusAst._strategy;\n const lazyCompile = details.pattern.length >= opts.lazyCompileLength;\n if (hiddenCaptures.length || transfers.length || strategy || lazyCompile) {\n details.options = {\n ...(hiddenCaptures.length && {hiddenCaptures}),\n ...(transfers.length && {transfers}),\n ...(strategy && {strategy}),\n ...(lazyCompile && {lazyCompile}),\n };\n }\n }\n return details;\n}\n\n// function toOnigurumaAst(pattern, options) {\n// return parse(pattern, {\n// flags: options?.flags ?? '',\n// noLine truncated
|
||||
"mappings": "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 truncated
|
||||
"names": ["cpOf", "char", "getOrInsert", "map", "key", "defaultValue", "PosixClassNames", "r", "throwIfNullish", "value", "msg", "charClassOpenPattern", "r", "sharedEscapesPattern", "quantifierRe", "tokenRe", "charClassTokenRe", "tokenize", "pattern", "options", "opts", "flagProperties", "getFlagProperties", "xStack", "context", "isXOn", "tokens", "match", "result", "getTokenWithDetails", "potentialUnnamedCaptureTokens", "numNamedAndOptInUnnamedCaptures", "t", "i", "numCaptures", "splitEscapedNumberToken", "m", "lastIndex", "m0", "m1", "getAllTokensForCharClass", "createAssertionToken", "createSubroutineToken", "createBackreferenceToken", "createDirectiveToken", "createCharacterSetToken", "tokenizeSharedEscape", "tokenizeNamedCallout", "tokenizeFlagModifier", "createGroupOpenToken", "createGroupCloseToken", "end", "re", "kind", "createAlternatorToken", "splitQuantifierMatch", "createCharacterToken", "cpOf", "opener", "createCharacterClassOpenToken", "numCharClassesOpen", "createCharacterClassCloseToken", "tokenizeAnyTokenWithinCharClass", "raw", "posix", "PosixClassNames", "createCharacterClassHyphenToken", "createCharacterClassIntersectorToken", "inCharClass", "char1", "tokenizeControlCharacter", "tokenizeShorthand", "tokenizeUnicodeProperty", "bytes", "hex", "decoded", "encoder", "char", "byte", "getValidatedHexCharCode", "EscapeCharCodes", "createEscapedNumberToken", "value", "negate", "throwIfNullish", "createNamedCalloutToken", "tag", "args", "createQuantifierToken", "min", "max", "CalloutNames", "on", "off", "enabledFlags", "getFlagGroupSwitches", "disabledFlags", "flagChanges", "callout", "name", "argsArray", "arg", "arg0", "arg1", "arg2", "tokenizeQuantifier", "minStr", "maxStr", "limit", "lower", "p", "neg", "flags", "obj", "token", "matches", "str", "withG", "parts", "hasOnlyChild", "node", "props", "kid", "key", "isQuantifiable", "node", "quantifiableTypes", "parse", "pattern", "options", "opts", "tokenized", "tokenize", "walk", "parent", "state", "token", "context", "createAlternative", "parseAssertion", "parseBackreference", "createCharacter", "parseCharacterClassHyphen", "parseCharacterClassOpen", "parseCharacterSet", "createDirective", "parseGroupOpen", "createNamedCallout", "parseQuantifier", "parseSubroutine", "ast", "createRegex", "createFlags", "top", "node", "capturingGroups", "hasNumberedRef", "namedGroupsByName", "subroutines", "ref", "r", "kind", "createAssertion", "throwIfNullish", "raw", "hasKWrapper", "fromNum", "num", "isRelative", "numCapturesToLeft", "orphan", "createBackreference", "numberedRef", "_", "tokens", "prevSiblingNode", "nextToken", "nextNode", "createCharacterClassRange", "cpOf", "negate", "intersections", "createCharacterClass", "ccFirstToken", "throwIfUnclosedCharacterClass", "cc", "value", "normalizeUnknownPropertyNames", "skipPropertyNameValidation", "unicodePropertyMap", "normalized", "slug", "PosixClassNames", "createUnicodeProperty", "createPosixClass", "createCharacterSet", "skipLookbehindValidation", "createByGroupKind", "isThisAbsenceFunction", "isThisLookbehind", "isLookbehind", "isThisNegLookbehind", "getOrInsert", "throwIfUnclosedGroup", "alt", "child", "msg", "isLookahead", "min", "max", "quantifiedNode", "isQuantifiable", "createQuantifier", "createSubroutine", "createAbsenceFunction", "getBodyForAlternativeContainer", "getBodyForElementContainer", "createCapturingGroup", "number", "isValidGroupName", "charCode", "hex", "flags", "createGroup", "atomic", "createLookaroundAssertion", "tag", "args", "name", "body", "normalizeUnicodePropertyName", "m", "first", "w", "range", "i", "traverse", "root", "visitor", "state", "traverseArray", "array", "parent", "i", "keyShift", "traverseNode", "node", "key", "container", "skipTraversingKidsOfPath", "path", "arrayContainer", "numericKey", "shifted", "newNode", "options", "traverseNew", "throwIfNullish", "newNodes", "keyShiftInLoop", "type", "anyTypeVisitor", "thisTypeVisitor", "enterAllFn", "enterThisFn", "value", "A", "K", "Q", "_", "i", "b", "F", "m", "B", "C", "E", "w", "o", "f", "node", "recursion", "k", "P", "a", "O", "J", "_", "m", "A", "b", "atomic", "i", "a", "re", "i", "m", "i", "re", "m", "token", "m", "f", "r", "m", "i", "incrementIfAtLeast", "f", "d", "J", "a", "b"]
|
||||
}
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
export namespace Accuracy {
|
||||
let _default: "default";
|
||||
export { _default as default };
|
||||
export let strict: "strict";
|
||||
}
|
||||
export namespace EsVersion {
|
||||
let ES2025: number;
|
||||
let ES2024: number;
|
||||
let ES2018: number;
|
||||
}
|
||||
/**
|
||||
Returns a complete set of options, with default values set for options that weren't provided.
|
||||
@param {ToRegExpOptions} [options]
|
||||
@returns {Required<ToRegExpOptions>}
|
||||
*/
|
||||
export function getOptions(options?: ToRegExpOptions): Required<ToRegExpOptions>;
|
||||
export namespace Target {
|
||||
export let auto: "auto";
|
||||
let ES2025_1: "ES2025";
|
||||
export { ES2025_1 as ES2025 };
|
||||
let ES2024_1: "ES2024";
|
||||
export { ES2024_1 as ES2024 };
|
||||
let ES2018_1: "ES2018";
|
||||
export { ES2018_1 as ES2018 };
|
||||
}
|
||||
import type { ToRegExpOptions } from './index.js';
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"type":"commonjs"}
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
export type EmulatedRegExpOptions = {
|
||||
hiddenCaptures?: Array<number>;
|
||||
lazyCompile?: boolean;
|
||||
strategy?: string | null;
|
||||
transfers?: Array<[number, Array<number>]>;
|
||||
};
|
||||
/**
|
||||
@typedef {{
|
||||
hiddenCaptures?: Array<number>;
|
||||
lazyCompile?: boolean;
|
||||
strategy?: string | null;
|
||||
transfers?: Array<[number, Array<number>]>;
|
||||
}} EmulatedRegExpOptions
|
||||
*/
|
||||
/**
|
||||
Works the same as JavaScript's native `RegExp` constructor in all contexts, but can be given
|
||||
results from `toRegExpDetails` to produce the same result as `toRegExp`.
|
||||
*/
|
||||
export class EmulatedRegExp extends RegExp {
|
||||
/**
|
||||
@overload
|
||||
@param {string} pattern
|
||||
@param {string} [flags]
|
||||
@param {EmulatedRegExpOptions} [options]
|
||||
*/
|
||||
constructor(pattern: string, flags?: string | undefined, options?: EmulatedRegExpOptions | undefined);
|
||||
/**
|
||||
@overload
|
||||
@param {EmulatedRegExp} pattern
|
||||
@param {string} [flags]
|
||||
*/
|
||||
constructor(pattern: EmulatedRegExp, flags?: string | undefined);
|
||||
/**
|
||||
Can be used to serialize the instance.
|
||||
@type {EmulatedRegExpOptions}
|
||||
*/
|
||||
rawOptions: EmulatedRegExpOptions;
|
||||
#private;
|
||||
}
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
export type RegexPlusAst = OnigurumaAst & {
|
||||
options: {
|
||||
disable: {
|
||||
[key: string]: boolean;
|
||||
};
|
||||
force: {
|
||||
[key: string]: boolean;
|
||||
};
|
||||
};
|
||||
_originMap: Map<CapturingGroupNode, CapturingGroupNode>;
|
||||
_strategy: string | null;
|
||||
};
|
||||
/**
|
||||
@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.
|
||||
Assumes target ES2025, expecting the generator to down-convert to the desired JS target version.
|
||||
|
||||
Regex+'s syntax and behavior is a strict superset of native JavaScript, so the AST is very close
|
||||
to representing native ES2025 `RegExp` but with some added features (atomic groups, possessive
|
||||
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 {OnigurumaAst} ast
|
||||
@param {{
|
||||
accuracy?: keyof Accuracy;
|
||||
asciiWordBoundaries?: boolean;
|
||||
avoidSubclass?: boolean;
|
||||
bestEffortTarget?: keyof Target;
|
||||
}} [options]
|
||||
@returns {RegexPlusAst}
|
||||
*/
|
||||
export function transform(ast: OnigurumaAst, options?: {
|
||||
accuracy?: "default" | "strict";
|
||||
asciiWordBoundaries?: boolean;
|
||||
avoidSubclass?: boolean;
|
||||
bestEffortTarget?: "auto" | "ES2025" | "ES2024" | "ES2018";
|
||||
}): RegexPlusAst;
|
||||
import type { OnigurumaAst } from 'oniguruma-parser/parser';
|
||||
import type { CapturingGroupNode } from 'oniguruma-parser/parser';
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
export const asciiSpaceChar: "[\t-\r ]";
|
||||
export const defaultWordChar: string;
|
||||
export function getIgnoreCaseMatchChars(char: any): any[];
|
||||
export const JsUnicodePropertyMap: Map<string, string>;
|
||||
export const PosixClassMap: Map<string, string>;
|
||||
export const UnicodePropertiesWithSpecificCase: Set<string>;
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
export const cp: (...codePoints: number[]) => string;
|
||||
export namespace envFlags {
|
||||
let flagGroups: boolean;
|
||||
let unicodeSets: boolean;
|
||||
let bugFlagVLiteralHyphenIsRange: boolean;
|
||||
let bugNestedClassIgnoresNegation: boolean;
|
||||
}
|
||||
export function getNewCurrentFlags(current: any, { enable, disable }: {
|
||||
enable: any;
|
||||
disable: any;
|
||||
}): {
|
||||
dotAll: boolean;
|
||||
ignoreCase: boolean;
|
||||
};
|
||||
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: (template: {
|
||||
raw: readonly string[] | ArrayLike<string>;
|
||||
}, ...substitutions: any[]) => string;
|
||||
export function throwIfNullish(value: any, msg: any): any;
|
||||
Reference in new issue
Block a user