#(reason)
[[:alnum:]$] will match alphanumeric characters and $.",
},
dot: {
title: "Dot",
detail: "Matches any character {{getDotAll()}}.",
},
matchanyset: {
title: "Match any",
detail:
"A character set that can be used to match any character, including line breaks, without the dotall flag (s)." +
"An alternative is [^], but it is not supported in all browsers.
$ or \\Z, it does not allow for a trailing newline.",
},
bof: {
title: "Beginning",
detail:
"Matches the beginning of the string, or the beginning of a line if the multiline flag (m) is enabled.",
},
eof: {
title: "End",
detail:
"Matches the end of the string, or the end of a line if the multiline flag (m) is enabled.",
},
wordboundary: {
title: "Word boundary",
detail:
"Matches a word boundary position between a word character and non-word character or position (start / end of string).",
},
notwordboundary: {
title: "Not word boundary",
detail: "Matches any position that is not a word boundary.",
},
prevmatchend: {
title: "Previous match end",
detail: "Matches the end position of the previous match.",
},
invalid: {
title: "Invalid character class",
detail: "No overview available.",
},
},
escchars: {
label: "Escaped characters",
desc: "Escape sequences can be used to insert reserved, special, and unicode characters. All escaped characters begin with the \\ character.",
reservedchar: {
title: "Reserved characters",
detail:
"The following character have special meaning, and should be preceded by a \\ (backslash) to represent a literal character:" +
"{{getEscChars()}}
Within a character set, only \\, -, and ] need to be escaped.
\\000.",
},
eschexadecimal: {
title: "Hexadecimal escape",
detail: "Hexadecimal escaped character in the form \\xFF.",
},
escunicodeu: {
title: "Unicode escape",
detail: "Unicode escaped character in the form \\uFFFF",
},
escunicodeub: {
title: "Extended unicode escape",
detail: "Unicode escaped character in the form \\u{FFFF}.",
},
escunicodexb: {
title: "Unicode escape",
detail: "Unicode escaped character in the form \\x{FF}.",
},
esccontrolchar: {
title: "Control character escape",
detail: "Escaped control character in the form \\cZ.",
},
escsequence: {
title: "Escape sequence",
detail: "Matches the literal string '{{value}}'.",
},
},
groups: {
label: "Groups & References",
desc: "Groups allow you to combine a sequence of tokens to operate on them together. Capture groups can be referenced by a backreference and accessed separately in the results.",
group: {
title: "Capturing group #{{group.num}}",
detail:
"Groups multiple tokens together and creates a capture group for extracting a substring or using a backreference.",
},
namedgroup: {
title: "Named capturing group",
detail: "Creates a capturing group named '{{name}}'.",
},
namedref: {
title: "Named reference",
detail:
"Matches the results of the capture group named '{{group.name}}'.",
},
numref: {
title: "Numeric reference",
detail: "Matches the results of capture group #{{group.num}}.",
},
branchreset: {
title: "Branch reset group",
detail: "Define alternative groups that share the same group numbers.",
},
noncapgroup: {
title: "Non-capturing group",
detail:
"Groups multiple tokens together without creating a capture group.",
},
atomic: {
title: "Atomic group",
detail:
"Non-capturing group that discards backtracking positions once matched.",
},
define: {
title: "Define",
detail:
"Used to define named groups for use as subroutines without including them in the match.",
},
numsubroutine: {
title: "Numeric subroutine",
detail: "Matches the expression in capture group #{{group.num}}.",
},
namedsubroutine: {
title: "Named subroutine",
detail:
"Matches the expression in the capture group named '{{group.name}}'.",
},
balancedcapture: {
title: "Balancing group",
detail:
"This allows nested constructs to be matched, such as parentheses or HTML tags. The previously defined group to balance against is specified by previous. Captures subpattern as a named group specified by name, or name can be omitted to capture as an unnamed group.",
},
absentfunction: {
title: "Absent function",
detail: "No overview available.",
},
},
lookaround: {
label: "Lookaround",
desc:
"Lookaround lets you match a group before (lookbehind) or after (lookahead) your main pattern without including it in the result." +
"Negative lookarounds specify a group that can NOT match before or after the pattern.
", poslookahead: { title: "Positive lookahead", detail: "Matches a group after the main expression without including it in the result.", }, neglookahead: { title: "Negative lookahead", detail: "Specifies a group that can not match after the main expression (if it matches, the result is discarded).", }, poslookbehind: { title: "Positive lookbehind", detail: "Matches a group before the main expression without including it in the result.", }, neglookbehind: { title: "Negative lookbehind", detail: "Specifies a group that can not match before the main expression (if it matches, the result is discarded).", }, keepout: { title: "Keep out", detail: "Keep text matched so far out of the returned match, essentially discarding the match up to this point.", }, nonatomicposlookahead: { title: "Non-atomic Positive lookahead", detail: "No overview available.", }, nonatomicposlookbehind: { title: "Non-atomic Positive lookbehind", detail: "No overview available.", }, scriptrun: { title: "Script run", detail: "No overview available.", }, atomicscriptrun: { title: "Atomic script run", detail: "No overview available.", }, changematchingoptions: { title: "Change matching options", detail: "No overview available.", }, }, quants: { label: "Quantifiers & Alternation", desc: "Quantifiers indicate that the preceding token must be matched a certain number of times. By default, quantifiers are greedy, and will match as many characters as possible." + "|.",
},
},
other: {
label: "Special",
desc: "Tokens that don't quite fit anywhere else.",
comment: {
title: "Comment",
detail:
"Allows you to insert a comment into your expression that is ignored when finding a match.",
},
conditional: {
title: "Conditional",
detail:
"Conditionally matches one of two options based on whether a lookaround is matched.",
},
conditionalgroup: {
title: "Group conditional",
detail:
"Conditionally matches one of two options based on whether group '{{name}}' matched.",
},
recursion: {
title: "Recursion",
detail:
"Attempts to match the full expression again at the current position.",
},
mode: {
title: "Mode modifier",
detail: "{{~getDesc()}}{{~getModes()}}",
},
interpolation: {
title: "Interpolation",
detail: "No overview available.",
},
},
subst: {
label: "Substitution",
desc: "These tokens are used in a substitution string to insert different parts of the match.",
"subst_$&match": {
title: "Match",
detail: "Inserts the matched text.",
},
subst_0match: {
title: "Match",
detail: "Inserts the matched text.",
},
subst_group: {
title: "Capture group",
detail: "Inserts the results of capture group #{{group.num}}.",
},
subst_$before: {
title: "Before match",
detail:
"Inserts the portion of the source string that precedes the match.",
},
subst_$after: {
title: "After match",
detail:
"Inserts the portion of the source string that follows the match.",
},
subst_$esc: {
title: "Escaped $",
detail: "Inserts a dollar sign character ($).",
},
subst_esc: {
title: "Escaped characters",
detail:
"For convenience, these escaped characters are supported in the Replace string in RegExr: \\n, \\r, \\t, \\\\, and unicode escapes \\uFFFF. This may vary in your deploy environment.",
},
},
flags: {
label: "Flags",
desc: "Expression flags change how the expression is interpreted. Flags follow the closing forward slash of the expression (ex. /.+/igm ).",
caseinsensitive: {
title: "Ignore case",
detail: "Makes the whole expression case-insensitive.",
},
global: {
title: "Global search",
detail:
"Retain the index of the last match, allowing iterative searches.",
},
multiline: {
title: "Multiline",
detail:
"Beginning/end anchors (^/$) will match the start/end of a line.",
},
unicode: {
title: "Unicode",
detail: "Enables \\x{FFFFF} unicode escapes.",
},
sticky: {
title: "Sticky",
detail:
"The expression will only match from its lastIndex position and ignores the global (g) flag if set.",
},
dotall: {
title: "Dot all",
detail:
"Dot (.) will match any character, including newline.",
},
extended: {
title: "Extended",
detail:
"Literal whitespace characters are ignored, except in character sets.",
},
ungreedy: {
title: "Ungreedy",
detail: "Makes quantifiers ungreedy (lazy) by default.",
},
},
misc: {
label: "Miscellaneous",
desc: "No overview available.",
ignorews: {
title: "Ignored whitespace",
detail:
"Whitespace character ignored due to the extended flag or mode.",
},
extnumref: {
title: "Numeric reference",
detail: "Matches the results of capture group #{{group.num}}.",
},
char: {
title: "Character",
detail:
"Matches a {{getChar()}} character (char code {{code}}). {{getInsensitive()}}",
},
escchar: {
title: "Escaped character",
detail: "Matches a {{getChar()}} character (char code {{code}}).",
},
open: {
title: "Open",
detail: "Indicates the start of a regular expression.",
},
close: {
title: "Close",
detail:
"Indicates the end of a regular expression and the start of expression flags.",
},
condition: {
title: "Condition",
detail:
"The lookaround to match in resolving the enclosing conditional statement. See 'conditional' in the Reference for info.",
},
conditionalelse: {
title: "Conditional else",
detail: "Delimits the 'else' portion of the conditional.",
},
ERROR: {
title: "Error",
detail:
"Errors in the expression are underlined in red. Roll over errors for more info.",
},
PREG_INTERNAL_ERROR: {
title: "Internal error",
detail: "Internal PCRE error",
},
PREG_BACKTRACK_LIMIT_ERROR: {
title: "Backtrack limit error",
detail: "Backtrack limit was exhausted.",
},
PREG_RECURSION_LIMIT_ERROR: {
title: "Recursion limit error",
detail: "Recursion limit was exhausted",
},
PREG_BAD_UTF8_ERROR: {
title: "Bad UTF8 error",
detail: "Malformed UTF-8 data",
},
PREG_BAD_UTF8_OFFSET_ERROR: {
title: "Bad UTF8 offset error",
detail: "Malformed UTF-8 data",
},
any: {
title: "Any",
detail: "No overview available.",
},
assigned: {
title: "Assigned",
detail: "No overview available.",
},
ascii: {
title: "Unicode property",
detail: "Matches any characters in the ASCII script extension.",
},
},
errors: {
groupopen: "Unmatched opening parenthesis.",
groupclose: "Unmatched closing parenthesis.",
setopen: "Unmatched opening square bracket.",
rangerev:
"Range values reversed. Start char code is greater than end char code.",
quanttarg: "Invalid target for quantifier.",
quantrev: "Quantifier minimum is greater than maximum.",
esccharopen: "Dangling backslash.",
esccharbad: "Unrecognized or malformed escape character.",
unicodebad: "Unrecognized unicode category or script.",
posixcharclassbad: "Unrecognized POSIX character class.",
posixcharclassnoset: "POSIX character class must be in a character set.",
notsupported:
'The "{{~getLabel()}}" feature is not supported in this flavor of RegEx.',
fwdslash:
"Unescaped forward slash. This may cause issues if copying/pasting this expression into code.",
esccharbad: "Invalid escape sequence.",
servercomm: "An error occurred while communicating with the server.",
extraelse: "Extra else in conditional group.",
unmatchedref: 'Reference to non-existent group "{{name}}".',
modebad: 'Unrecognized mode flag "{{errmode}}".',
badname: "Group name can not start with a digit.",
dupname: "Duplicate group name.",
branchreseterr:
"Branch Reset. Results will be ok, but RegExr's parser does not number branch reset groups correctly. Coming soon!",
timeout: "The expression took longer than 250ms to execute.", // TODO: can we couple this to the help content somehow?
// warnings:
jsfuture:
'The "{{~getLabel()}}" feature may not be supported in all browsers.',
infinite:
"The expression can return empty matches, and may match infinitely in some use cases.", // TODO: can we couple this to the help content somehow?
},
empty: {
empty: {
title: "Empty",
detail: "No overview available.",
},
},
};
================================================
FILE: Public/js/misc/icons.js
================================================
"use strict";
import { config, library, dom } from "@fortawesome/fontawesome-svg-core";
import {
faFlag,
faOctagonXmark,
faStethoscope,
faHeart,
faBackwardStep,
faForwardStep,
faCaretLeft,
faCaretRight,
} from "@fortawesome/pro-solid-svg-icons";
import {
faAt,
faCheck,
faCommentAltSmile,
} from "@fortawesome/pro-regular-svg-icons";
import { faMonitorHeartRate } from "@fortawesome/pro-light-svg-icons";
import { faSwift, faGithub } from "@fortawesome/free-brands-svg-icons";
config.searchPseudoElements = true;
library.add(
faFlag,
faOctagonXmark,
faStethoscope,
faHeart,
faBackwardStep,
faForwardStep,
faCaretLeft,
faCaretRight,
faAt,
faCheck,
faCommentAltSmile,
faMonitorHeartRate,
faSwift,
faGithub
);
dom.watch();
================================================
FILE: Public/js/misc/utils.js
================================================
"use strict";
const Utils = {};
export default Utils;
Utils.copy = function (target, source) {
for (let n in source) {
target[n] = source[n];
}
return target;
};
Utils.clone = function (o) {
// this seems hacky, but it's the fastest, easiest approach for now:
return JSON.parse(JSON.stringify(o));
};
Utils.htmlSafe = function (str) {
return str == null
? ""
: ("" + str).replace(/&/g, "&").replace(/ 0 && str.length > length;
if (b) {
str = str.substr(0, length - 1);
}
if (htmlSafe) {
str = Utils.htmlSafe(str);
}
return !b
? str
: str + (tag && "<" + tag + ">") + "\u2026" + (tag && "");
};
Utils.unescSubstStr = function (str) {
if (!str) {
return "";
}
return str.replace(
Utils.SUBST_ESC_RE,
(a, b, c) =>
Utils.SUBST_ESC_CHARS[b] || String.fromCharCode(parseInt(c, 16))
);
};
Utils.getRegExp = function (str) {
// returns a JS RegExp object.
let match = str.match(/^\/(.+)\/([a-z]+)?$/),
regex = null;
try {
regex = match ? new RegExp(match[1], match[2] || "") : new RegExp(str, "g");
} catch (e) {}
return regex;
};
Utils.decomposeRegEx = function (str, delim = "/") {
let re = new RegExp("^" + delim + "(.*)" + delim + "([igmsuUxy]*)$");
let match = re.exec(str);
if (match) {
return { source: match[1], flags: match[2] };
} else {
return { source: str, flags: "g" };
}
};
Utils.isMac = function () {
return !!navigator.userAgent.match(/Mac\sOS/i);
};
Utils.getCtrlKey = function () {
return Utils.isMac() ? "cmd" : "ctrl";
};
Utils.now = function () {
return window.performance ? performance.now() : Date.now();
};
Utils.getUrlParams = function () {
let match,
re = /([^&=]+)=?([^&]*)/g,
params = {};
let url = window.location.search.substr(1).replace(/\+/g, " ");
while ((match = re.exec(url))) {
params[decodeURIComponent(match[1])] = decodeURIComponent(match[2]);
}
return params;
};
let deferIds = {};
Utils.defer = function (f, id, t = 1) {
clearTimeout(deferIds[id]);
if (f === null) {
delete deferIds[id];
return;
}
deferIds[id] = setTimeout(() => {
delete deferIds[id];
f();
}, t);
};
Utils.getHashCode = function (s) {
let hash = 0,
l = s.length,
i;
for (i = 0; i < l; i++) {
hash = ((hash << 5) - hash + s.charCodeAt(i)) | 0;
}
return hash;
};
Utils.getPatternURL = function (pattern) {
let a = Utils.isLocal ? "?id=" : "/";
let url = window.location.origin,
id = (pattern && pattern.id) || "";
return url + a + id;
};
Utils.isLocal = window.location.hostname === "localhost";
Utils.getPatternURLStr = function (pattern) {
if (!pattern || !pattern.id) {
return null;
}
let a = Utils.isLocal ? "?id=" : "/";
let url = window.location.host,
id = pattern.id;
return url + a + id;
};
Utils.SUBST_ESC_CHARS = {
// this is just the list supported in Replace. Others: b, f, ", etc.
n: "\n",
r: "\r",
t: "\t",
"\\": "\\",
};
Utils.SUBST_ESC_RE = /\\([nrt\\]|u([A-Z0-9]{4}))/gi;
================================================
FILE: Public/js/runner.js
================================================
"use strict";
import ReconnectingWebSocket from "reconnecting-websocket";
export class Runner {
constructor() {
this.connection = this.createConnection(this.endpoint());
this.onconnect = () => {};
this.onready = () => {};
this.onresponse = () => {};
}
get isReady() {
return this.connection.readyState === 1;
}
run(request) {
const encoder = new TextEncoder();
this.connection.send(encoder.encode(JSON.stringify(request)));
}
createConnection(endpoint) {
if (
this.connection &&
(this.connection.readyState === 0 || this.connection.readyState === 1)
) {
return this.connection;
}
const connection = new ReconnectingWebSocket(endpoint, [], {
maxReconnectionDelay: 10000,
minReconnectionDelay: 1000,
reconnectionDelayGrowFactor: 1.3,
connectionTimeout: 10000,
maxRetries: Infinity,
debug: false,
});
connection.bufferType = "arraybuffer";
connection.onopen = () => {
this.onconnect();
this.onready();
};
connection.onerror = (event) => {
connection.close();
};
connection.onmessage = (event) => {
if (event.data.trim()) {
this.onresponse(JSON.parse(event.data));
}
};
return connection;
}
endpoint() {
let endpoint;
if (window.location.protocol === "https:") {
endpoint = "wss:";
} else {
endpoint = "ws:";
}
endpoint += "//" + window.location.host;
endpoint += window.location.pathname + "api/ws";
return endpoint;
}
}
================================================
FILE: Public/js/state/decoder.js
================================================
"use strict";
import { ungzip } from "pako";
export class Decoder {
static decode(string) {
const base64 = decodeURIComponent(string);
const gziped = Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
const json = ungzip(gziped, { to: "string" });
return JSON.parse(json);
}
}
================================================
FILE: Public/js/state/encoder.js
================================================
"use strict";
import { gzip } from "pako";
export class Encoder {
static encode(data) {
const json = JSON.stringify(data);
const gziped = gzip(json);
const base64 = btoa(String.fromCharCode(...gziped));
return encodeURIComponent(base64);
}
}
================================================
FILE: Public/js/state/worker.js
================================================
"use strict";
import { Decoder } from "./decoder.js";
import { Encoder } from "./encoder.js";
onmessage = (e) => {
if (!e.data || !e.data.type || !e.data.value) {
return;
}
switch (e.data.type) {
case "decode": {
const searchParams = new URLSearchParams(e.data.value);
const query = Object.fromEntries(searchParams.entries());
if (!query.s) {
return;
}
try {
const data = Decoder.decode(query.s);
if (!data) {
return;
}
const pattern = data.p;
const options = data.o;
const text1 = data.t1;
const builder = data.b;
const text2 = data.t2;
postMessage({
type: e.data.type,
value: {
pattern,
options,
text1,
builder,
text2,
},
});
} catch (error) {}
break;
}
case "encode": {
postMessage({
type: e.data.type,
value: `?s=${Encoder.encode({
p: e.data.value.pattern,
o: e.data.value.options,
t1: e.data.value.text1,
b: e.data.value.builder,
t2: e.data.value.text2,
})}`,
});
break;
}
}
};
================================================
FILE: Public/js/views/debugger_highlighter.js
================================================
"use strict";
import Editor from "./editor";
export default class DebuggerHighlighter {
constructor(editor) {
this.editor = editor;
this.activeMarks = [];
this.widgets = [];
}
draw(traces, backtrack) {
this.clear();
const editor = this.editor;
editor.operation(() => {
const doc = editor.getDoc();
const marks = this.activeMarks;
const defaultTextHeight = editor.defaultTextHeight();
for (const trace of traces) {
const className = "debuggermatch";
if (trace.location.start !== trace.location.end) {
const location = Editor.calcRangePos(
this.editor,
trace.location.start,
trace.location.end - trace.location.start
);
marks.push(
doc.markText(location.startPos, location.endPos, {
className: className,
})
);
} else {
const pos = doc.posFromIndex(trace.location.start);
const widget = document.createElement("span");
widget.className = className;
widget.style.height = `${defaultTextHeight * 1.5}px`;
widget.style.width = "1px";
widget.style.zIndex = "10";
this.editor.addWidget(pos, widget);
const coords = editor.charCoords(pos, "local");
widget.style.left = `${coords.left}px`;
widget.style.top = `${coords.top + 2}px`;
this.widgets.push(widget);
}
}
if (backtrack) {
const pos = doc.posFromIndex(backtrack.start);
const widget = document.createElement("span");
widget.className = "debuggerbacktrack";
widget.style.height = `${defaultTextHeight * 1.5}px`;
widget.style.width = `${editor.defaultCharWidth()}px`;
widget.style.zIndex = "10";
this.editor.addWidget(pos, widget);
const coords = editor.charCoords(pos, "local");
widget.style.left = `${coords.left}px`;
widget.style.top = `${coords.top + 2}px`;
this.widgets.push(widget);
}
});
}
clear() {
this.editor.operation(() => {
let marks = this.activeMarks;
for (var i = 0, l = marks.length; i < l; i++) {
marks[i].clear();
}
marks.length = 0;
for (const widget of this.widgets) {
widget.parentNode.removeChild(widget);
}
this.widgets.length = 0;
});
}
}
================================================
FILE: Public/js/views/debugger_text.js
================================================
"use strict";
import Editor from "./editor";
import DebuggerHighlighter from "./debugger_highlighter";
export class DebuggerText {
constructor(container) {
this.container = container;
this.init(container);
}
get value() {
return this.editor.getValue();
}
set value(val) {
this.editor.setValue(val);
}
init(container) {
const editor = Editor.create(
container,
{
lineWrapping: true,
screenReaderLabel: "Debugger Test View",
readOnly: true,
},
"100%",
"100%"
);
this.editor = editor;
this.highlighter = new DebuggerHighlighter(editor);
}
}
================================================
FILE: Public/js/views/dsl_editor.js
================================================
"use strict";
import { EventDispatcher } from "@createjs/easeljs";
import Editor from "./editor";
import ErrorMessage from "./error_message";
import Utils from "../misc/utils";
const defaultValue = `Regex {
Capture {
ChoiceOf {
"CREDIT"
"DEBIT"
}
}
OneOrMore(.whitespace)
Capture {
Regex {
Repeat(1...2) {
One(.digit)
}
"/"
Repeat(1...2) {
One(.digit)
}
"/"
Repeat(count: 4) {
One(.digit)
}
}
}
}
`;
export class DSLEditor extends EventDispatcher {
static defaultValue = defaultValue;
constructor(container) {
super();
this.container = container;
this.init(container);
}
get value() {
return this.editor.getValue();
}
set value(val) {
this.editor.setValue(val);
}
set error(error) {
const editor = this.editor;
const widgets = this.widgets;
editor.operation(function () {
for (const widget of widgets) {
editor.removeLineWidget(widget);
}
widgets.length = 0;
if (!error) {
return;
}
widgets.push(
editor.addLineWidget(0, ErrorMessage.create(error), {
coverGutter: false,
noHScroll: true,
above: true,
})
);
});
}
init(container) {
this.editor = Editor.create(
container,
{
lineNumbers: true,
lineWrapping: false,
matchBrackets: true,
mode: "swift",
screenReaderLabel: "Build DSL Editor",
},
"100%",
"100%"
);
this.editor.setValue(defaultValue);
this.editor.setCursor(this.editor.lineCount(), 0);
this.editor.on("change", (editor, event) =>
this.onEditorChange(editor, event)
);
this.widgets = [];
}
setDefaultValue() {
this.editor.setValue(defaultValue);
}
deferUpdate() {
Utils.defer(() => this.update(), "DSLEditor.update");
}
update() {
this.dispatchEvent("change");
}
onEditorChange(editor, event) {
this.deferUpdate();
}
}
================================================
FILE: Public/js/views/dsl_highlighter.js
================================================
"use strict";
import { EventDispatcher } from "@createjs/easeljs";
import Editor from "./editor";
export class DSLHighlighter extends EventDispatcher {
constructor(editor) {
super();
this.editor = editor;
this.activeMarks = [];
}
clear() {
this.editor.operation(() => {
let marks = this.activeMarks;
for (var i = 0, l = marks.length; i < l; i++) {
marks[i].clear();
}
marks.length = 0;
});
}
draw(tokens) {
const editor = this.editor;
this.clear();
editor.operation(() => {
const doc = editor.getDoc();
const marks = this.activeMarks;
for (const token of tokens) {
const className = "highlight";
const location = Editor.calcRangePos(
this.editor,
token.sourceLocation.start,
token.sourceLocation.end - token.sourceLocation.start
);
marks.push(
doc.markText(location.startPos, location.endPos, {
className: className,
})
);
}
});
}
}
================================================
FILE: Public/js/views/dsl_view.js
================================================
"use strict";
import { EventDispatcher } from "@createjs/easeljs";
import Editor from "./editor";
import ErrorMessage from "./error_message";
export class DSLView extends EventDispatcher {
constructor(container) {
super();
this.container = container;
this.init(container);
}
get value() {
return this.editor.getValue();
}
set value(val) {
this.editor.setValue(val);
}
set error(error) {
const editor = this.editor;
const widgets = this.widgets;
editor.operation(function () {
for (const widget of widgets) {
editor.removeLineWidget(widget);
}
widgets.length = 0;
if (!error) {
return;
}
if (typeof error === "string" || error instanceof String) {
widgets.push(
editor.addLineWidget(0, ErrorMessage.create(error), {
coverGutter: false,
noHScroll: true,
above: true,
}),
);
} else {
for (const e of error) {
const message = ErrorMessage.create(e.message);
widgets.push(
editor.addLineWidget(0, message, {
coverGutter: false,
noHScroll: true,
above: true,
}),
);
}
}
});
}
init(container) {
this.editor = Editor.create(
container,
{
lineNumbers: true,
lineWrapping: false,
matchBrackets: true,
mode: "swift",
readOnly: true,
screenReaderLabel: "Build DSL View",
},
"100%",
"100%",
);
this.widgets = [];
}
}
================================================
FILE: Public/js/views/editor.js
================================================
"use strict";
import CodeMirror from "codemirror";
import "codemirror/mode/swift/swift";
import Utils from "../misc/utils";
const Editor = {};
export default Editor;
Editor.create = (target, opts = {}, width = "100%", height = "100%") => {
const keys = {};
const o = Utils.copy(
{
extraKeys: keys,
indentWithTabs: false,
lineNumbers: false,
mode: "null",
specialChars:
/[ \u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b-\u200f\u2028\u2029\ufeff]/,
specialCharPlaceholder: (ch) =>
createElement("span", ch === " " ? "cm-space" : "cm-special", " "), // needs to be a space so wrapping works
tabSize: 2,
},
opts,
);
const cm = CodeMirror(target, o);
cm.setSize(width, height);
if (cm.getOption("maxLength")) {
cm.on("beforeChange", Editor.enforceMaxLength);
}
if (cm.getOption("singleLine")) {
cm.on("beforeChange", Editor.enforceSingleLine);
}
return cm;
};
Editor.enforceMaxLength = (cm, change) => {
let maxLength = cm.getOption("maxLength");
if (maxLength && change.update) {
let str = change.text.join("\n");
let delta =
str.length - (cm.indexFromPos(change.to) - cm.indexFromPos(change.from));
if (delta <= 0) {
return true;
}
delta = cm.getValue().length + delta - maxLength;
if (delta > 0) {
str = str.substr(0, str.length - delta);
change.update(change.from, change.to, str.split("\n"));
}
}
return true;
};
Editor.enforceSingleLine = (cm, change) => {
if (change.update) {
let str = change.text.join("").replace(/(\n|\r)/g, "");
change.update(change.from, change.to, [str]);
}
return true;
};
Editor.selectAll = (cm) => {
cm.focus();
cm.setSelection({ ch: 0, line: 0 }, { ch: 0, line: cm.lineCount() });
};
Editor.calcRangePos = (cm, i, l = 0, o = {}) => {
let doc = cm.getDoc();
o.startPos = doc.posFromIndex(i);
o.endPos = doc.posFromIndex(i + l);
return o;
};
function createElement(type, className, content, parent) {
let element = document.createElement(type || "div");
if (className) {
element.className = className;
}
if (content) {
if (content instanceof HTMLElement) {
element.appendChild(content);
} else {
element.innerHTML = content;
}
}
if (parent) {
parent.appendChild(element);
}
return element;
}
================================================
FILE: Public/js/views/error_message.js
================================================
"use strict";
const ErrorMessage = {};
export default ErrorMessage;
ErrorMessage.create = (message) => {
const container = document.createElement("div");
container.classList.add("error-message", "d-flex", "flex-row");
const wrapper = document.createElement("div");
wrapper.classList.add("d-flex", "flex-row", "overflow-hidden", "w-100");
container.appendChild(wrapper);
const iconWrapper = document.createElement("div");
wrapper.appendChild(iconWrapper);
const icon = document.createElement("span");
icon.classList.add(
"fa-solid",
"fa-octagon-xmark",
"fa-xs",
"text-danger",
"px-2",
);
iconWrapper.appendChild(icon);
const messageWrapper = document.createElement("div");
messageWrapper.classList.add("text-nowrap");
messageWrapper.textContent = message;
wrapper.appendChild(messageWrapper);
return container;
};
================================================
FILE: Public/js/views/expression_field.js
================================================
"use strict";
import { EventDispatcher } from "@createjs/easeljs";
import tippy from "tippy.js";
import Editor from "./editor";
import ExpressionHighlighter from "./expression_highlighter";
import Utils from "../misc/utils";
export class ExpressionField extends EventDispatcher {
constructor(container) {
super();
this.container = container;
this.init(container);
}
get value() {
return this.editor.getValue();
}
set value(val) {
this.editor.setValue(val);
}
set tokens(tokens) {
this.expressionTokens = tokens;
this.highlighter.draw(tokens);
this.resetTooltips();
}
set error(error) {
if (error.length) {
let message = "";
if (typeof error === "string" || error instanceof String) {
const errorMessage = Utils.htmlSafe(error);
message = `Parse Error: ${errorMessage}`;
} else {
message = error
.map((e) => {
const errorMessage = Utils.htmlSafe(e.message);
return `${e.behavior}: ${errorMessage}`;
})
.join("
https://swiftregex.com
================================================
FILE: SECURITY.md
================================================
# Security Policy
For security related problems, please don't use the public issue tracker, but email [@kishikawakatsumi](https://github.com/kishikawakatsumi).
================================================
FILE: Sources/App/Debugger/Context.swift
================================================
import Foundation
extension Debugger {
class Context {
var instructions: [String] = []
var programCounter = 0
var stepCount = 0
var breakPoint: Int?
var start: Int = 0
var current: Int = 0
var failurePosition: Int = 0
var totalCycleCount = 0
var resets = 0
var backtracks = 0
init(stepCount: Int = 0, breakPoint: Int? = nil) {
self.stepCount = stepCount
self.breakPoint = breakPoint
}
func reset() {
instructions = []
programCounter = 0
stepCount = 0
breakPoint = nil
start = 0
current = 0
failurePosition = 0
totalCycleCount = 0
resets = 0
backtracks = 0
}
}
}
================================================
FILE: Sources/App/Debugger/Debugger.swift
================================================
import Foundation
@testable import _RegexParser
@testable @_spi(RegexBenchmark) import _StringProcessing
struct Debugger {
func run(pattern: String, text: String, matchingOptions: [String] = [], context: Debugger.Context) throws {
let ast = try _RegexParser.parse(pattern, .traditional)
var sequence = [AST.MatchingOption]()
if matchingOptions.contains("i") {
sequence.append(.init(.caseInsensitive, location: .fake))
}
if matchingOptions.contains("s") {
sequence.append(.init(.singleLine, location: .fake))
}
if matchingOptions.contains("asciiOnlyWordCharacters") {
sequence.append(.init(.asciiOnlyWord, location: .fake))
}
if matchingOptions.contains("asciiOnlyDigits") {
sequence.append(.init(.asciiOnlyDigit, location: .fake))
}
if matchingOptions.contains("asciiOnlyWhitespace") {
sequence.append(.init(.asciiOnlySpace, location: .fake))
}
if matchingOptions.contains("asciiOnlyCharacterClasses") {
sequence.append(.init(.asciiOnlyPOSIXProps, location: .fake))
}
sequence.append(.init(.graphemeClusterSemantics, location: .fake))
var options = MatchingOptions()
options.apply(AST.MatchingOptionSequence(adding: sequence))
let program = try compile(ast, options: options)
context.instructions = program.instructions.map {
$0.description
}
let inputRange = text.startIndex..