*
* myObject.addEventListener("change", createjs.proxy(myMethod, scope));
*
* @module CreateJS
* @main CreateJS
*/
/**
* Contains properties and methods shared by all events for use with
* {{#crossLink "EventDispatcher"}}{{/crossLink}}.
*
* Note that Event objects are often reused, so you should never
* rely on an event object's state outside of the call stack it was received in.
* @class Event
* @param {String} type The event type.
* @param {Boolean} bubbles Indicates whether the event will bubble through the display list.
* @param {Boolean} cancelable Indicates whether the default behaviour of this event can be cancelled.
* @constructor
**/
class Event {
constructor(type, bubbles, cancelable) {
// public properties:
/**
* The type of event.
* @property type
* @type String
**/
this.type = type;
/**
* The object that generated an event.
* @property target
* @type Object
* @default null
* @readonly
*/
this.target = null;
/**
* The current target that a bubbling event is being dispatched from. For non-bubbling events, this will
* always be the same as target. For example, if childObj.parent = parentObj, and a bubbling event
* is generated from childObj, then a listener on parentObj would receive the event with
* target=childObj (the original target) and currentTarget=parentObj (where the listener was added).
* @property currentTarget
* @type Object
* @default null
* @readonly
*/
this.currentTarget = null;
/**
* For bubbling events, this indicates the current event phase:
*
capture phase: starting from the top parent to the target
*
at target phase: currently being dispatched from the target
*
bubbling phase: from the target to the top parent
*
* @property eventPhase
* @type Number
* @default 0
* @readonly
*/
this.eventPhase = 0;
/**
* Indicates whether the event will bubble through the display list.
* @property bubbles
* @type Boolean
* @default false
* @readonly
*/
this.bubbles = !!bubbles;
/**
* Indicates whether the default behaviour of this event can be cancelled via
* {{#crossLink "Event/preventDefault"}}{{/crossLink}}. This is set via the Event constructor.
* @property cancelable
* @type Boolean
* @default false
* @readonly
*/
this.cancelable = !!cancelable;
/**
* The epoch time at which this event was created.
* @property timeStamp
* @type Number
* @default 0
* @readonly
*/
this.timeStamp = new Date().getTime();
/**
* Indicates if {{#crossLink "Event/preventDefault"}}{{/crossLink}} has been called
* on this event.
* @property defaultPrevented
* @type Boolean
* @default false
* @readonly
*/
this.defaultPrevented = false;
/**
* Indicates if {{#crossLink "Event/stopPropagation"}}{{/crossLink}} or
* {{#crossLink "Event/stopImmediatePropagation"}}{{/crossLink}} has been called on this event.
* @property propagationStopped
* @type Boolean
* @default false
* @readonly
*/
this.propagationStopped = false;
/**
* Indicates if {{#crossLink "Event/stopImmediatePropagation"}}{{/crossLink}} has been called
* on this event.
* @property immediatePropagationStopped
* @type Boolean
* @default false
* @readonly
*/
this.immediatePropagationStopped = false;
/**
* Indicates if {{#crossLink "Event/remove"}}{{/crossLink}} has been called on this event.
* @property removed
* @type Boolean
* @default false
* @readonly
*/
this.removed = false;
}
// public methods:
/**
* Sets {{#crossLink "Event/defaultPrevented"}}{{/crossLink}} to true if the event is cancelable.
* Mirrors the DOM level 2 event standard. In general, cancelable events that have `preventDefault()` called will
* cancel the default behaviour associated with the event.
* @method preventDefault
**/
preventDefault() {
this.defaultPrevented = this.cancelable && true;
}
/**
* Sets {{#crossLink "Event/propagationStopped"}}{{/crossLink}} to true.
* Mirrors the DOM event standard.
* @method stopPropagation
**/
stopPropagation() {
this.propagationStopped = true;
}
/**
* Sets {{#crossLink "Event/propagationStopped"}}{{/crossLink}} and
* {{#crossLink "Event/immediatePropagationStopped"}}{{/crossLink}} to true.
* Mirrors the DOM event standard.
* @method stopImmediatePropagation
**/
stopImmediatePropagation() {
this.immediatePropagationStopped = this.propagationStopped = true;
}
/**
* Causes the active listener to be removed via removeEventListener();
*
* myBtn.addEventListener("click", function(evt) {
* // do stuff...
* evt.remove(); // removes this listener.
* });
*
* @method remove
**/
remove() {
this.removed = true;
}
/**
* Returns a clone of the Event instance.
* @method clone
* @return {Event} a clone of the Event instance.
**/
clone() {
return new Event(this.type, this.bubbles, this.cancelable);
}
/**
* Provides a chainable shortcut method for setting a number of properties on the instance.
*
* @method set
* @param {Object} props A generic object containing properties to copy to the instance.
* @return {Event} Returns the instance the method is called on (useful for chaining calls.)
* @chainable
*/
set(props) {
for (let n in props) {
this[n] = props[n];
}
return this;
}
/**
* Returns a string representation of this object.
* @method toString
* @return {String} a string representation of the instance.
**/
toString() {
return "[Event (type=" + this.type + ")]";
}
}
/*
* EventDispatcher
* Visit http://createjs.com/ for documentation, updates and examples.
*
* Copyright (c) 2010 gskinner.com, inc.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
class EventDispatcher {
constructor() {
// private properties:
/**
* @protected
* @property _listeners
* @type Object
**/
this._listeners = null;
/**
* @protected
* @property _captureListeners
* @type Object
**/
this._captureListeners = null;
/**
* A shortcut to the removeEventListener method, with the same parameters and return value. This is a companion to the
* .on method.
*
* IMPORTANT: To remove a listener added with `on`, you must pass in the returned wrapper function as the listener. See
* {{#crossLink "EventDispatcher/on"}}{{/crossLink}} for an example.
*
* @method off
* @param {String} type The string type of the event.
* @param {Function | Object} listener The listener function or object.
* @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase.
**/
this.off = this.removeEventListener;
}
// static public methods:
/**
* Static initializer to mix EventDispatcher methods into a target object or prototype.
*
* EventDispatcher.initialize(MyClass.prototype); // add to the prototype of the class
* EventDispatcher.initialize(myObject); // add to a specific instance
*
* @method initialize
* @static
* @param {Object} target The target object to inject EventDispatcher methods into. This can be an instance or a
* prototype.
**/
static EventDispatcher(target) {
target.addEventListener = p.addEventListener;
target.on = p.on;
target.removeEventListener = target.off = p.removeEventListener;
target.removeAllEventListeners = p.removeAllEventListeners;
target.hasEventListener = p.hasEventListener;
target.dispatchEvent = p.dispatchEvent;
target._dispatchEvent = p._dispatchEvent;
target.willTrigger = p.willTrigger;
}
// public methods:
/**
* Adds the specified event listener. Note that adding multiple listeners to the same function will result in
* multiple callbacks getting fired.
*
*
Example
*
* displayObject.addEventListener("click", handleClick);
* function handleClick(event) {
* // Click happened.
* }
*
* @method addEventListener
* @param {String} type The string type of the event.
* @param {Function | Object} listener An object with a handleEvent method, or a function that will be called when
* the event is dispatched.
* @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase.
* @return {Function | Object} Returns the listener for chaining or assignment.
**/
addEventListener(type, listener, useCapture) {
let listeners;
if (useCapture) {
listeners = this._captureListeners = this._captureListeners || {};
} else {
listeners = this._listeners = this._listeners || {};
}
let arr = listeners[type];
if (arr) {
this.removeEventListener(type, listener, useCapture);
}
arr = listeners[type]; // remove may have deleted the array
if (!arr) {
listeners[type] = [listener];
} else {
arr.push(listener);
}
return listener;
}
/**
* A shortcut method for using addEventListener that makes it easier to specify an execution scope, have a listener
* only run once, associate arbitrary data with the listener, and remove the listener.
*
* This method works by creating an anonymous wrapper function and subscribing it with addEventListener.
* The wrapper function is returned for use with `removeEventListener` (or `off`).
*
* IMPORTANT: To remove a listener added with `on`, you must pass in the returned wrapper function as the listener, or use
* {{#crossLink "Event/remove"}}{{/crossLink}}. Likewise, each time you call `on` a NEW wrapper function is subscribed, so multiple calls
* to `on` with the same params will create multiple listeners.
*
*
Example
*
* var listener = myBtn.on("click", handleClick, null, false, {count:3});
* function handleClick(evt, data) {
* data.count -= 1;
* console.log(this == myBtn); // true - scope defaults to the dispatcher
* if (data.count == 0) {
* alert("clicked 3 times!");
* myBtn.off("click", listener);
* // alternately: evt.remove();
* }
* }
*
* @method on
* @param {String} type The string type of the event.
* @param {Function | Object} listener An object with a handleEvent method, or a function that will be called when
* the event is dispatched.
* @param {Object} [scope] The scope to execute the listener in. Defaults to the dispatcher/currentTarget for function listeners, and to the listener itself for object listeners (ie. using handleEvent).
* @param {Boolean} [once=false] If true, the listener will remove itself after the first time it is triggered.
* @param {*} [data] Arbitrary data that will be included as the second parameter when the listener is called.
* @param {Boolean} [useCapture=false] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase.
* @return {Function} Returns the anonymous function that was created and assigned as the listener. This is needed to remove the listener later using .removeEventListener.
**/
on(type, listener, scope, once, data, useCapture) {
if (listener.handleEvent) {
scope = scope || listener;
listener = listener.handleEvent;
}
scope = scope || this;
return this.addEventListener(type, function (evt) {
listener.call(scope, evt, data);
once && evt.remove();
}, useCapture);
}
/**
* Removes the specified event listener.
*
* Important Note: that you must pass the exact function reference used when the event was added. If a proxy
* function, or function closure is used as the callback, the proxy/closure reference must be used - a new proxy or
* closure will not work.
*
*
Example
*
* displayObject.removeEventListener("click", handleClick);
*
* @method removeEventListener
* @param {String} type The string type of the event.
* @param {Function | Object} listener The listener function or object.
* @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase.
**/
removeEventListener(type, listener, useCapture) {
let listeners = useCapture ? this._captureListeners : this._listeners;
if (!listeners) {
return;
}
let arr = listeners[type];
if (!arr) {
return;
}
for (let i = 0, l = arr.length; i < l; i++) {
if (arr[i] === listener) {
if (l == 1) {
delete listeners[type];
} // allows for faster checks.
else {
arr.splice(i, 1);
}
break;
}
}
}
/**
* Removes all listeners for the specified type, or all listeners of all types.
*
*
Example
*
* // Remove all listeners
* displayObject.removeAllEventListeners();
*
* // Remove all click listeners
* displayObject.removeAllEventListeners("click");
*
* @method removeAllEventListeners
* @param {String} [type] The string type of the event. If omitted, all listeners for all types will be removed.
**/
removeAllEventListeners(type) {
if (!type) {
this._listeners = this._captureListeners = null;
} else {
if (this._listeners) {
delete this._listeners[type];
}
if (this._captureListeners) {
delete this._captureListeners[type];
}
}
}
/**
* Dispatches the specified event to all listeners.
*
*
Example
*
* // Use a string event
* this.dispatchEvent("complete");
*
* // Use an Event instance
* var event = new Event("progress");
* this.dispatchEvent(event);
*
* @method dispatchEvent
* @param {Object | String | Event} eventObj An object with a "type" property, or a string type.
* While a generic object will work, it is recommended to use a CreateJS Event instance. If a string is used,
* dispatchEvent will construct an Event instance if necessary with the specified type. This latter approach can
* be used to avoid event object instantiation for non-bubbling events that may not have any listeners.
* @param {Boolean} [bubbles] Specifies the `bubbles` value when a string was passed to eventObj.
* @param {Boolean} [cancelable] Specifies the `cancelable` value when a string was passed to eventObj.
* @return {Boolean} Returns false if `preventDefault()` was called on a cancelable event, true otherwise.
**/
dispatchEvent(eventObj, bubbles, cancelable) {
if (typeof eventObj == "string") {
// skip everything if there's no listeners and it doesn't bubble:
let listeners = this._listeners;
if (!bubbles && (!listeners || !listeners[eventObj])) {
return true;
}
eventObj = new Event(eventObj, bubbles, cancelable);
} else if (eventObj.target && eventObj.clone) {
// redispatching an active event object, so clone it:
eventObj = eventObj.clone();
}
// TODO: it would be nice to eliminate this. Maybe in favour of evtObj instanceof Event? Or !!evtObj.createEvent
try {
eventObj.target = this;
} catch (e) {} // try/catch allows redispatching of native events
if (!eventObj.bubbles || !this.parent) {
this._dispatchEvent(eventObj, 2);
} else {
let top = this,
list = [top];
while (top.parent) {
list.push(top = top.parent);
}
let i,
l = list.length;
// capture & atTarget
for (i = l - 1; i >= 0 && !eventObj.propagationStopped; i--) {
list[i]._dispatchEvent(eventObj, 1 + (i == 0));
}
// bubbling
for (i = 1; i < l && !eventObj.propagationStopped; i++) {
list[i]._dispatchEvent(eventObj, 3);
}
}
return !eventObj.defaultPrevented;
}
/**
* Indicates whether there is at least one listener for the specified event type.
* @method hasEventListener
* @param {String} type The string type of the event.
* @return {Boolean} Returns true if there is at least one listener for the specified event.
**/
hasEventListener(type) {
let listeners = this._listeners,
captureListeners = this._captureListeners;
return !!(listeners && listeners[type] || captureListeners && captureListeners[type]);
}
/**
* Indicates whether there is at least one listener for the specified event type on this object or any of its
* ancestors (parent, parent's parent, etc). A return value of true indicates that if a bubbling event of the
* specified type is dispatched from this object, it will trigger at least one listener.
*
* This is similar to {{#crossLink "EventDispatcher/hasEventListener"}}{{/crossLink}}, but it searches the entire
* event flow for a listener, not just this object.
* @method willTrigger
* @param {String} type The string type of the event.
* @return {Boolean} Returns `true` if there is at least one listener for the specified event.
**/
willTrigger(type) {
let o = this;
while (o) {
if (o.hasEventListener(type)) {
return true;
}
o = o.parent;
}
return false;
}
/**
* @method toString
* @return {String} a string representation of the instance.
**/
toString() {
return "[EventDispatcher]";
}
// private methods:
/**
* @method _dispatchEvent
* @param {Object | Event} eventObj
* @param {Object} eventPhase
* @protected
**/
_dispatchEvent(eventObj, eventPhase) {
let l,
arr,
listeners = eventPhase <= 2 ? this._captureListeners : this._listeners;
if (eventObj && listeners && (arr = listeners[eventObj.type]) && (l = arr.length)) {
try {
eventObj.currentTarget = this;
} catch (e) {}
try {
eventObj.eventPhase = eventPhase | 0;
} catch (e) {}
eventObj.removed = false;
arr = arr.slice(); // to avoid issues with items being removed or added during the dispatch
for (let i = 0; i < l && !eventObj.immediatePropagationStopped; i++) {
let o = arr[i];
if (o.handleEvent) {
o.handleEvent(eventObj);
} else {
o(eventObj);
}
if (eventObj.removed) {
this.off(eventObj.type, o, eventPhase == 1);
eventObj.removed = false;
}
}
}
if (eventPhase === 2) {
this._dispatchEvent(eventObj, 2.1);
}
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
let DOMUtils = {},
$ = DOMUtils;
$.query = function (query, element = document.body) {
return query[0] === ">" ? $._childQuery(query, element, $.query) : element.querySelector(query);
};
$.queryAll = function (query, element = document.body) {
return query[0] === ">" ? $._childQuery(query, element, $.queryAll) : element.querySelectorAll(query);
};
$.removeClass = function (element, className) {
if ($._runOnNodeList($.removeClass, element, className)) {
return element;
}
if (className instanceof RegExp) {
let arr = (element.getAttribute("class") || "").split(" "),
re = className;
element.setAttribute("class", arr.filter(s => !re.test(s)).join(" "));
} else {
let list = element.classList;
list.remove.apply(list, className.split(" "));
}
return element;
};
$.addClass = function (element, className) {
if ($._runOnNodeList($.addClass, element, className)) {
return element;
}
$.removeClass(element, className);
let names = className.split(" ");
for (let i = 0; i < names.length; i++) {
element.classList.add(names[i]);
}
return element;
};
$.toggleClass = function (element, className, value) {
if ($._runOnNodeList($.toggleClass, element, className, value)) {
return element;
}
let curValue = $.hasClass(element, className);
if (value == null) {
value = !curValue;
} else if (value === curValue) {
return;
}
if (value) {
$.addClass(element, className);
} else {
$.removeClass(element, className);
}
};
$.hasClass = function (element, className) {
return !!(element.getAttribute("class") || "").match(new RegExp("\\b\\s?" + className + "\\b", "g"));
};
$.swapClass = function (element, oldClass, newClass) {
$.removeClass(element, oldClass);
$.addClass(element, newClass);
return element;
};
$.remove = function (element) {
if ($._runOnNodeList($.remove, element)) {
return element;
}
if (element.remove) {
element.remove();
} else if (element.parentNode) {
element.parentNode.removeChild(element);
}
return element;
};
$.on = function (element, event, listener) {
if ($._runOnNodeList($.on, element, event, listener)) {
return element;
}
element.addEventListener(event, listener);
};
$.off = function (element, event, listener) {
if ($._runOnNodeList($.off, element, event, listener)) {
return element;
}
element.removeEventListener(event, listener);
};
/*
Remove all children from an element.
When using .innerHTML = ""; IE fails when adding new dom elements via appendChild();
*/
$.empty = function (element) {
if ($._runOnNodeList($.empty, element)) {
return element;
}
while (element.firstChild) {
element.removeChild(element.firstChild);
}
return element;
};
$.create = function (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;
};
$.getEl = function (query, scope) {
if (query instanceof HTMLElement || !query) {
return query;
}
return $.query(query, scope);
};
$.togglePanel = function (element, openEl, closedEl, open) {
let el1 = $.getEl(openEl, element),
el2 = $.getEl(closedEl, element),
tmp,
isOpen = !$.hasClass(element, "closed");
if (open === undefined) {
open = !isOpen;
} else {
open = !!open;
}
if (open === isOpen) {
return;
}
if (open) {
$.removeClass(element, "closed");
tmp = el2;
el2 = el1;
el1 = tmp;
} else {
$.addClass(element, "closed");
}
el1 && (el1.style.display = "none");
if (el2) {
let f = function (evt) {
if (evt.target !== element) {
return;
}
el2.style.display = "flex";
element.removeEventListener("transitionend", f);
};
element.addEventListener("transitionend", f);
}
};
$.transition = function (target, className, then) {
let f = evt => {
if (evt.target !== target) {
return;
}
target.removeEventListener("transition", f);
then();
};
target.addEventListener("transitionend", f);
$.addClass(target, className);
};
$.template = function (strings, ...keys) {
return o => {
let result = strings[0];
for (let i = 0, l = keys.length; i < l; i++) {
result += o[keys[i]] + strings[i + 1];
}
return result;
};
};
// TODO: evaluate whether this belongs here. Feels awkward given its specific DOM dependencies.
$.getCSSValue = function (name, prop) {
let el = $.create("div", name);
el.style.display = "none";
el.id = "export";
document.body.appendChild(el);
let val = window.getComputedStyle(el).getPropertyValue(prop);
$.remove(el);
return val;
};
$._runOnNodeList = function (f, nodelist, ...rest) {
if (!nodelist) {
return true;
}
if (nodelist.length === undefined) {
return false;
}
for (let i = 0, l = nodelist.length; i < l; i++) {
f.call(DOMUtils, nodelist[i], ...rest);
}
return true;
};
$._childQuery = function (query, el, f) {
if (!el.id) {
el.id = "___tmp_id";
}
let result = f("#" + el.id + " " + query, el.parentNode);
if (el.id === "___tmp_id") {
el.id = "";
}
return result;
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
let Utils = {};
Utils.prepMenuContent = function (content, idMap) {
if (!idMap.__next_id) {
idMap.__next_id = 1;
}
let kids = content.kids;
for (let i = 0, l = kids.length; i < l; i++) {
let o = kids[i];
// current list implementation requires everything to have an id:
if (!o.id) {
o.id = "__id_" + idMap.__next_id++;
}
idMap[o.id] = o;
o.parent = content;
if (o.kids) {
Utils.prepMenuContent(o, idMap);
}
}
return content;
};
Utils.find = function (arr, f) {
for (let i = 0, l = arr.length; i < l; i++) {
if (f(arr[i])) {
return arr[i];
}
}
};
Utils.findIndex = function (arr, f) {
for (let i = 0, l = arr.length; i < l; i++) {
if (f(arr[i])) {
return i;
}
}
return -1;
};
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.searchRank = function (o, search) {
let test = Utils.searchTest;
search = search.toLowerCase();
if (o.access) {
// pattern (My Favorites).
// text? pattern?
return test((o.keywords || "") + " " + (o.name || ""), search, 16) + test((o.description || "") + " " + (o.author || ""), search, 8);
} else {
// reference.
return test(o.token, search, 16) + test((o.id || "") + " " + (o.label || ""), search, 8) + test((o.desc || "") + " " + (o.ext || ""), search, 4);
}
};
Utils.searchTest = function (str, search, weight = 1) {
return str && str.toLowerCase().indexOf(search) !== -1 ? weight : 0;
};
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.getForkName = function (name) {
let res = / ?\(fork ?(\d*)\)$/.exec(name);
if (res) {
let num = (res[1] || 1) * 1 + 1;
return name.substr(0, res.index) + " (fork " + num + ")";
}
return name + " (fork)";
};
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}))/ig;
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Tooltip {
constructor(el, transition = false) {
this.el = DOMUtils.remove(el);
this.transition = transition;
this.contentEl = DOMUtils.query(".content", el);
this.tipEl = DOMUtils.query(".tip", el);
this.hideF = evt => Date.now() > this._showT && this.handleBodyClick(evt);
this.curId = null;
}
toggle(id, content, x, y, autohide, th) {
if (id === this.curId) {
return this.hide(id);
}
this.show(id, content, x, y, autohide, th);
}
toggleOn(id, content, el, autohide, th) {
if (id === this.curId) {
return this.hide(id);
}
this.showOn(id, content, el, autohide, th);
this.toggleEl = el;
DOMUtils.addClass(el, "selected");
}
hide(id) {
if (id && this.curId !== id) {
return;
}
let el = this.el,
elStyle = el.style;
DOMUtils.empty(DOMUtils.query(".content", DOMUtils.remove(el)));
DOMUtils.removeClass(el, "flipped");
document.body.removeEventListener("mousedown", this.hideF);
if (this.toggleEl) {
DOMUtils.removeClass(this.toggleEl, "selected");
this.toggleEl = null;
}
// reset position and width so that content wrapping resolves properly:
elStyle.left = elStyle.top = "0";
elStyle.width = "";
if (this.transition) {
elStyle.opacity = 0;
elStyle.marginTop = "-0.25em";
}
this.curId = null;
}
show(id, content, x, y, autohide = false, th = 0) {
this.hide();
if (!content) {
return;
}
let el = this.el,
elStyle = el.style,
contentEl = this.contentEl,
body = document.body,
pad = 8;
if (content instanceof HTMLElement) {
contentEl.appendChild(content);
} else {
contentEl.innerHTML = content;
}
if (autohide) {
this._showT = Date.now() + 30; // ignore double clicks and events in the current stack.
body.addEventListener("mousedown", this.hideF);
}
body.appendChild(el);
let wh = window.innerHeight,
ww = window.innerWidth;
let rect = el.getBoundingClientRect(),
w = rect.right - rect.left,
h = rect.bottom - rect.top,
off = 0;
if (y + h > wh - pad) {
DOMUtils.addClass(el, "flipped");
y -= th;
}
if (x - w / 2 < pad) {
off = pad - x + w / 2;
} else if (x + w / 2 > ww - pad) {
off = ww - pad - x - w / 2;
}
this.tipEl.style.marginRight = Math.max(-w / 2 + 10, Math.min(w / 2 - 10, off)) * 2 + "px";
elStyle.width = Math.ceil(w / 2) * 2 + "px";
elStyle.top = Math.round(y) + "px";
elStyle.left = Math.round(x + off) + "px";
if (this.transition) {
elStyle.opacity = 1;
elStyle.marginTop = 0;
}
this.curId = id;
}
showOn(id, content, el, autohide, th = 0) {
let rect = el.getBoundingClientRect();
let x = Math.round((rect.left + rect.right) / 2);
let y = rect.bottom + th;
let h = rect.bottom - rect.top;
this.show(id, content, x, y, autohide, h);
}
handleBodyClick(evt) {
let id = this.curId;
if (this.el.contains(evt.target) || this.toggleEl && this.toggleEl.contains(evt.target)) {
return;
}
this.hide(id);
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Server {
// regex:
static solve(req) {
return Server._getRequest("regex/solve", {
data: JSON.stringify(req)
});
}
static version(flavor) {
return Server._getRequest("regex/version", {
flavor: flavor
});
}
// patterns:
static communitySearch(str) {
return Server._getRequest("patterns/search", {
query: str || "",
startIndex: 0,
limit: 100
}, data => {
this._processPatternList(data);
});
}
static load(id) {
return Server._getRequest("patterns/load", {
patternId: id
}, data => this._processPattern(data));
}
static save(pattern, fork, community) {
// clone and prep the pattern object:
let o = this._prepPattern(pattern, fork, community);
return Server._getRequest("patterns/save", o, data => this._processPattern(data));
}
static rate(id, rating) {
return Server._getRequest("patterns/rate", {
patternId: id,
userRating: rating
}, data => data.rating = Number(data.rating));
}
static delete(id) {
return Server._getRequest("patterns/delete", {
patternId: id
});
}
static favorite(id, value) {
return Server._getRequest("patterns/favorite", {
patternId: id,
favorite: !!value
});
}
static private(id, value) {
return Server.setAccess(id, value ? "private" : "protected");
}
static setAccess(id, value) {
return Server._getRequest("patterns/setAccess", {
patternId: id,
access: value
});
}
static multiFavorite(ids) {
return Server._getRequest("patterns/multiFavorite", {
patternIds: JSON.stringify(ids)
});
}
// account:
static login(service) {
window.location = Server.url + "?action=account/login&type=" + service;
}
static logout() {
return Server._getRequest("account/logout", {});
}
static verify() {
return Server._getRequest("account/verify", {});
}
static patterns() {
return Server._getRequest("account/patterns", {}, data => {
this._processPatternList(data);
data.results.sort((a, b) => {
return b.favorite - a.favorite || b.dateAdded - a.dateAdded || 1 - 2 * (a.id > b.id);
});
});
}
// helpers:
static _processPatternList(data) {
data.results.forEach(this._processPattern);
}
static _processPattern(o) {
// parse values:
o.rating = Number(o.rating);
o.userRating = Number(o.userRating);
o.flavor = o.flavor || "js";
o.mode = o.mode || "text";
o.text = o.text || null;
if (o.tool && o.tool.id) {
o.tool.id = o.tool.id.toLowerCase();
}
}
static _prepPattern(o, fork, community) {
o = Utils.clone(o);
if (fork) {
o.parentId = o.id;
delete o.id;
if (!community) {
o.name = Utils.getForkName(o.name);
}
}
// clear null values:
if (!o.id) {
delete o.id;
}
if (!o.parentId) {
delete o.parentId;
}
delete o.userId; // this gets added by the server
o.tool = o.tool && JSON.stringify(o.tool);
o.tests = o.tests && JSON.stringify(o.tests);
return o;
}
// private methods:
static _getRequest(action, data = {}, postprocess) {
let req = new XMLHttpRequest(),
p = new ServerPromise(req, postprocess),
params = [];
req.open("POST", Server.url);
req.setRequestHeader("Content-type", "application/x-www-form-urlencoded", true);
req.timeout = 30 * 1000;
data.action = action;
if (Server.isLocal && Server.useBeta) {
data.userId = 111;
}
for (let n in data) {
params.push(n + "=" + encodeURIComponent(data[n]));
}
if (Server.isLocal) {
console.log(data);
}
req.send(params.join("&"));
return p;
}
}
class ServerPromise {
constructor(req, postprocess) {
this._req = req;
this._postprocess = postprocess;
req.addEventListener("load", () => this._load());
req.addEventListener("timeout", evt => this._error("servercomm"));
req.addEventListener("error", evt => this._error("servercomm"));
}
then(f, cf, ff) {
this._loadF = f;
if (cf) {
this.catch(cf);
}
if (this._data) {
f(this._data);
}
if (ff) {
this.finally(ff);
}
return this;
}
catch(f) {
this._errorF = f;
if (this._err) {
f(this._err);
}
return this;
}
finally(f) {
this._finallyF = f;
if (this._complete) {
f();
}
return this;
}
abort() {
if (this._complete) {
return;
}
this._complete = true;
this._req.abort();
this._finallyF && this._finallyF();
this._loadF = this._errorF = this._finallyF = null; // just to make sure.
}
_load() {
let json;
this._complete = true;
if (Server.isLocal) {
console.log(this._req.response || this._req.responseText);
}
try {
json = JSON.parse(this._req.response || this._req.responseText);
} catch (e) {
return this._error(e);
}
if (!json.success) {
return this._error(json.data);
}
this._postprocess && this._postprocess(json.data);
this._data = json.data;
this._loadF && this._loadF(this._data);
this._finallyF && this._finallyF();
}
_error(e) {
this._err = e.data && e.data.error || e.message || e.detail || e.type || String(e);
this._errorF && this._errorF(this._err);
this._finallyF && this._finallyF();
}
}
Server.isLocal = Utils.isLocal;
Server.useBeta = Server.isLocal || window.location.hostname === "beta.regexr.com";
Server.host = "https://" + (Server.useBeta ? "beta." : "") + "regexr.com";
Server.url = Server.host + "/server/api.php";
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
let CMUtils = {};
CMUtils.create = function (target, opts = {}, width = "100%", height = "100%") {
let keys = {},
ctrlKey = Utils.getCtrlKey();
//keys[ctrlKey + "-Z"] = keys[ctrlKey + "-Y"] = keys["Shift-" + ctrlKey + "-Z"] = () => false; // block CM handling
let o = Utils.copy({
lineNumbers: false,
tabSize: 3,
indentWithTabs: true,
extraKeys: keys,
specialChars: /[ \u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b-\u200f\u2028\u2029\ufeff]/,
specialCharPlaceholder: ch => DOMUtils.create("span", ch === " " ? "cm-space" : "cm-special", " ") // needs to be a space so wrapping works
}, opts);
let cm = CodeMirror(target, o);
cm.setSize(width, height);
if (cm.getOption("maxLength")) {
cm.on("beforeChange", CMUtils.enforceMaxLength);
}
if (cm.getOption("singleLine")) {
cm.on("beforeChange", CMUtils.enforceSingleLine);
}
return cm;
};
CMUtils.getCharIndexAt = function (cm, winX, winY) {
let pos = cm.coordsChar({
left: winX,
top: winY
}, "page");
// test current and prev character, since CM seems to use the center of each character for coordsChar:
for (let i = 0; i <= 1; i++) {
let rect = cm.charCoords(pos, "page");
if (winX >= rect.left && winX <= rect.right && winY >= rect.top && winY <= rect.bottom) {
return cm.indexFromPos(pos);
}
if (pos.ch-- <= 0) {
break;
}
}
return null;
};
/*
// unused?
CMUtils.getEOLPos = function (cm, pos) {
if (!isNaN(pos)) {
pos = cm.posFromIndex(pos);
}
let rect = cm.charCoords(pos, "local"), w = cm.getScrollInfo().width;
return cm.coordsChar({left: w - 1, top: rect.top}, "local");
};
*/
CMUtils.getCharRect = function (cm, index) {
if (index == null) {
return null;
}
let pos = cm.posFromIndex(index),
rect = cm.charCoords(pos);
rect.x = rect.left;
rect.y = rect.top;
rect.width = rect.right - rect.left;
rect.height = rect.bottom - rect.top;
return rect;
};
CMUtils.enforceMaxLength = function (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;
};
CMUtils.enforceSingleLine = function (cm, change) {
if (change.update) {
let str = change.text.join("").replace(/(\n|\r)/g, "");
change.update(change.from, change.to, [str]);
}
return true;
};
CMUtils.selectAll = function (cm) {
cm.focus();
cm.setSelection({
ch: 0,
line: 0
}, {
ch: 0,
line: cm.lineCount()
});
};
CMUtils.calcRangePos = function (cm, i, l = 0, o = {}) {
let doc = cm.getDoc();
o.startPos = doc.posFromIndex(i);
o.endPos = doc.posFromIndex(i + l);
return o;
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
let Track = {};
Track.GA_ID = "UA-3579542-6";
Track.page = function (path) {
gtag("config", Track.GA_ID, {
"page_path": "/" + path
});
};
// https://developers.google.com/analytics/devguides/collection/gtagjs/events
Track.event = function (name, category, label) {
let o = {};
if (category) {
o.event_category = category;
}
if (label) {
o.event_label = label;
}
gtag("event", name, o);
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class List extends EventDispatcher {
constructor(el, opts) {
super();
this.el = el;
this.multi = opts.multi;
this.template = opts.template;
this.data = opts.data;
if (opts.selected) {
this.selected = opts.selected;
}
}
set data(data) {
DOMUtils.empty(this.el);
this._data = data;
if (!data || !data.length) {
return;
}
for (let i = 0, l = data.length; i < l; i++) {
this.addItem(data[i]);
}
}
get data() {
return this._data;
}
set selected(ids) {
DOMUtils.removeClass(DOMUtils.queryAll(".selected", this.el), "selected");
if (!(ids instanceof Array)) {
ids = [ids];
}
ids.forEach(id => DOMUtils.addClass(DOMUtils.query("[data-id='" + id + "']", this.el), "selected"));
if (!this.multi) {
this.scrollTo(ids[0]);
}
}
get selected() {
let els = DOMUtils.queryAll("li.selected", this.el);
if (!els[0]) {
return null;
}
if (!this.multi) {
return els[0].dataset.id;
}
let ids = [];
for (let i = 0, l = els.length; i < l; i++) {
ids.push(els[i].dataset.id);
}
return ids;
}
set selectedIndex(index) {
let data = this.data;
this.selected = data && data[index] && data[index].id;
}
get selectedIndex() {
let el = this.selectedEl,
id = el && el.dataset.id;
return id === null ? -1 : this.data.findIndex(o => o.id === id);
}
get selectedItem() {
let el = this.selectedEl;
return el && el.item;
}
get selectedEl() {
return DOMUtils.query("li.selected", this.el);
}
refresh() {
let sel = this.selected;
this.data = this._data;
this.selected = sel;
}
addItem(o, selected = null) {
let label, id, sel;
let f = evt => this.handleClick(evt),
template = this.template;
if (typeof o === "string") {
id = o;
label = template ? template(o) : o;
} else {
if (o.hide) {
return;
}
id = o.id || o.label;
label = template ? template(o) : o.label;
if (selected === null) {
sel = o.selected;
}
}
let item = DOMUtils.create("li", sel ? "selected" : null, label, this.el);
item.dataset.id = id;
item.item = o;
item.addEventListener("click", f);
item.addEventListener("dblclick", f);
if (selected) {
this.selected = o.id;
}
}
removeItem(id) {
let el = DOMUtils.query("[data-id='" + id + "']", this.el);
el && el.remove();
}
handleClick(evt) {
let id = evt.currentTarget.dataset.id,
old = this.selected;
if (!this.getEl(id)) {
return;
}
if (evt.type === "dblclick") {
if (id != null) {
this.dispatchEvent("dblclick");
}
return;
} else if (this.multi) {
DOMUtils.toggleClass(evt.currentTarget, "selected");
} else if (old === id) {
if (id != null) {
this.dispatchEvent("selclick");
}
return;
} else {
this.selected = id;
}
if (!this.dispatchEvent("change", false, true)) {
this.selected = old;
}
}
scrollTo(id = this.selected) {
let el = this.getEl(id);
if (!el) {
return;
}
//el.scrollIntoView(); // this is too jumpy, but would handle horizontal.
let scrollEl = this.scrollEl || this.el;
let top = el.offsetTop - scrollEl.offsetTop;
if (top + el.offsetHeight > scrollEl.scrollTop + scrollEl.offsetHeight) {
scrollEl.scrollTop = top + el.offsetHeight - scrollEl.offsetHeight + 10;
} else if (top < scrollEl.scrollTop) {
scrollEl.scrollTop = top - 10;
}
}
getEl(id) {
return DOMUtils.query("[data-id='" + id + "']", this.el);
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class ExpressionLexer {
constructor() {
this.profile = null;
}
set profile(profile) {
this._profile = profile;
this.string = this.token = this.errors = this.captureGroups = this.namedGroups = null;
}
parse(str) {
if (!this._profile) {
return null;
}
if (str === this.string) {
return this.token;
}
this.token = null;
this._modes = {};
this.string = str;
this.errors = [];
let capgroups = this.captureGroups = [];
let namedgroups = this.namedGroups = {};
let brgroups = this.branchResetGroups = [];
let groups = [],
refs = [],
i = 0,
l = str.length;
let o,
c,
token,
charset = null;
// previous is the previous token, prv is the previous "active" token (!ignore)
let prev = null,
prv = null;
let profile = this._profile,
unquantifiable = profile.unquantifiable;
let charTypes = profile.charTypes;
let closeIndex = str.lastIndexOf("/");
for (let i = closeIndex + 1; i < l; i++) {
this._modes[str[i]] = true;
}
while (i < l) {
c = str[i];
token = {
i: i,
l: 1,
prev: prev,
prv: prv,
modes: this._modes
};
if (prev) {
prev.next = token;
} else {
this.token = token;
}
if (i === 0 || i >= closeIndex) {
this.parseFlag(str, token);
} else if (c === "(" && !charset) {
this.parseParen(str, token);
if (token.close === null) {
token.depth = groups.length;
groups.push(token);
}
if (token.capture) {
this.addCaptureGroup(token, groups);
}
} else if (c === ")" && !charset) {
token.type = "groupclose";
if (groups.length) {
o = token.open = groups.pop();
o.close = token;
if (o.type === "branchreset") {
brgroups.pop();
}
} else {
token.error = {
id: "groupclose"
};
}
} else if (c === "[") {
charset = this.parseSquareBracket(str, token, charset);
} else if (c === "]" && charset) {
token.type = "setclose";
token.open = charset;
charset.close = token;
charset = null;
} else if (c === "+" && prv && prv.clss === "quant" && profile.tokens.possessive) {
token.type = "possessive";
token.related = [prv];
} else if ((c === "+" || c === "*") && !charset) {
token.type = charTypes[c];
token.clss = "quant";
token.min = c === "+" ? 1 : 0;
token.max = -1;
} else if (c === "{" && !charset && str.substr(i).search(/^{\d+,?\d*}/) !== -1) {
this.parseQuant(str, token);
} else if (c === "\\") {
this.parseBackSlash(str, token, charset, closeIndex);
} else if (c === "?" && !charset) {
if (!prv || prv.clss !== "quant") {
token.type = charTypes[c];
token.clss = "quant";
token.min = 0;
token.max = 1;
} else {
token.type = "lazy";
token.related = [prv];
}
} else if (c === "-" && charset && prv.code !== undefined && prv.prv && prv.prv.type !== "range") {
// this may be the start of a range, but we'll need to validate after the next token.
token.type = "range";
} else {
this.parseChar(str, token, charset);
if (!charset && this._modes.x && /\s/.test(c)) {
token.ignore = true;
token.type = "ignorews";
}
}
// post process token:
// quantifier:
if (token.clss === "quant") {
if (!prv || prv.close !== undefined || unquantifiable[prv.type] || prv.open && unquantifiable[prv.open.type]) {
token.error = {
id: "quanttarg"
};
} else {
token.related = [prv.open || prv];
}
}
// reference:
if (token.group === true) {
refs.push(token);
}
// conditional:
let curGroup = groups.length ? groups[groups.length - 1] : null;
if (curGroup && (curGroup.type === "conditional" || curGroup.type === "conditionalgroup") && token.type === "alt") {
if (!curGroup.alt) {
curGroup.alt = token;
} else {
token.error = {
id: "extraelse"
};
}
token.related = [curGroup];
token.type = "conditionalelse";
token.clss = "special";
} else if (curGroup && curGroup.type === "branchreset") {
// reset group
curGroup.curGroupNum = curGroup.inGroupNum;
}
// range:
if (prv && prv.type === "range" && prv.l === 1) {
this.validateRange(str, token);
}
// js warnings:
// TODO: this isn't ideal, but I'm hesitant to write a more robust solution for a couple of edge cases.
if (profile.id === "js") {
this.addJSWarnings(token);
}
// general:
if (token.open && !token.clss) {
token.clss = token.open.clss;
}
if (token.error) {
this.addError(token);
}
i += token.l;
prev = token;
if (!token.ignore) {
prv = token;
}
}
// post processing:
while (groups.length) {
this.addError(groups.pop(), {
id: "groupopen"
});
}
this.matchRefs(refs, capgroups, namedgroups);
if (charset) {
this.addError(charset, {
id: "setopen"
});
}
return this.token;
}
addError(token, error = token.error) {
token.error = error;
this.errors.push(token);
}
addJSWarnings(token) {
if (token.error) {
return;
}
if (token.type === "neglookbehind" || token.type === "poslookbehind" || token.type === "sticky" || token.type === "unicode" || token.type == "dotall" || token.type === "unicodecat" || token.type === "unicodescript" || token.type === "namedgroup") {
token.error = {
id: "jsfuture",
warning: true
};
}
}
addCaptureGroup(token, groups) {
// it would be nice to make branch reset groups actually highlight all of the groups that share the same number
// that would require switching to arrays of groups for each group num - requires rearchitecture throughout the app.
let capgroups = this.captureGroups,
brgroups = this.branchResetGroups,
namedgroups = this.namedGroups;
let curGroup = groups.length ? groups[groups.length - 1] : null;
if (brgroups.length) {
let brgroup = brgroups[brgroups.length - 1];
token.num = ++brgroup.curGroupNum;
} else {
token.num = capgroups.length + 1;
}
if (!capgroups[token.num - 1]) {
capgroups.push(token);
}
if (token.name && !token.error) {
if (/\d/.test(token.name[0])) {
token.error = {
id: "badname"
};
} else if (namedgroups[token.name]) {
token.error = {
id: "dupname"
};
token.related = [namedgroups[token.name]];
} else {
namedgroups[token.name] = token;
}
}
}
getRef(token, str) {
token.clss = "ref";
token.group = true;
token.relIndex = this.captureGroups.length;
token.name = str;
}
matchRefs(refs, indexes, names) {
while (refs.length) {
let token = refs.pop(),
name = token.name,
group = names[name];
if (!group && !isNaN(name)) {
let sign = name[0],
index = parseInt(name) + (sign === "+" || sign === "-" ? token.relIndex : 0);
if (sign === "-") {
index++;
}
group = indexes[index - 1];
}
if (group) {
token.group = group;
token.related = [group];
token.dir = token.i < group.i ? 1 : !group.close || token.i < group.close.i ? 0 : -1;
} else {
delete token.group;
delete token.relIndex;
this.refToOctal(token);
if (token.error) {
this.errors.push(token.error);
}
}
}
}
refToOctal(token) {
// PCRE: \# unmatched, \0 \00 \## = octal
// JS: \# \0 \00 \## = octal
// PCRE matches \8 \9 to "8" "9"
// JS: without the u flag \8 \9 match "8" "9" in IE, FF & Chrome, and "\8" "\9" in Safari. We support the former.
// JS: with the u flag, Chrome & FF throw an esc error, Safari does not.
// TODO: handle \0 for PCRE? Would need more testing.
// TODO: this doesn't handle two digit refs with 8/9 in them. Ex. \18 - not even sure what this is interpreted as.
let name = token.name,
profile = this._profile;
if (token.type !== "numref") {
// not a simple \4 style reference, so can't decompose into an octal.
token.error = {
id: "unmatchedref"
};
} else if (/^[0-7]{2}$/.test(name) || profile.config.reftooctalalways && /^[0-7]$/.test(name)) {
// octal
let next = token.next,
char = String.fromCharCode(next.code);
if (next.type === "char" && char >= "0" && char <= "7" && parseInt(name + char, 8) <= 255) {
name += char;
this.mergeNext(token);
}
token.code = parseInt(name, 8);
token.clss = "esc";
token.type = "escoctal";
delete token.name;
} else if (name === "8" || name === "9") {
this.parseEscChar(token, name);
delete token.name;
} else {
token.error = {
id: "unmatchedref"
};
}
}
mergeNext(token) {
let next = token.next;
token.next = next.next;
token.next.prev = token;
token.l++;
}
parseFlag(str, token) {
// note that this doesn't deal with misformed patterns or incorrect flags.
let i = token.i,
c = str[i];
if (str[i] === "/") {
token.type = i === 0 ? "open" : "close";
if (i !== 0) {
token.related = [this.token];
this.token.related = [token];
}
} else {
token.type = this._profile.flags[c];
}
//token.clear = true;
}
parseChar(str, token, charset) {
let c = str[token.i];
token.type = !charset && this._profile.charTypes[c] || "char";
if (!charset && c === "/") {
token.error = {
id: "fwdslash"
};
}
if (token.type === "char") {
token.code = c.charCodeAt(0);
} else if (ExpressionLexer.ANCHOR_TYPES[token.type]) {
token.clss = "anchor";
} else if (token.type === "dot") {
token.clss = "charclass";
}
return token;
}
parseSquareBracket(str, token, charset) {
let match;
if (this._profile.tokens.posixcharclass && (match = str.substr(token.i).match(/^\[(:|\.)([^\]]*?)\1]/))) {
// posixcharclass: [:alpha:]
// posixcollseq: [.ch.]
// currently neither flavor supports posixcollseq, but PCRE does flag as an error:
// TODO: the expression above currently does not catch [.\].]
token.l = match[0].length;
token.value = match[2];
token.clss = "charclass";
if (match[1] === ":") {
token.type = "posixcharclass";
if (!this._profile.posixCharClasses[match[2]]) {
token.error = {
id: "posixcharclassbad"
};
} else if (!charset) {
token.error = {
id: "posixcharclassnoset"
};
}
} else {
token.type = "posixcollseq";
// TODO: can this be generalized? Right now, no, because we assign ids that aren't in the profile.
token.error = {
id: "notsupported"
};
}
} else if (!charset) {
// set [a-z] [aeiou]
// setnot [^a-z]
token.type = token.clss = "set";
if (str[token.i + 1] === "^") {
token.l++;
token.type += "not";
}
charset = token;
} else {
// [[] (square bracket inside a set)
this.parseChar(str, token, charset);
}
return charset;
}
parseParen(str, token) {
/*
core:
. group:
. lookahead: ?= ?!
. noncap: ?:
PCRE:
. lookbehind: ?<= ? ?'name' ?
. namedref: ?P=name Also: \g'name' \k'name' etc
. comment: ?#
. atomic: ?>
. recursion: ?0 ?R Also: \g<0>
. define: ?(DEFINE)
. subroutine: ?1 ?-1 ?&name ?P>name
conditionalgroup: ?(1)a|b ?(-1)a|b ?(name)a|b
conditional: ?(?=if)then|else
mode: ?c-i
branchreset: ?|
*/
token.clss = token.type = "group";
if (str[token.i + 1] !== "?") {
token.close = null; // indicates that it needs a close token.
token.capture = true;
return token;
}
let sub = str.substr(token.i + 2),
match,
s = sub[0];
if (s === ":") {
// (?:foo)
token.type = "noncapgroup";
token.close = null;
token.l = 3;
} else if (s === ">") {
// (?>foo)
token.type = "atomic";
token.close = null;
token.l = 3;
} else if (s === "|") {
// (?|(a)|(b))
token.type = "branchreset";
token.close = null;
token.l = 3;
token.inGroupNum = token.curGroupNum = this.captureGroups.length;
this.branchResetGroups.push(token);
} else if (s === "#" && (match = sub.match(/[^)]*\)/))) {
// (?#foo)
token.clss = token.type = "comment";
token.ignore = true;
token.l = 2 + match[0].length;
} else if (/^(R|0)\)/.test(sub)) {
// (?R) (?0)
token.clss = "ref";
token.type = "recursion";
token.l = 4;
} else if (match = sub.match(/^P=(\w+)\)/i)) {
// (?P=name)
token.type = "namedref";
this.getRef(token, match[1]);
token.l = match[0].length + 2;
} else if (/^\(DEFINE\)/.test(sub)) {
// (?(DEFINE)foo)
token.type = "define";
token.close = null;
token.l = 10;
} else if (match = sub.match(/^/)) || this._profile.config.namedgroupalt && ((match = sub.match(/^'(\w+)'/)) || (match = sub.match(/^P<(\w+)>/)))) {
// (?foo) (?'name'foo) (?Pfoo)
token.type = "namedgroup";
token.close = null;
token.name = match[1];
token.capture = true;
token.l = match[0].length + 2;
} else if ((match = sub.match(/^([-+]?\d\d?)\)/)) || (match = sub.match(/^(?:&|P>)(\w+)\)/))) {
// (?1) (?-1) (?&name) (?P>name)
token.type = (isNaN(match[1]) ? "named" : "num") + "subroutine";
this.getRef(token, match[1]);
token.l = match[0].length + 2;
} else if ((match = sub.match(/^\(([-+]?\d\d?)\)/)) || (match = sub.match(/^\((\w+)\)/))) {
// (?(1)a|b) (?(-1)a|b) (?(name)a|b)
this.getRef(token, match[1]);
token.clss = "special";
token.type = "conditionalgroup";
token.close = null;
token.l = match[0].length + 2;
} else if (/^\(\?255). In theory it should allow 4?
if (isNaN(val) || val > 255 || /[^\da-f]/i.test(match[1])) {
token.error = {
id: "esccharbad"
};
} else {
token.code = val;
}
} else if (match = sub.match(/^x([\da-fA-F]{0,2})/)) {
// hex ascii: \xFF
token.type = "eschexadecimal";
token.l += match[0].length;
token.code = parseInt(match[1] || 0, 16);
} else if (match = sub.match(/^c([a-zA-Z])?/)) {
// control char: \cA \cz
// also handles: \c
// not supported in JS strings
token.type = "esccontrolchar";
if (match[1]) {
token.code = match[1].toUpperCase().charCodeAt(0) - 64; // A=65
token.l += 2;
} else if (profile.config.ctrlcodeerr) {
token.l++;
token.error = {
id: "esccharbad"
};
} else {
return this.parseChar(str, token, charset); // this builds the "/" token
}
} else if (match = sub.match(/^[0-7]{1,3}/)) {
// octal ascii: \011
token.type = "escoctal";
sub = match[0];
if (parseInt(sub, 8) > 255) {
sub = sub.substr(0, 2);
}
token.l += sub.length;
token.code = parseInt(sub, 8);
} else if (profile.tokens.escoctalo && (match = sub.match(/^o\{(.*?)}/i))) {
// \o{377}
token.type = "escoctal";
token.l += match[0].length;
val = parseInt(match[1], 8);
if (isNaN(val) || val > 255 || /[^0-7]/.test(match[1])) {
token.error = {
id: "esccharbad"
};
} else {
token.code = val;
}
} else {
// single char
if (token.type = profile.escCharTypes[c]) {
token.l++;
token.clss = ExpressionLexer.ANCHOR_TYPES[token.type] ? "anchor" : "charclass";
return token;
}
token.code = profile.escCharCodes[c];
if (token.code === undefined || token.code === false) {
// unrecognized.
return this.parseEscChar(token, c);
}
// update SubstLexer if this changes:
token.l++;
token.type = "esc_" + token.code;
}
token.clss = "esc";
return token;
}
parseEscChar(token, c) {
// unrecognized escchar: \u \a \8, etc
// JS: allowed except if u flag set, Safari still allows \8 \9
// PCRE: allows \8 \9 but not others // TODO: support?
let profile = this._profile;
token.l = 2;
if (!profile.badEscChars[c] && profile.tokens.escchar && !this._modes.u || profile.escChars[c]) {
token.type = "escchar";
token.code = c.charCodeAt(0);
token.clss = "esc";
} else {
token.error = {
id: "esccharbad"
};
}
}
parseRef(token, sub) {
// namedref: \k \k'name' \k{name} \g{name}
// namedsubroutine: \g \g'name'
// numref: \g1 \g+2 \g{2}
// numsubroutine: \g<-1> \g'1'
// recursion: \g<0> \g'0'
let c = sub[0],
s = "",
match;
if (match = sub.match(/^[gk](?:'\w*'|<\w*>|{\w*})/)) {
s = match[0].substr(2, match[0].length - 3);
if (c === "k" && !isNaN(s)) {
s = "";
} // TODO: specific error for numeric \k?
} else if (match = sub.match(/^g(?:({[-+]?\d+}|<[-+]?\d+>|'[-+]?\d+')|([-+]?\d+))/)) {
s = match[2] !== undefined ? match[2] : match[1].substr(1, match[1].length - 2);
}
let isRef = c === "k" || !(sub[1] === "'" || sub[1] === "<");
if (!isRef && s == 0) {
token.type = "recursion";
token.clss = "ref";
} else {
// namedref, extnumref, namedsubroutine, numsubroutine
token.type = (isNaN(s) ? "named" : (isRef ? "ext" : "") + "num") + (isRef ? "ref" : "subroutine");
this.getRef(token, s);
}
token.l += match ? match[0].length : 1;
}
parseUnicode(token, sub) {
// unicodescript: \p{Cherokee}
// unicodecat: \p{Ll} \pL
// not: \P{Ll} \p{^Lu}
let match = sub.match(/p\{\^?([^}]*)}/i),
val = match && match[1],
not = sub[0] === "P";
if (!match && (match = sub.match(/[pP]([LMZSNPC])/))) {
val = match[1];
} else {
not = not !== (sub[2] === "^");
}
token.l += match ? match[0].length : 1;
token.type = "unicodecat";
if (this._profile.unicodeScripts[val]) {
token.type = "unicodescript";
} else if (!this._profile.unicodeCategories[val]) {
val = null;
}
if (not) {
token.type = "not" + token.type;
}
if (!this._profile.config.unicodenegated && sub[2] === "^" || !val) {
token.error = {
id: "unicodebad"
};
}
token.value = val;
token.clss = "charclass";
return token;
}
parseMode(token, sub) {
// (?i-x)
// supported modes in PCRE: i-caseinsens, x-freespacing, s-dotall, m-multiline, U-switchlazy, [J-samename]
let match = sub.match(/^[-a-z]+\)/i);
if (!match) {
return;
}
let supModes = this._profile.modes;
let modes = Utils.copy({}, this._modes),
bad = false,
not = false,
s = match[0],
c;
token.on = token.off = "";
for (let i = 0, l = s.length - 1; i < l; i++) {
c = s[i];
if (c === "-") {
not = true;
continue;
}
if (!supModes[c]) {
bad = true;
break;
}
modes[c] = !not;
token.on = token.on.replace(c, "");
if (not) {
token.off = token.off.replace(c, "");
token.off += c;
} else {
token.on += c;
}
}
token.clss = "special";
token.type = "mode";
token.l = match[0].length + 2;
if (bad) {
token.error = {
id: "modebad"
};
token.errmode = c;
} else {
this._modes = modes;
}
return token;
}
parseQuant(str, token) {
// quantifier: {0,3} {3} {1,}
token.type = token.clss = "quant";
let i = token.i;
let end = str.indexOf("}", i + 1);
token.l += end - i;
let arr = str.substring(i + 1, end).split(",");
token.min = parseInt(arr[0]);
token.max = arr[1] === undefined ? token.min : arr[1] === "" ? -1 : parseInt(arr[1]);
if (token.max !== -1 && token.min > token.max) {
token.error = {
id: "quantrev"
};
}
return token;
}
validateRange(str, end) {
// char range: [a-z] [\11-\n]
let next = end,
token = end.prv,
prv = token.prv;
if (prv.code === undefined || next.code === undefined) {
// not a range, rewrite as a char:
this.parseChar(str, token);
} else {
token.clss = "set";
if (prv.code > next.code) {
// this gets added here because parse has already moved to the next token:
this.errors.push(token.error = {
id: "rangerev"
});
}
// preserve as separate tokens, but treat as one in the UI:
next.proxy = prv.proxy = token;
token.set = [prv, token, next];
}
}
}
ExpressionLexer.ANCHOR_TYPES = {
"bof": true,
"eof": true,
"bos": true,
"eos": true,
"abseos": true,
"wordboundary": true,
"notwordboundary": true,
"prevmatchend": true
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class ExpressionHighlighter extends EventDispatcher {
constructor(cm) {
super();
this.cm = cm;
this._activeMarks = [];
this._hoverMarks = [];
this._hoverToken = null;
}
clear() {
this.cm.operation(() => {
let marks = this._activeMarks;
for (var i = 0, l = marks.length; i < l; i++) {
marks[i].clear();
}
marks.length = 0;
});
}
draw(token) {
let cm = this.cm,
pre = ExpressionHighlighter.CSS_PREFIX;
this.clear();
cm.operation(() => {
let groupClasses = ExpressionHighlighter.GROUP_CLASS_BY_TYPE;
let doc = cm.getDoc(),
endToken,
marks = this._activeMarks;
while (token) {
if (token.clear) {
token = token.next;
continue;
}
token = this._calcTokenPos(token);
var className = pre + (token.clss || token.type);
if (token.error) {
className += " " + pre + (token.error.warning ? "warning" : "error");
}
if (className) {
marks.push(doc.markText(token.startPos, token.endPos, {
className: className
}));
}
if (token.close) {
endToken = this._calcTokenPos(token.close);
className = groupClasses[token.clss || token.type];
if (className) {
className = className.replace("%depth%", token.depth);
marks.push(doc.markText(token.startPos, endToken.endPos, {
className: className
}));
}
}
token = token.next;
}
});
}
set hoverToken(token) {
if (token === this._hoverToken) {
return;
}
if (token && token.set && token.set.indexOf(this._hoverToken) !== -1) {
return;
}
while (this._hoverMarks.length) {
this._hoverMarks.pop().clear();
}
this._hoverToken = token;
if (token) {
if (token.open) {
this._drawSelect(token.open);
} else {
this._drawSelect(token);
}
if (token.related) {
for (let i = 0, l = token.related.length; i < l; i++) {
this._drawSelect(token.related[i], ExpressionHighlighter.CSS_PREFIX + "related");
}
}
}
this.dispatchEvent("hover");
}
get hoverToken() {
return this._hoverToken;
}
// private methods:
_drawSelect(token, style = ExpressionHighlighter.CSS_PREFIX + "selected") {
let doc = this.cm.getDoc(),
endToken = token.close || token;
if (token.set) {
endToken = token.set[token.set.length - 1];
token = token.set[0];
}
this._calcTokenPos(endToken);
this._calcTokenPos(token);
this._hoverMarks.push(doc.markText(token.startPos, endToken.endPos, {
className: style,
startStyle: style + "-left",
endStyle: style + "-right"
}));
}
_calcTokenPos(token) {
if (token.startPos || token == null) {
return token;
}
CMUtils.calcRangePos(this.cm, token.i, token.l, token);
return token;
}
}
ExpressionHighlighter.CSS_PREFIX = "exp-";
ExpressionHighlighter.GROUP_CLASS_BY_TYPE = {
set: ExpressionHighlighter.CSS_PREFIX + "group-set",
setnot: ExpressionHighlighter.CSS_PREFIX + "group-set",
group: ExpressionHighlighter.CSS_PREFIX + "group-%depth%",
lookaround: ExpressionHighlighter.CSS_PREFIX + "group-%depth%"
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class ExpressionHover {
constructor(editor, highlighter) {
this.editor = editor;
this.highlighter = highlighter;
this.isMouseDown = false;
this.token = null;
let o = editor.display.lineDiv;
o.addEventListener("mousemove", evt => this._handleMouseMove(evt));
o.addEventListener("mouseout", evt => this._handleMouseOut(evt));
o.addEventListener("mousedown", evt => this._handleMouseDown(evt));
}
// private methods:
_handleMouseMove(evt) {
if (this.isMouseDown) {
return;
}
let index,
editor = this.editor,
token = this.token,
target = null;
if (evt && token && (index = CMUtils.getCharIndexAt(editor, evt.clientX, evt.clientY + window.pageYOffset)) != null) {
while (token) {
if (index >= token.i && index < token.i + token.l) {
target = token;
break;
}
token = token.next;
}
}
while (target) {
if (target.open) {
target = target.open;
} else if (target.proxy) {
target = target.proxy;
} else {
break;
}
}
this.highlighter.hoverToken = target;
let rect = index != null && CMUtils.getCharRect(editor, index);
if (rect) {
rect.right = rect.left = evt.clientX;
}
app.tooltip.hover.show("ExpressionHover", app.reference.tipForToken(target), evt.clientX, rect.bottom, true, 0);
}
_handleMouseOut(evt) {
this.highlighter.hoverToken = null;
app.tooltip.hover.hide("ExpressionHover");
}
_handleMouseDown(evt) {
// TODO: Should this also be in TextHover?
if (evt.which !== 1 && evt.button !== 1) {
return;
}
this.isMouseDown = true;
let f,
t = window.addEventListener ? window : document;
t.addEventListener("mouseup", f = () => {
t.removeEventListener("mouseup", f);
this.isMouseDown = false;
});
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
The core profile essentially defines every feature we support, and is then pared down by other profiles. All values should be y (true).
It also acts in part as pseudo documentation for all of the "type" values.
*/
let y = true,
n = false;
let core = {
id: "core",
flags: {
"g": "global",
// note that this is not a real flag in some flavors, but a different method call
"i": "caseinsensitive",
"m": "multiline",
"s": "dotall",
"u": "unicode",
"y": "sticky",
"x": "extended",
"U": "ungreedy"
},
// reserved characters that need to be escaped:
escChars: "+*?^$\\.[]{}()|/".split("").reduce((o, c) => {
o[c] = y;
return o;
}, {}),
// escape chars that are specifically not supported by the flavor:
badEscChars: n,
escCharCodes: {
"0": 0,
// null
"a": 7,
// bell
"t": 9,
// tab
"n": 10,
// lf
"v": 11,
// vertical tab
"f": 12,
// form feed
"r": 13,
// cr
"e": 27 // escape
},
escCharTypes: {
"A": "bos",
"b": "wordboundary",
"B": "notwordboundary",
"d": "digit",
"D": "notdigit",
"G": "prevmatchend",
"h": "hwhitespace",
"H": "nothwhitespace",
"K": "keepout",
"N": "notlinebreak",
"R": "linebreak",
"s": "whitespace",
"S": "notwhitespace",
"v": "vwhitespace",
"V": "notvwhitespace",
"w": "word",
"W": "notword",
"X": "unicodegrapheme",
"Z": "eos",
"z": "abseos"
},
charTypes: {
".": "dot",
"|": "alt",
"$": "eof",
"^": "bof",
"?": "opt",
// also: "lazy"
"+": "plus",
// also: "possessive"
"*": "star"
},
unquantifiable: {
// all group/set open tokens are unquantifiable by default (ie. tokens with a .close value)
"quant": y,
"plus": y,
"star": y,
"opt": y,
"lazy": y,
"possessive": y,
"eof": y,
"bof": y,
"eos": y,
"abseos": y,
"alt": y,
"open": y,
"mode": y,
"comment": y,
// TODO: this should actually be ignored by quantifiers.
"condition": y
},
unicodeScripts: {
// from: http://www.pcre.org/original/doc/html/pcrepattern.html
"Arabic": y,
"Armenian": y,
"Avestan": y,
"Balinese": y,
"Bamum": y,
"Bassa_Vah": y,
"Batak": y,
"Bengali": y,
"Bopomofo": y,
"Brahmi": y,
"Braille": y,
"Buginese": y,
"Buhid": y,
"Canadian_Aboriginal": y,
"Carian": y,
"Caucasian_Albanian": y,
"Chakma": y,
"Cham": y,
"Cherokee": y,
"Common": y,
"Coptic": y,
"Cuneiform": y,
"Cypriot": y,
"Cyrillic": y,
"Deseret": y,
"Devanagari": y,
"Duployan": y,
"Egyptian_Hieroglyphs": y,
"Elbasan": y,
"Ethiopic": y,
"Georgian": y,
"Glagolitic": y,
"Gothic": y,
"Grantha": y,
"Greek": y,
"Gujarati": y,
"Gurmukhi": y,
"Han": y,
"Hangul": y,
"Hanunoo": y,
"Hebrew": y,
"Hiragana": y,
"Imperial_Aramaic": y,
"Inherited": y,
"Inscriptional_Pahlavi": y,
"Inscriptional_Parthian": y,
"Javanese": y,
"Kaithi": y,
"Kannada": y,
"Katakana": y,
"Kayah_Li": y,
"Kharoshthi": y,
"Khmer": y,
"Khojki": y,
"Khudawadi": y,
"Lao": y,
"Latin": y,
"Lepcha": y,
"Limbu": y,
"Linear_A": y,
"Linear_B": y,
"Lisu": y,
"Lycian": y,
"Lydian": y,
"Mahajani": y,
"Malayalam": y,
"Mandaic": y,
"Manichaean": y,
"Meetei_Mayek": y,
"Mende_Kikakui": y,
"Meroitic_Cursive": y,
"Meroitic_Hieroglyphs": y,
"Miao": y,
"Modi": y,
"Mongolian": y,
"Mro": y,
"Myanmar": y,
"Nabataean": y,
"New_Tai_Lue": y,
"Nko": y,
"Ogham": y,
"Ol_Chiki": y,
"Old_Italic": y,
"Old_North_Arabian": y,
"Old_Permic": y,
"Old_Persian": y,
"Old_South_Arabian": y,
"Old_Turkic": y,
"Oriya": y,
"Osmanya": y,
"Pahawh_Hmong": y,
"Palmyrene": y,
"Pau_Cin_Hau": y,
"Phags_Pa": y,
"Phoenician": y,
"Psalter_Pahlavi": y,
"Rejang": y,
"Runic": y,
"Samaritan": y,
"Saurashtra": y,
"Sharada": y,
"Shavian": y,
"Siddham": y,
"Sinhala": y,
"Sora_Sompeng": y,
"Sundanese": y,
"Syloti_Nagri": y,
"Syriac": y,
"Tagalog": y,
"Tagbanwa": y,
"Tai_Le": y,
"Tai_Tham": y,
"Tai_Viet": y,
"Takri": y,
"Tamil": y,
"Telugu": y,
"Thaana": y,
"Thai": y,
"Tibetan": y,
"Tifinagh": y,
"Tirhuta": y,
"Ugaritic": y,
"Vai": y,
"Warang_Citi": y,
"Yi": y
},
unicodeCategories: {
// from: http://www.pcre.org/original/doc/html/pcrepattern.html
"C": y,
// Other
"Cc": y,
// Control
"Cf": y,
// Format
"Cn": y,
// Unassigned
"Co": y,
// Private use
"Cs": y,
// Surrogate
"L": y,
// Letter
"L&": y,
// Any letter
"Ll": y,
// Lower case letter
"Lm": y,
// Modifier letter
"Lo": y,
// Other letter
"Lt": y,
// Title case letter
"Lu": y,
// Upper case letter
"M": y,
// Mark
"Mc": y,
// Spacing mark
"Me": y,
// Enclosing mark
"Mn": y,
// Non-spacing mark
"N": y,
// Number
"Nd": y,
// Decimal number
"Nl": y,
// Letter number
"No": y,
// Other number
"P": y,
// Punctuation
"Pc": y,
// Connector punctuation
"Pd": y,
// Dash punctuation
"Pe": y,
// Close punctuation
"Pf": y,
// Final punctuation
"Pi": y,
// Initial punctuation
"Po": y,
// Other punctuation
"Ps": y,
// Open punctuation
"S": y,
// Symbol
"Sc": y,
// Currency symbol
"Sk": y,
// Modifier symbol
"Sm": y,
// Mathematical symbol
"So": y,
// Other symbol
"Z": y,
// Separator
"Zl": y,
// Line separator
"Zp": y,
// Paragraph separator
"Zs": y // Space separator
},
posixCharClasses: {
// from: http://www.pcre.org/original/doc/html/pcrepattern.html
"alnum": y,
// letters and digits
"alpha": y,
// letters
"ascii": y,
// character codes 0 - 127
"blank": y,
// space or tab only
"cntrl": y,
// control characters
"digit": y,
// decimal digits (same as \d)
"graph": y,
// printing characters, excluding space
"lower": y,
// lower case letters
"print": y,
// printing characters, including space
"punct": y,
// printing characters, excluding letters and digits and space
"space": y,
// white space (the same as \s from PCRE 8.34)
"upper": y,
// upper case letters
"word": y,
// "word" characters (same as \w)
"xdigit": y // hexadecimal digits
},
modes: {
"i": "caseinsensitive",
"s": "dotall",
"m": "multiline",
"x": "freespacing",
"J": "samename",
"U": "switchlazy"
},
tokens: {
// note that not all of these are actively used in the lexer, but are included for completeness.
"open": y,
// opening /
"close": y,
// closing /
"char": y,
// abc
// classes:
// also in escCharTypes and charTypes
"set": y,
// [a-z]
"setnot": y,
// [^a-z]
"setclose": y,
// ]
"range": y,
// [a-z]
"unicodecat": y,
// \p{Ll} \P{^Ll} \pL
"notunicodecat": y,
// \P{Ll} \p{^Ll} \PL
"unicodescript": y,
// \p{Cherokee} \P{^Cherokee}
"notunicodescript": y,
// \P{Cherokee} \p{^Cherokee}
"posixcharclass": y,
// [[:alpha:]]
// not in supported flavors: "posixcollseq": y, // [[.foo.]] // this is recognized by the lexer, currently returns "notsupported" error
// not in supported flavors: "unicodeblock": y, // \p{InThai} \p{IsThai} and NOT \P
// not in supported flavors: "subtract": y, // [base-[subtract]]
// not in supported flavors: "intersect": y, // [base&&[intersect]]
// esc:
// also in escCharCodes and escCharTypes
"escoctal": y,
// \11
"escunicodeu": y,
// \uFFFF
"escunicodeub": y,
// \u{00A9}
"escunicodexb": y,
// \x{00A9}
"escsequence": y,
// \Q...\E
"eschexadecimal": y,
// \xFF
"esccontrolchar": y,
// \cA
"escoctalo": y,
// \o{377} // resolved to escoctal in lexer, no docs required
"escchar": y,
// \m (unrecognized escapes) // no reference documentation required
// group:
"group": y,
// (foo)
"groupclose": y,
// )
"noncapgroup": y,
// (?:foo)
"namedgroup": y,
// (?Pfoo) (?foo) (?'name'foo)
"atomic": y,
// (?>foo|bar)
"define": y,
// (?(DEFINE)foo)
"branchreset": y,
// (?|(a)|(b))
// lookaround:
"poslookbehind": y,
// (?<=foo)
"neglookbehind": y,
// (? \k'name' \k{name} (?P=name) \g{name}
"numref": y,
// \1
"extnumref": y,
// \g{-1} \g{+1} \g{1} \g1 \g-1
"recursion": y,
// (?R) (?0) \g<0> \g'0'
"numsubroutine": y,
// \g<1> \g'-1' (?1) (?-1)
"namedsubroutine": y,
// \g \g'name' (?&name) (?P>name)
// quantifiers:
// also in specialChars
"quant": y,
// {1,2}
"possessive": y,
// ++
"lazy": y,
// ?
// special:
"conditional": y,
// (?(?=if)then|else)
"condition": y,
// (?=if) any lookaround
"conditionalelse": y,
// |
"conditionalgroup": y,
// (?(1)a|b) (?(-1)a|b) (?(name)a|b)
"mode": y,
// (?i-x) see modes above
"comment": y,
// (?#comment)
// meta:
"matchanyset": y // [\s\S]
},
substTokens: {
// named references aren't supported in JS or PCRE / PHP
"subst_$esc": y,
// $$
"subst_$&match": y,
// $&
"subst_$before": y,
// $`
"subst_$after": y,
// $'
"subst_$group": y,
// $1 $99 // resolved to subst_group in lexer, no docs required
"subst_$bgroup": y,
// ${1} ${99} // resolved to subst_group in lexer, no docs required
"subst_bsgroup": y,
// \1 \99 // resolved to subst_group in lexer, no docs required
"subst_group": y,
// $1 \1 \{1} // combined in docs, not used by lexer
"subst_0match": y,
// $0 \0 \{0}
// this isn't a feature of the engine, but of RegExr:
"subst_esc": y // \n \r \u1234
},
config: {
"forwardref": y,
// \1(a)
"nestedref": y,
// (\1a|b)+
"ctrlcodeerr": y,
// does \c error? (vs decompose)
"reftooctalalways": y,
// does a single digit reference \1 become an octal? (vs remain an unmatched ref)
"substdecomposeref": y,
// will a subst reference decompose? (ex. \3 becomes "\" & "3" if < 3 groups)
"looseesc": y,
// should unrecognized escape sequences match the character (ex. \u could match "u") // disabled when `u` flag is set
"unicodenegated": y,
// \p{^etc}"
"namedgroupalt": y // if false, only support (?foo)
},
docs: {
// for example:
//possessive: {desc: "+This will be appended to the existing entry." },
//namedgroup: {tip: "This will overwrite the existing entry." }
}
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/*
The PCRE profile is almost a straight copy of the core profile.
*/
let y$1 = true,
n$1 = false;
let pcre = {
id: "pcre",
label: "PCRE",
browser: false,
flags: {
"u": n$1,
"y": n$1
},
badEscChars: "uUlLN".split("").reduce((o, c) => {
o[c] = y$1;
return o;
}, {}),
escCharCodes: {
"v": n$1 // vertical tab // PCRE support \v as vertical whitespace
},
tokens: {
"escunicodeu": n$1,
// \uFFFF
"escunicodeub": n$1 // \u{00A9}
// octalo PCRE 8.34+
},
substTokens: {
"subst_$esc": n$1,
// $$
"subst_$&match": n$1,
// $&
"subst_$before": n$1,
// $`
"subst_$after": n$1 // $'
},
config: {
"reftooctalalways": n$1,
// does a single digit reference \1 become an octal? (vs remain an unmatched ref)
"substdecomposeref": n$1,
// will a subst reference decompose? (ex. \3 becomes "\" & "3" if < 3 groups)
"looseesc": n$1 // should unrecognized escape sequences match the character (ex. \u could match "u") // disabled when `u` flag is set
},
docs: {
"escoctal": {
ext: "+
The syntax \\o{FFF} is also supported.
"
},
"numref": {
ext: "
There are multiple syntaxes for this feature: \\1\\g1\\g{1}.
" + "
The latter syntaxes support relative values preceded by + or -. For example \\g-1 would match the group preceding the reference.
"
},
"lazy": {
ext: "+
This behaviour is reversed by the ungreedy (U) flag/modifier.
"
}
// notunicodecat, unicodescript, notunicodescript are copied from unicodecat below.
}
};
javascript.docs.notunicodecat = javascript.docs.unicodescript = javascript.docs.notunicodescript = javascript.docs.unicodecat;
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
let profiles = {
core
};
profiles.pcre = merge(core, pcre);
profiles.js = merge(core, javascript);
function merge(p1, p2) {
// merges p1 into p2, essentially just a simple deep copy without array support.
for (let n in p1) {
if (p2[n] === false) {
continue;
} else if (typeof p1[n] === "object") {
p2[n] = merge(p1[n], p2[n] || {});
} else if (p2[n] === undefined) {
p2[n] = p1[n];
}
}
return p2;
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Expression extends EventDispatcher {
constructor(el) {
super();
this.el = el;
this.delim = "/";
this.lexer = new ExpressionLexer();
this._initUI(el);
app.flavor.on("change", () => this._onFlavorChange());
this._onFlavorChange();
}
set value(expression) {
let regex = Utils.decomposeRegEx(expression || Expression.DEFAULT_EXPRESSION, this.delim);
this.pattern = regex.source;
this.flags = regex.flags;
}
get value() {
return this.editor.getValue();
}
set pattern(pattern) {
let index = this.editor.getValue().lastIndexOf(this.delim);
this.editor.replaceRange(pattern, {
line: 0,
ch: 1
}, {
line: 0,
ch: index
});
this._deferUpdate();
}
get pattern() {
return Utils.decomposeRegEx(this.editor.getValue(), this.delim).source;
}
set flags(flags) {
flags = app.flavor.validateFlagsStr(flags);
let str = this.editor.getValue(),
index = str.lastIndexOf(this.delim);
this.editor.replaceRange(flags, {
line: 0,
ch: index + 1
}, {
line: 0,
ch: str.length
}); // this doesn't work if readOnly is false.
}
get flags() {
return Utils.decomposeRegEx(this.editor.getValue(), this.delim).flags;
}
get token() {
return this.lexer.token;
}
showFlags() {
this.flagsList.selected = this.flags.split("");
app.tooltip.toggle.toggleOn("flags", this.flagsEl, this.flagsBtn, true, -2);
}
toggleFlag(s) {
let flags = this.flags,
i = flags.indexOf(s);
this.flags = i >= 0 ? flags.replace(s, "") : flags + s;
}
showFlavors() {
app.tooltip.toggle.toggleOn("flavor", this.flavorEl, this.flavorBtn, true, -2);
}
insert(str) {
this.editor.replaceSelection(str, "end");
}
selectAll() {
CMUtils.selectAll(this.editor);
}
// private methods:
_initUI(el) {
this.editorEl = DOMUtils.query("> .editor", el);
let editor = this.editor = CMUtils.create(this.editorEl, {
autofocus: true,
maxLength: 2500,
singleLine: true
}, "100%", "100%");
editor.on("mousedown", (cm, evt) => this._onEditorMouseDown(cm, evt));
editor.on("change", (cm, evt) => this._onEditorChange(cm, evt));
editor.on("keydown", (cm, evt) => this._onEditorKeyDown(cm, evt));
// hacky method to disable overwrite mode on expressions to avoid overwriting flags:
editor.toggleOverwrite = () => {};
this.errorEl = DOMUtils.query(".icon.alert", this.editorEl);
this.errorEl.addEventListener("mouseenter", evt => this._onMouseError(evt));
this.errorEl.addEventListener("mouseleave", evt => this._onMouseError(evt));
this.highlighter = new ExpressionHighlighter(editor);
this.hover = new ExpressionHover(editor, this.highlighter);
this._setInitialExpression();
this._initTooltips(el);
this.value = Expression.DEFAULT_EXPRESSION;
}
_setInitialExpression() {
let editor = this.editor;
editor.setValue("/./g");
// leading /
editor.getDoc().markText({
line: 0,
ch: 0
}, {
line: 0,
ch: 1
}, {
className: "exp-decorator",
readOnly: true,
atomic: true,
inclusiveLeft: true
});
// trailing /g
editor.getDoc().markText({
line: 0,
ch: 2
}, {
line: 0,
ch: 4
}, {
className: "exp-decorator",
readOnly: false,
atomic: true,
inclusiveRight: true
});
this._deferUpdate();
}
_deferUpdate() {
Utils.defer(() => this._update(), "Expression._update");
}
_update() {
let expr = this.editor.getValue();
this.lexer.profile = app.flavor.profile;
let token = this.lexer.parse(expr);
DOMUtils.toggleClass(this.editorEl, "error", !!this.lexer.errors.length);
this.hover.token = token;
this.highlighter.draw(token);
this.dispatchEvent("change");
}
_initTooltips(el) {
const template = DOMUtils.template` ${"label"}`;
let flavorData = app.flavor.profiles.map(o => ({
id: o.id,
label: o.label + " (" + (o.browser ? "Browser" : "Server") + ")"
}));
this.flavorBtn = DOMUtils.query("section.expression .button.flavor", el);
this.flavorEl = DOMUtils.query("#library #tooltip-flavor");
this.flavorList = new List(DOMUtils.query("ul.list", this.flavorEl), {
data: flavorData,
template
});
this.flavorList.on("change", () => this._onFlavorListChange());
this.flavorBtn.addEventListener("click", evt => this.showFlavors());
DOMUtils.query(".icon.help", this.flavorEl).addEventListener("click", () => app.sidebar.goto("engine"));
this.flagsBtn = DOMUtils.query("section.expression .button.flags", el);
this.flagsEl = DOMUtils.query("#library #tooltip-flags");
this.flagsList = new List(DOMUtils.query("ul.list", this.flagsEl), {
data: [],
multi: true,
template
});
this.flagsList.on("change", () => this._onFlagListChange());
this.flagsBtn.addEventListener("click", evt => this.showFlags());
DOMUtils.query(".icon.help", this.flagsEl).addEventListener("click", () => app.sidebar.goto("flags"));
}
// event handlers:
_onFlavorListChange() {
app.tooltip.toggle.hide("flavor");
app.flavor.value = this.flavorList.selected;
Track.page("flavor/" + this.flavorList.selected);
}
_onFlagListChange() {
let sel = this.flagsList.selected;
this.flags = sel ? sel.join("") : "";
Track.event("set_flags", "engagement", this.flags);
}
_onFlavorChange() {
let flavor = app.flavor,
profile = flavor.profile;
this.flavorList.selected = profile.id;
DOMUtils.query("> .label", this.flavorBtn).innerText = profile.label;
let supported = Expression.FLAGS.split("").filter(n => !!profile.flags[n]);
let labels = Expression.FLAG_LABELS;
this.flagsList.data = supported.map(n => ({
id: n,
label: labels[n]
}));
this.flags = this.flags.split("").filter(n => !!profile.flags[n]).join("");
}
_onEditorMouseDown(cm, evt) {
// offset by half a character to make accidental clicks less likely:
let index = CMUtils.getCharIndexAt(cm, evt.clientX - cm.defaultCharWidth() * 0.6, evt.clientY);
if (index >= cm.getValue().lastIndexOf(this.delim)) {
this.showFlags();
}
}
_onEditorChange(cm, evt) {
// catches pasting full expressions in.
// TODO: will need to be updated to work with other delimeters
this._deferUpdate();
let str = evt.text[0];
if (str.length < 3 || !str.match(/^\/.+[^\\]\/[a-z]*$/ig) || evt.from.ch !== 1 || evt.to.ch != 1 + evt.removed[0].length) {
// not pasting a full expression.
return;
}
this.value = str;
}
_onEditorKeyDown(cm, evt) {
// Ctrl or Command + D by default, will delete the expression and the flags field, Re: https://github.com/gskinner/regexr/issues/74
// So we just manually reset to nothing here.
if ((evt.ctrlKey || evt.metaKey) && evt.keyCode == 68) {
evt.preventDefault();
this.pattern = "";
}
}
_onMouseError(evt) {
let tt = app.tooltip.hover,
errs = this.lexer.errors;
if (evt.type === "mouseleave") {
return tt.hide("error");
}
if (errs.length === 0) {
return;
}
let err = errs.length === 1 && errs[0].error;
let str = err ? app.reference.getError(err, errs[0]) : "Problems in the Expression are underlined in red. Roll over them for details.";
let label = err && err.warning ? "WARNING" : "PARSE ERROR";
tt.showOn("error", "" + label + ": " + str, this.errorEl);
}
}
Expression.DEFAULT_EXPRESSION = "/(Student[^\\n ]* )?([^\\n ]+) .+(Zweitv|2. V)ersuch nicht bestanden/g";
//Expression.DEFAULT_EXPRESSION = "/(Zweitv|2. V)ersuch/g";
Expression.FLAGS = "gimsuxyU"; // for flag order
Expression.FLAG_LABELS = {
"g": "global",
"i": "case insensitive",
"m": "multiline",
"s": "single line (dotall)",
"u": "unicode",
"x": "extended",
"y": "sticky",
"U": "Ungreedy"
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
let UID = {
_next: 0,
get id() {
return Date.now() + "_" + this._next++;
},
assign(list, force = false) {
list.forEach(o => o.id = o.id == null || force ? this.id : o.id);
}
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class TextHighlighter {
constructor(editor, canvas, fill = "#6CF", stroke = "#888") {
this.lineSpacing = 2;
this.capWidth = 4;
this.lastBottom = -1;
this.lastRight = -1;
this.editor = editor;
this.canvas = canvas;
this.fill = fill;
this.stroke = stroke;
}
set matches(val) {
this._matches = val;
this._deferUpdate();
}
set hoverMatch(val) {
this._hoverMatch = val;
this._deferUpdate();
}
set selectedMatch(val) {
this._selectedMatch = val;
this._deferUpdate();
}
redraw() {
this._update();
}
_deferUpdate() {
Utils.defer(() => this._update(), "TextHighlighter._update");
}
_update() {
this.clear();
let matches = this._matches,
hoverMatch = this._hoverMatch,
selectedMatch = this._selectedMatch;
if (!matches || !matches.length) {
return;
}
let cm = this.editor,
doc = cm.getDoc();
let ctx = this.canvas.getContext("2d");
ctx.fillStyle = this.fill;
ctx.strokeStyle = this.stroke;
ctx.lineWidth = 2;
// find the range of the visible text:
let scroll = cm.getScrollInfo();
let top = cm.indexFromPos(cm.coordsChar({
left: 0,
top: scroll.top
}, "local"));
let bottom = cm.indexFromPos(cm.coordsChar({
left: scroll.clientWidth,
top: scroll.top + scroll.clientHeight
}, "local"));
for (let i = 0, l = matches.length; i < l; i++) {
let match = matches[i],
start = match.i,
end = match.i + match.l - 1;
if (start > bottom) {
break;
} // all done.
if (end < top || end < start) {
continue;
} // not visible, so don't mark.
let startPos = match.startPos || (match.startPos = doc.posFromIndex(start));
let endPos = match.endPos || (match.endPos = doc.posFromIndex(end));
let emphasis = match === hoverMatch || match === selectedMatch;
let startRect = cm.charCoords(startPos, "local"),
endRect = cm.charCoords(endPos, "local");
if (startRect.bottom === endRect.bottom) {
this.drawHighlight(ctx, startRect.left, startRect.top, endRect.right, endRect.bottom, scroll.top, false, false, emphasis);
} else {
let lw = cm.getScrollInfo().width,
lh = cm.defaultTextHeight();
// render first line:
this.drawHighlight(ctx, startRect.left, startRect.top, lw - 2, startRect.bottom, scroll.top, false, true, emphasis); // startRect.top+lh
// render lines in between:
let y = startRect.top;
while ((y += lh) < endRect.top - 1) {
// the -1 is due to fractional issues on FF
this.drawHighlight(ctx, 0, y, lw - 2, y + startRect.bottom - startRect.top, scroll.top, true, true, emphasis); // lh
}
// render last line:
this.drawHighlight(ctx, 0, endRect.top, endRect.right, endRect.bottom, scroll.top, true, false, emphasis);
// CMUtils.getEOLPos(this.sourceCM, startPos);
}
}
}
drawHighlight(ctx, left, top, right, bottom, scrollY, startCap, endCap, emphasis) {
let capW = this.capWidth;
if (right < 0 || left + 1 >= right) {
return;
} // weird bug in CodeMirror occasionally returns negative values
left = left + 0.5 | 0;
right = right + 0.5 | 0;
top = (top + 0.5 | 0) + this.lineSpacing;
bottom = bottom + 0.5 | 0;
if (top + 1 > this.lastBottom) {
this.lastBottom = bottom;
} else if (left < this.lastRight) {
left = this.lastRight;
}
this.lastRight = right;
let a = ctx.globalAlpha;
if (startCap) {
ctx.globalAlpha = a * 0.5;
ctx.fillRect(left + 1 | 0, top - scrollY, capW + 1, bottom - top);
left += capW;
}
if (endCap) {
ctx.globalAlpha = a * 0.5;
ctx.fillRect(right - capW - 1 | 0, top - scrollY, capW + 1, bottom - top);
right -= capW;
}
ctx.globalAlpha = a;
ctx.fillRect(left + 1, top - scrollY, right - left - 1, bottom - top);
if (emphasis) {
ctx.strokeRect(left + 1, top - scrollY, right - left - 1, bottom - top);
}
}
clear() {
this.canvas.width = this.canvas.width;
this.lastBottom = -1;
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class TextHover {
constructor(editor, highlighter) {
this.editor = editor;
this.highlighter = highlighter;
this._matches = this._x = null;
let o = editor.display.lineDiv;
o.addEventListener("mousemove", evt => this._handleMouseMove(evt));
o.addEventListener("mouseout", evt => this._handleMouseOut(evt));
}
set matches(val) {
this._matches = val;
this._update();
}
// private methods:
_handleMouseMove(evt) {
this._x = evt.clientX;
this._y = evt.clientY + window.pageYOffset;
this._update();
}
_handleMouseOut(evt) {
this._x = null;
this._update();
}
_update() {
if (this._x === null) {
this.highlighter.hoverMatch = null;
app.tooltip.hover.hide("TextHover");
return;
}
let index,
cm = this.editor,
match,
matches = this._matches,
x = this._x,
y = this._y;
if (matches && matches.length && (index = CMUtils.getCharIndexAt(cm, x, y)) != null) {
match = this.highlighter.hoverMatch = app.text.getMatchAt(index);
}
let rect = index != null && CMUtils.getCharRect(cm, index);
if (rect) {
rect.right = rect.left = x;
}
let tip = app.reference.tipForMatch(match, cm.getValue());
if (tip) {
let div = DOMUtils.create("div", "texthover", tip);
app.tooltip.hover.show("TextHover", div, x, rect.bottom, true, 0);
}
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Text extends EventDispatcher {
constructor(el) {
super();
this.el = el;
this._initUI(el);
this._initTestUI(el);
app.on("result", () => this._setResult(app.result));
app.theme.on("change", () => this._handleThemeChange());
}
set value(val) {
this.editor.setValue(val || this.defaultText);
}
get value() {
return this.editor.getValue();
}
set tests(val) {
if (!(val instanceof Array)) {
val = [];
DOMUtils.removeClass(this.testsEl, "tests-added");
}
this._tests = this.testList.data = val;
this._testMatches = null;
this._reselectTest();
}
get tests() {
return this._tests;
}
set mode(val) {
if (val === this.mode) {
return;
}
this.modeList.selected = val || "text";
this._handleModeChange();
}
get mode() {
return this.modeList.selected;
}
get selectedMatch() {
let cm = this.editor;
return this.getMatchAt(cm.indexFromPos(cm.getCursor()), true);
}
getMatchValue(match) {
// this also works for groups.
return match ? this.value.substr(match.i, match.l) : null;
}
getMatchAt(index, inclusive) {
// also used by TextHover
let match,
offset = inclusive ? -1 : 0,
matches = this._result && this._result.matches;
if (!matches) {
return null;
}
for (let i = 0, l = matches.length; i < l; i++) {
match = matches[i];
if (match.l + match.i - 1 < index + offset) {
continue;
}
if (match.i > index) {
break;
}
return match;
}
return null;
}
getEmptyTest() {
return {
id: UID.id,
name: "",
text: "Enter your test text here.",
type: "any"
};
}
// private methods:
_initUI(el) {
this.resultEl = DOMUtils.query("> header .result", el);
this.resultEl.addEventListener("mouseenter", evt => this._mouseResult(evt));
this.resultEl.addEventListener("mouseleave", evt => this._mouseResult(evt));
this.modeListEl = DOMUtils.query("> header .modelist", el);
let data = ["Text", "Tests"].map(val => ({
label: val,
id: val.toLowerCase()
}));
this.modeList = new List(this.modeListEl, {
data
});
this.modeList.on("change", () => this._handleModeChange());
this.modeList.selected = "text";
let textEl = DOMUtils.query(".editor > .pad", el);
this.defaultText = DOMUtils.query("textarea", textEl).value;
let editor = this.editor = CMUtils.create(DOMUtils.empty(textEl), {
lineWrapping: true
}, "100%", "100%");
editor.setValue(this.defaultText);
editor.on("change", () => this._change());
editor.on("scroll", () => this._update());
editor.on("cursorActivity", () => this._updateSelected());
let detector = DOMUtils.create("iframe", "resizedetector", null, textEl),
win = detector.contentWindow;
let canvas = this.canvas = DOMUtils.create("canvas", "highlights", null, textEl);
textEl.appendChild(editor.display.wrapper); // move the editor on top of the iframe & canvas.
win.onresize = () => {
let w = win.innerWidth | 0,
h = win.innerHeight | 0;
this._startResize();
Utils.defer(() => this._handleResize(w, h), "text_resize", 250);
};
win.onresize();
this.highlighter = new TextHighlighter(editor, canvas, DOMUtils.getCSSValue("match", "color"), DOMUtils.getCSSValue("selected-stroke", "color"));
this.hover = new TextHover(editor, this.highlighter);
}
_handleThemeChange() {
this.highlighter.fill = DOMUtils.getCSSValue("match", "color");
this.highlighter.stroke = DOMUtils.getCSSValue("selected-stroke", "color");
this.highlighter.redraw();
}
_handleModeChange(evt) {
this.dispatchEvent("modechange");
if (this.mode === "text") {
this.editor.refresh();
} else {
DOMUtils.addClass(this.el, "tests-viewed");
}
Track.page("mode/" + this.mode);
}
_setResult(val) {
this._result = val;
this._testMatches = null;
if (this.mode !== val.mode) {
return;
}
if (val.mode === "tests") {
this._updateTests();
} else {
// mode === "text"
this._updateEmptyCount();
this._updateResult();
this._updateSelected();
this._deferUpdate();
}
}
_deferUpdate() {
Utils.defer(() => this._update(), "Text._update");
}
_update() {
let result = this._result,
matches = result && result.matches;
if (result && result.mode === "tests") {
this._updateTests();
} else {
// mode === "text"
this.hover.matches = this.highlighter.matches = matches;
}
}
_updateResult() {
let result = this._result,
matches = result && result.matches,
l = matches && matches.length,
text;
if (l && result && !result.error) {
text = l + " match" + (l > 1 ? "es" : "") + (this._emptyCount ? "*" : "");
} else if (!result || !result.error) {
text = "No match";
}
this._showResult(text);
}
_showResult(text, clss) {
let result = this._result,
el = this.resultEl;
DOMUtils.removeClass(el, "error warning matches pass fail");
if (result && result.error) {
if (!text) {
text = result.error.warning ? "WARNING" : "ERROR";
}
DOMUtils.addClass(el, "error");
if (result.error.warning) {
DOMUtils.addClass(el, "warning");
}
}
if (clss) {
DOMUtils.addClass(el, clss);
}
el.innerHTML = text;
if (result.time != null) {
el.innerHTML += " (" + parseFloat(result.time).toFixed(1) + "ms)";
}
}
_updateSelected() {
let match = this.selectedMatch;
if (this.highlighter.selectedMatch === match) {
return;
}
this.highlighter.selectedMatch = match;
this.dispatchEvent("select");
}
_change() {
this.dispatchEvent("change");
}
_startResize() {
let canvas = this.canvas,
style = canvas.style;
style.visibility = "hidden";
style.opacity = 0;
// keeps it from causing scrollbars:
canvas.width = canvas.height = 1;
}
_mouseResult(evt) {
let tt = app.tooltip.hover,
res = this._result,
err = res && res.error,
str = "";
if (evt.type === "mouseleave") {
return tt.hide("result");
}
if (err && !err.warning) {
str = "EXEC ERROR: " + this._errorText(err);
} else {
if (err && err.warning) {
str = "WARNING: " + this._errorText(err) + "";
}
let l = this._tests.length;
if (this.mode === "tests") {
if (this._tests.length === 0) {
str += "Use the 'Add Test' button to create a new test.";
} else if (this._testFails) {
str += this._testFails + " out of " + l + " tests failed.";
} else {
str += "All " + l + " tests passed.";
}
} else {
str += (l || "No") + " match" + (l > 1 ? "es" : "") + " found in " + this.value.length + " characters";
str += this._emptyCount ? ", including " + this._emptyCount + " empty matches (* not displayed)." : ".";
let cm = this.editor,
sel = cm.listSelections()[0],
pos = sel.head;
let i0 = cm.indexFromPos(pos),
i1 = cm.indexFromPos(sel.anchor),
range = Math.abs(i0 - i1);
str += "Insertion point: line " + pos.line + ", col " + pos.ch + ", index " + i0;
str += range > 0 ? " (" + range + " character" + (range === 1 ? "" : "s") + " selected)" : "";
}
}
tt.showOn("result", str, this.resultEl, false, -2);
}
_updateEmptyCount() {
let result = this._result,
matches = result && result.matches;
this._emptyCount = matches ? matches.reduce((v, o) => v + (o.l ? 0 : 1), 0) : 0;
}
_errorText(err) {
return err.message || app.reference.getError(err);
}
_handleResize(w, h) {
let canvas = this.canvas,
style = canvas.style;
style.visibility = style.opacity = "";
canvas.width = w;
canvas.height = h;
this.editor.refresh();
this._deferUpdate();
}
// Test mode:
_initTestUI(el) {
const types = [{
id: "all",
label: "Match Full"
}, {
id: "any",
label: "Match Any"
},
// {id:"start", label:"Match Start"},
{
id: "none",
label: "Match None"
}];
this.typeLabels = types.reduce((o, t) => {
o[t.id] = t.label;
return o;
}, {});
this.testsEl = DOMUtils.query(".tests", el);
this.testItemEl = DOMUtils.query("#library > #tests_item");
this.testListEl = DOMUtils.query(".list", this.testsEl);
this.testList = new List(this.testListEl, {
template: o => this._testItemTemplate(o)
});
this.testList.scrollEl = this.testsEl;
this.testList.on("change", evt => this._handleTestChange(evt));
DOMUtils.on(DOMUtils.queryAll(".button.add", el), "click", () => this._addTest());
const template = DOMUtils.template` ${"label"}`;
this.typesEl = DOMUtils.query("#library #tooltip-testtypes");
this.typesList = new List(DOMUtils.query("ul.list", this.typesEl), {
data: types,
template
});
this.typesList.on("change", () => this._handleTypesChange());
this.tests = null;
}
_updateTests() {
let result = this._result;
if (result.error) {
return this._showResult();
}
let data = this._tests,
l = data.length;
if (!data || !l) {
return this._showResult("No tests.");
}
let matches = result.matches.reduce((o, t) => {
o[t.id] = t;
return o;
}, {}),
fails = 0;
for (let i = 0; i < l; i++) {
let test = data[i],
match = matches[test.id],
pass = false,
el = this.testList.getEl(test.id);
if (test.type === "none") {
pass = match.i == null;
} else if (test.type === "all") {
pass = match.l === test.text.length;
} else if (test.type === "start") {
pass = match.i === 0;
} else {
// any
pass = match.i != null;
}
DOMUtils.toggleClass(el, "fail", !pass);
if (!pass) {
fails++;
}
}
this._testFails = fails;
this._testMatches = matches;
if (fails) {
this._showResult(fails + " FAILED", "fail");
} else {
this._showResult("PASSED", "pass");
}
this._updateSelTest();
}
_updateSelTest() {
if (this._testMark) {
this._testMark.clear();
}
let matches = this._testMatches,
el = this.testList.selectedEl;
if (!el || !matches) {
return;
}
let match = matches[this.testList.selected],
cm = this.testEditor;
if (match && match.i != null) {
let pos = CMUtils.calcRangePos(cm, match.i, match.l);
this._testMark = this.testEditor.getDoc().markText(pos.startPos, pos.endPos, {
className: "match"
});
}
}
_testItemTemplate(o) {
let el = this.testItemEl.cloneNode(true);
let typeBtn = DOMUtils.query("header .button.type", el);
typeBtn.addEventListener("click", evt => this._showTypes(typeBtn, o));
let delBtn = DOMUtils.query("header .delete", el);
delBtn.addEventListener("click", evt => this._deleteTest(o));
let nameFld = DOMUtils.query("header .name", el);
nameFld.addEventListener("input", () => this._handleTestNameChange(nameFld, o));
this._updateTestHeader(o, el, false);
return el;
}
_updateTestHeader(o, el, edit) {
let nameFld = DOMUtils.query("header .name", el);
nameFld.value = o.name || "";
nameFld.placeholder = o.text && !edit ? o.text.substr(0, 100) : "Untitled Test";
let typeLbl = DOMUtils.query("header .button.type .label", el);
typeLbl.innerText = this.typeLabels[o.type];
}
_addTest() {
const o = this.getEmptyTest();
this._tests.push(o);
this.testList.addItem(o, true);
this._handleTestChange();
this.testEditor.execCommand("selectAll");
DOMUtils.addClass(this.testsEl, "tests-added");
this._change();
}
_reselectTest() {
if (this._selTest) {
this.testList.selected = this._selTest.id;
}
if (!this._selTest || this.testList.selected == null) {
this.testList.selectedIndex = 0;
}
this._selTest = null;
this._handleTestChange();
}
_handleTestChange() {
let el, o;
if (this._selTest) {
o = this._selTest;
el = this.testList.getEl(o.id);
this._updateTestHeader(o, el, false);
}
el = this.testList.selectedEl;
o = this._selTest = this.testList.selectedItem;
if (!o) {
return;
}
this._getTestEditor(DOMUtils.query("article .editor .pad", el), o);
this._updateTestHeader(o, el, true);
this._updateSelTest();
this.testEditor.focus();
this.testEditor.setCursor(this.testEditor.lineCount(), 0);
}
_handleTestNameChange(fld, o) {
o.name = fld.value;
this._change();
}
_handleTypesChange() {
let el = this.testList.selectedEl,
o = this.testList.selectedItem;
o.type = this.typesList.selectedItem.id;
app.tooltip.toggle.hide("testtypes");
this._updateTestHeader(o, el, true);
this._change();
}
_handleTestTextChange(change) {
this._selTest.text = this.testEditor.getValue();
if (change.origin !== "setValue") {
this._change();
}
}
_showTypes(el, o) {
this.typesList.selected = o.type;
app.tooltip.toggle.toggleOn("testtypes", this.typesEl, el, true, -2);
}
_deleteTest(o) {
let data = this._tests;
let i = data.indexOf(o);
data.splice(i, 1);
this._selTest = null;
this.testList.removeItem(o.id);
if (data.length) {
this.testList.selected = data[Math.min(i, data.length - 1)].id;
}
this._updateTests();
this._handleTestChange();
this._change();
}
_getTestEditor(el, o) {
let cm = this.testEditor;
if (!cm) {
cm = this.testEditor = CMUtils.create(DOMUtils.empty(el), {
lineWrapping: true
}, "100%", "100%");
cm.on("change", (a, b) => this._handleTestTextChange(b));
} else {
el.appendChild(cm.getWrapperElement());
}
cm.setValue(o.text);
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Explain {
constructor(el) {
this.el = el;
DOMUtils.addClass(el, "explain");
this._update();
this._bound_handleEvent = evt => this._handleEvent(evt);
app.expression.addEventListener("change", this._bound_handleEvent);
app.expression.highlighter.addEventListener("hover", this._bound_handleEvent);
}
cleanup() {
DOMUtils.empty(this.el);
DOMUtils.removeClass(this.el, "explain");
app.expression.removeEventListener("change", this._bound_handleEvent);
app.expression.highlighter.removeEventListener("hover", this._bound_handleEvent);
}
// private methods:
_update() {
let el = DOMUtils.empty(this.el),
token = app.expression.token,
expr = app.expression.value;
this._divs = [];
if (!token || token.next.type === "close") {
el.innerHTML = "Enter an Expression above and it will be explained here.";
return;
}
el.innerHTML = "Roll-over elements below to highlight in the Expression above. Click to open in Reference.";
while ((token = token.next) && token.type !== "close") {
if (token.proxy || token.open && token.open.proxy) {
continue;
}
let groupClasses = ExpressionHighlighter.GROUP_CLASS_BY_TYPE,
pre = ExpressionHighlighter.CSS_PREFIX;
let i = token.i,
end = token.i + token.l,
content = expr.substring(i, end).replace("<", "<");
if (token.set) {
let set0 = token.set[0],
set2 = token.set[2];
content = "" + expr.substring(set0.i, set0.i + set0.l) + "";
content += expr.substring(i, end);
content += "" + expr.substring(set2.i, set2.i + set2.l) + "";
}
let className = pre + (token.clss || token.type);
content = "" + content + " ";
if (!token.open) {
content += app.reference.tipForToken(token);
} else {
content += " ";
}
let div = DOMUtils.create("div", null, content, el);
if (token.close) {
className = groupClasses[token.clss || token.type];
if (className) {
className = className.replace("%depth%", Math.min(4, token.depth));
DOMUtils.addClass(div, className);
}
if (token.depth > 3) {
div.innerHTML = "So... you wanted to see what would happen if you just kept nesting groups, eh? Well, this is it." + " I was going to reward your curiosity with a RegEx joke, but a quick search on google reveals that not even" + " the collective wisdom of the internet can make regular expressions funny. Well, except the whole 'now you've got two problems'" + " shtick, but you've probably heard that one already. Wasn't really worth the effort, was it?";
token = token.close.prv;
this._divs.push(div);
el = div;
continue;
}
el = div;
}
div.token = token;
if (token.open) {
DOMUtils.addClass(div, "close");
div.proxy = el;
el = el.parentNode;
}
if (token.error) {
DOMUtils.addClass(div, "error");
if (token.error.warning) {
DOMUtils.addClass(div, "warning");
}
}
if (!token.open) {
div.addEventListener("mouseover", this._handleMouseEvent);
div.addEventListener("mouseout", this._handleMouseEvent);
div.addEventListener("click", this._handleMouseEvent);
}
if (token.clss === "quant" || token.type === "lazy" || token.type === "possessive") {
this._insertApplied(div);
} else {
this._divs.push(div);
}
}
}
_insertApplied(div) {
let divs = this._divs,
prv = div.token.prv,
d,
i = divs.length;
while ((d = divs[--i]) && d.token !== prv) {} // search backwards for efficiency
d = d.proxy || d;
divs.splice(i, 0, div);
d.insertAdjacentElement("afterend", div);
DOMUtils.addClass(div, "applied");
}
_handleHoverChange() {
let token = app.expression.highlighter.hoverToken;
DOMUtils.removeClass(DOMUtils.queryAll("div.selected", this.el), "selected");
DOMUtils.removeClass(DOMUtils.queryAll("div.related", this.el), "related");
if (!token) {
return;
}
let div = this._findDiv(token);
DOMUtils.addClass(div, "selected");
if (token.related) {
for (let i = 0, l = token.related.length; i < l; i++) {
DOMUtils.addClass(this._findDiv(token.related[i]), "related");
}
}
}
_findDiv(token) {
return Utils.find(this._divs, div => div.token === token);
}
_handleMouseEvent(evt) {
let type = evt.type,
token = evt.currentTarget.token;
if (type == "click") {
app.sidebar.showToken(token);
} else {
app.expression.highlighter.hoverToken = type === "mouseout" ? null : token;
}
evt.stopPropagation();
}
_handleEvent(evt) {
if (evt.type === "change") {
this._update();
} else if (evt.type === "hover") {
this._handleHoverChange();
}
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Details {
constructor(el) {
this.el = el;
DOMUtils.addClass(el, "details");
this._update();
this._bound_handleEvent = evt => this._handleEvent(evt);
app.addEventListener("result", this._bound_handleEvent);
app.text.addEventListener("select", this._bound_handleEvent);
}
cleanup() {
DOMUtils.empty(this.el);
DOMUtils.removeClass(this.el, "details");
app.removeEventListener("result", this._bound_handleEvent);
app.text.removeEventListener("select", this._bound_handleEvent);
Utils.defer(null, "Details._update");
}
// private methods:
_update() {
DOMUtils.empty(this.el);
DOMUtils.create("div", "desc", "Click a match above to display match & group details. Mouse over a Group row to highlight it in the Expression.", this.el);
this._addMatch(app.text.selectedMatch, app.text.value);
}
_addMatch(match, textVal) {
if (!match) {
return;
}
let groups = match.groups,
l = groups && groups.length,
ext = l && groups[0].i != null,
matchVal = this._getMatchVal(match, textVal),
extStr = "",
me = match.i + match.l;
let groupTokens = app.expression.lexer.captureGroups;
let tableEl = DOMUtils.create("table", null, null, this.el);
let matchEl = DOMUtils.create("tr", "match", "
Match " + match.num + "
" + this._getRangeStr(match) + "
", tableEl);
if (l) {
let inGroups = [],
lastIndex = match.i;
for (let i = 0; i <= l; i++) {
let group = groups[i],
index = group ? group.i : me,
num = i + 1,
token = groupTokens[i];
if (ext) {
for (let j = inGroups.length - 1; j >= 0; j--) {
let inGroup = inGroups[j],
ge = inGroup.i + inGroup.l;
if (ge > index) {
break;
}
inGroups.pop();
extStr += Utils.htmlSafe(textVal.substring(lastIndex, ge)) + "";
lastIndex = ge;
}
}
if (!group) {
break;
}
if (group.l) {
extStr += Utils.htmlSafe(textVal.substring(lastIndex, index)) + "";
inGroups.push(group);
lastIndex = index;
}
let val = "" + this._getMatchVal(group, textVal) + "";
let label = token.name ? "'" + token.name + "'" : "Group " + num;
let tr = DOMUtils.create("tr", "group", "
", tableEl);
}
DOMUtils.query("td:last-child", matchEl).innerHTML = extStr || matchVal;
}
_getMatchVal(match, str) {
let val = match.s || (match.i === undefined ? "" : str.substr(match.i, match.l));
return val ? Utils.htmlSafe(val) : "<empty>";
}
_getRangeStr(match) {
// we could check for match.l>0 to catch empty matches, but having a weird range might be more accurate.
return match.i != null ? match.i + "-" + (match.i + match.l - 1) : "n/a";
}
_handleEvent(evt) {
Utils.defer(() => this._update(), "Details._update");
}
_handleMouseEvent(evt) {
let type = evt.type,
token = evt.currentTarget.token;
app.expression.highlighter.hoverToken = type === "mouseout" ? null : token;
if (type === "mouseover") {
DOMUtils.addClass(DOMUtils.query("span.num-" + token.num, this.el), "hover");
} else {
DOMUtils.removeClass(DOMUtils.query("span.hover", this.el), "hover");
}
evt.stopPropagation();
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Replace {
constructor(el, cm) {
this.el = el;
this.editor = cm;
this._bound_handleEvent = evt => this._handleEvent(evt);
app.addEventListener("result", this._bound_handleEvent);
this._initUI();
this._update();
}
cleanup() {
DOMUtils.empty(this.el);
this.output.value = "";
DOMUtils.removeClass(this.el, "details");
app.removeEventListener("result", this._bound_handleEvent);
Utils.defer(null, "Replace._update");
}
// private methods:
_initUI() {
this.output = DOMUtils.create("textarea", null, null, this.el);
this.output.readOnly = true;
}
_update() {
let o = app.result && app.result.tool,
result = o && o.result;
this.output.value = result || "no result";
}
_handleEvent(evt) {
Utils.defer(() => this._update(), "Replace._update");
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class SubstLexer {
constructor() {
this.profile = null;
}
set profile(profile) {
this._profile = profile;
this.string = this.token = this.errors = null;
}
parse(str) {
if (!this._profile) {
return null;
}
this.token = null;
this.string = str;
this.errors = [];
// TODO: should this be passed in from Tools?
let capGroups = app.expression.lexer.captureGroups;
let prev = null,
token,
c;
for (let i = 0, l = str.length; i < l; i += token.l) {
c = str[i];
token = {
prev: prev,
i: i,
l: 1,
subst: true
};
if (c === "$" && i + 1 < l) {
this.parseDollar(str, token, capGroups);
} else if (c == "\\" && i + 1 < l) {
this.parseBackSlash(str, token, capGroups);
}
if (!token.type) {
token.type = "char";
token.code = c.charCodeAt(0);
}
if (prev) {
prev.next = token;
}
if (!this.token) {
this.token = token;
}
if (token.error) {
// SubstLexer currently doesn't generate any errors.
this.errors.push(token.error);
}
prev = token;
}
return this.token;
}
parseBackSlash(str, token, capGroups) {
let match,
sub = str.substr(token.i),
profile = this._profile;
if (profile.substTokens.subst_bsgroup && (match = sub.match(/^\\(\d\d?)/))) {
this._getRef(match[1], token, capGroups, "subst_bsgroup");
} else if (match = sub.match(SubstLexer.SUBST_ESC_RE)) {
if (match[1][0] === "u") {
token.type = "escunicode";
token.code = parseInt(match[2], 16);
} else {
token.code = profile.escCharCodes[match[1]];
token.type = "esc_" + token.code;
}
if (token.type) {
token.clss = "esc";
token.l += match[1].length;
}
}
}
parseDollar(str, token, capGroups) {
// Note: Named groups are not supported in PCRE or JS.
let match = str.substr(token.i + 1).match(/^([$&`']|\d\d?|{\d\d?})/);
if (!match) {
return;
}
let d = match[1],
type = SubstLexer.$_TYPES[d],
profile = this._profile;
if (type) {
if (!profile.substTokens[type]) {
return;
}
token.type = type;
token.clss = "subst";
token.l += d.length;
} else {
this._getRef(d, token, capGroups, d[0] === "{" ? "subst_$bgroup" : "subst_$group");
}
}
_getRef(numStr, token, capGroups, type) {
if (!this._profile.substTokens[type]) {
return;
}
let num = parseInt(numStr.match(/\d\d?/)[0]),
l = 0;
if (!this._profile.config.substdecomposeref || capGroups[num - 1]) {
l = numStr.length;
} else if (num >= 10 && capGroups[(num = num / 10 | 0) - 1]) {
l = numStr.length - 1;
}
if (l) {
token.l += l;
// we don't assign the original type, because the docs combine them all into one id:
token.type = num > 0 ? "subst_group" : "subst_0match";
token.clss = "subst";
if (num > 0) {
token.group = capGroups[num - 1];
}
}
}
}
SubstLexer.$_TYPES = {
"$": "subst_$esc",
"&": "subst_$&match",
"`": "subst_$before",
"'": "subst_$after",
"0": "subst_0match"
};
SubstLexer.SUBST_ESC_RE = new RegExp("^" + Utils.SUBST_ESC_RE.source, "i");
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Tools extends EventDispatcher {
constructor(el) {
super();
this.el = el;
this._initUI();
this.value = null;
}
set value(o) {
if (!o) {
this.show("explain");
this._toolValues = Utils.copy({}, Tools.DEFAULT_VALUES);
} else {
this.show(o.id);
if (o.input != null) {
this.editor.setValue(o.input);
}
}
}
get value() {
return {
id: this._toolId,
input: this.input
};
}
get input() {
return this.hasInput ? this.editor.getValue() : null;
}
get hasInput() {
let id = this._toolId;
return id === "replace" || id === "list";
}
show(id) {
if (!id || id === this._toolId) {
return;
}
this.toolList.selected = this._toolId = id;
let input = id === "replace" || id === "list";
if (this._tool) {
this._tool.cleanup();
}
DOMUtils.toggleClass(DOMUtils.query("> article", this.el), "showinput", input);
if (input) {
this.editor.setValue(this._toolValues[id]);
this.editor.refresh();
this.editor.focus();
}
if (id === "explain") {
this._tool = new Explain(this.contentEl);
} else if (id === "details") {
this._tool = new Details(this.contentEl);
} else if (id === "replace" || id === "list") {
this._tool = new Replace(this.resultEl, this.editor);
}
this._toolId = id;
this._updateHighlights();
}
_initUI() {
let el = this.el;
this.headerEl = DOMUtils.query("header", this.el);
this.headerEl.addEventListener("click", evt => this._handleHeaderClick(evt));
this.contentEl = DOMUtils.query("> article > .content", el);
this.resultEl = DOMUtils.query("> article > .inputtool > .result", el);
this.toolListEl = DOMUtils.query(".toollist", this.headerEl);
let data = ["Replace", "List", "Details", "Explain"].map(val => ({
label: val,
id: val.toLowerCase()
}));
this.toolList = new List(this.toolListEl, {
data
});
this.toolList.on("change", () => this._handleListChange());
let editor = this.editor = CMUtils.create(DOMUtils.query(".inputtool .editor", el), {
maxLength: 2500,
singleLine: true
}, "100%", "100%");
DOMUtils.query(".help.icon", el).addEventListener("click", () => app.sidebar.goto(this._toolId));
// TODO: evaluate this living here or in Replace:
editor.on("change", () => this._handleEditorChange());
app.flavor.on("change", () => this._updateHighlights());
app.expression.on("change", () => this._updateHighlights());
this.lexer = new SubstLexer();
this.highlighter = new ExpressionHighlighter(editor);
this.hover = new ExpressionHover(editor, this.highlighter);
}
_handleEditorChange() {
this._updateHighlights();
this._toolValues[this._toolId] = this.editor.getValue();
this.dispatchEvent("change");
}
_updateHighlights() {
if (!this.hasInput) {
return;
} // only for Replace & List
this.lexer.profile = app.flavor.profile;
let token = this.lexer.parse(this.editor.getValue());
this.highlighter.draw(token);
this.hover.token = token;
}
_handleListChange() {
this.show(this.toolList.selected);
Track.page("tool/" + this.toolList.selected);
}
_handleHeaderClick(evt) {
if (DOMUtils.hasClass(this.el, "closed") || !this.toolListEl.contains(evt.target)) {
DOMUtils.togglePanel(this.el, 'article');
}
}
}
Tools.DEFAULT_VALUES = {
replace: "<< $& >>",
list: "$&\\n"
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
let home = {};
home.id = "home";
home.label = "Menu";
home.desc = "[from HTML]";
home.kids = [{
label: "Pattern Settings",
id: "share",
el: "#share_main",
list: false,
kids: [{
label: "Save to my Favorites",
id: "share_favorites",
el: "#share_favorites"
}, {
label: "Share with the Community",
id: "share_community",
el: "#share_community"
}]
}, {
label: "My Patterns",
id: "favorites",
desc: "The list above will display any patterns that you create or favorite." + "
To edit a pattern you created, click its URL or double-click it in the list to load it, then open Save / Share to edit and save.
",
search: true,
kids: []
}, {
label: "Cheatsheet",
id: "cheatsheet",
el: "#cheatsheet"
}, {
// injected from Reference
id: "reference"
}, {
label: "Community Patterns",
id: "community",
desc: "Welcome to Community Patterns, a searchable database of patterns submitted by users like you." + "
After selecting a pattern, click its URL or double-click it in the list to load the full pattern. Or use the right arrow icon to load just the expression or text.
" + "
Help make the Community better by rating patterns, and submitting your own via Search & Share in the menu.
",
search: true,
kids: []
}, {
label: "Help",
id: "help",
desc: "Help for the RegExr application. See the RegEx Reference for help with Regular Expressions.",
kids: [{
label: "About",
desc: "RegExr v3.8.0 (May 10, 2024)." + "
"
}, {
label: "Getting started",
desc: "RegExr provides real-time visual results, syntax highlighting, tooltips, and undo/redo ({{getCtrlKey()}}-Z / Y) so it's easy and fun to explore Regular Expressions." + "
Browse through the RegEx Reference and test different tokens to see what they do, then check out Community Patterns to see examples.
" + "
You can also Save your patterns for later reference, or to share with others. Sign In to ensure you don't lose your patterns.
" + "
Modify your pattern's details, share it with the Community, or make it private, or delete it in Pattern Settings
",
kids: [{
label: "Expression panel",
desc: "This is where you enter a regular expression to test. The results in the Text and Tools panel will update as you type." + "Roll over the expression for information on each token." + "
The buttons to the right allow you to switch RegEx engines, or edit the expression flags.
"
}, {
label: "Text panel",
desc: "This is where you enter text to test your expression against. Drag & drop a text file to load its contents." + "
Matches will be highlighted as you type. Roll over a match for information on the match and its capture groups. The match count and execution time are shown in the title bar.
" + "
Lighter colored caps at the start or end of a line indicate the match continues between lines.
"
}, {
label: "Tests panel",
desc: "This allows you to create a suite of tests that you can use to validate your Expression in real time." + "
A test can check if the pattern matches anything, matches everything, or matches nothing in the test text.
" + "
Access this panel with the toggle at the top of the Text panel. When you save, both your Text and Tests will be saved.
"
}, {
label: "Tools panel",
desc: "Click the Tools title bar below the Text panel to show or hide the Tools panel." + "
Tools provide different ways of working with or exploring your results.
",
kids: [{
label: "Replace",
id: "replace",
desc: "The Replace tool replaces matches with a specified string or pattern." + "
Matches in the Text panel are replaced by the substitution string & displayed as you type.
" + "
Substitution tokens and escaped characters are supported, such as \\n, \\t & \\u0009.
" + "
Roll over tokens for information, and check out the RegEx Reference for more information.
"
}, {
label: "List",
id: "list",
desc: "The List tool lists all found matches." + "
You can specify either a simple delimiter (ex. , or \\n), or use substitution tokens to generate more advanced reports. For example, $1\\n would list all group 1 results (in the JavaScript engine).
" + "
Escaped characters are supported, such as \\n, \\t & \\u0009.
" + "
Roll over tokens for information.
"
}, {
label: "Details",
id: "details",
desc: "The Details tool displays the full text of a match and its capture groups." + "
Click on a highlighted match in the Text panel to display the details for that match.
" + "
Roll over a group row to highlight that group in your Expression.
"
}, {
label: "Explain",
id: "explain",
desc: "The Explain tool displays a detailed breakdown of the Expression." + "
Mouse over the explanation to highlight the related tokens in the Expression panel and vice versa.
" + "
Click an item in the explanation to show more info in the RegEx Reference.
"
}]
}, {
label: "Menu",
desc: "The Menu (this panel) includes Help, a full RegEx Reference, a Cheatsheet, and Pattern Settings features." + "
Double-click a selected item in the RegEx Reference to insert it into your Expression. Click the arrow beside an example to load it.
" + "
The menu also includes searchable Community Patterns, and patterns you've created or favorited in My Patterns.
"
}]
}, {
label: "Signing in",
id: "signin",
desc: "Before you sign in, RegExr creates a temporary account which relies on a browser cookie. This means you can't access your patterns on other computers, and that you could lose your patterns if your cookies are deleted or expire." + "
Signing in creates a permanent account, so you can access your patterns anywhere, anytime.
" + "
Your existing patterns & favorites will automatically be assigned to the new account.
" + "
We don't use your info for anything other than signing you into your RegExr account.
"
}, {
id: "engine",
label: "RegEx engines",
desc: "While the core feature set of regular expressions is fairly consistent, different implementations (ex. Perl vs Java) may have different features or behaviours." + "
RegExr currently supports JavaScript RegExp executed in your browser and PCRE via PHP.
" + "
You can switch engines using the dropdown in Expression.
",
kids: [{
label: "JavaScript",
desc: "Your browser's JavaScript engine is used to execute RegEx in an asynchronous worker using RegExp.exec()." + "
Note that while implementations are mostly consistent, there are small variations between browsers. Here is a short list of known differences:
" + "
Older browsers don't support the u or y flags
" + "
Differences in handling of certain ambiguous escapes: \\8 \\9
" + "
Chrome handles \\x & \\u escapes slightly differently than other browsers
" + "
Chrome supports lookbehind, but it isn't yet in the JS spec
" + "
Safari ignores leading zeros in octal escapes (ex. \\00020)
" + "
"
}, {
label: "PCRE (PHP)",
desc: "PHP {{getPHPVersion()}} and PCRE {{getPCREVersion()}} are used to execute your pattern on our server."
}]
}, {
label: "Query string support",
desc: "In addition to the built in Save mechanism which creates a shareable link, RegExr also supports the ability to pre-populate a pattern via the query string." + "
The following query string params are recognized:
" + "
engine - the RegEx engine to use (js or pcre)
" + "
expression - populates the Expression area. It is recommended to pass a full expression with flags (/.*/ig) not just the pattern (.*)
" + "
text - populates the Text area
" + "
tool - sets the tool (replace, list, details, or explain)
" + "
input - populates the tool input field
" + "
" + "Ex. regexr.com/?expression=/./g&text=test"
}]
}];
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class LinkRow {
constructor(el) {
this.el = el;
this._initUI();
this.url = null;
}
set pattern(val) {
let url = Utils.getPatternURLStr(val);
this._pattern = val;
DOMUtils.query(".url", this.el).innerText = url || "";
DOMUtils.toggleClass(this.el, "disabled", !url);
DOMUtils.toggleClass(this.el, "active", !!url);
}
showMessage(message) {
// for some reason this displays one line too low if it's synchronous:
setTimeout(() => app.tooltip.toggle.showOn("linkrow", message, DOMUtils.query(".copy.icon", this.el), true, 0), 1);
}
_initUI() {
this.el.onclick = evt => this._onClick(evt);
let fld = DOMUtils.query(".url", this.el),
copyBtn = DOMUtils.query(".copy", this.el);
let clipboard = new Clipboard(copyBtn, {
target: () => fld
});
clipboard.on("success", () => app.tooltip.toggle.toggleOn("copy", "Copied to clipboard.", copyBtn, true, 3));
clipboard.on("error", e => app.tooltip.toggle.toggleOn("copy", Utils.getCtrlKey() + "-C to copy.", copyBtn, true, 3)); // TODO: cmd/ctrl
}
_onClick(evt) {
if (DOMUtils.query(".copy", this.el).contains(evt.target)) {
return;
}
if (evt.which === 2 || evt.metaKey || evt.ctrlKey) {
window.open(Utils.getPatternURL(this._pattern));
} else {
app.load(this._pattern);
}
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Example {
constructor(title, ex) {
this.el = DOMUtils.create("div", "example");
this.title = title;
this.example = ex;
}
set example(ex) {
if (ex === this._example) {
return;
}
this._example = ex;
let str = "",
txt,
exp,
regex;
if (ex) {
exp = ex[0];
txt = ex[1];
regex = Utils.getRegExp(exp, "g");
if (this.title) {
str += "
" + this.title + "
";
}
str += "" + Utils.htmlSafe(exp) + "";
if (txt && regex) {
let over = Math.max(0, txt.length - 160),
s = txt;
if (over) {
s = Utils.htmlSafe(s.substr(0, 159));
}
if (regex) {
s = s.replace(regex, "$&");
}
// TODO: this won't match on html elements:
str += "" + s + (over ? "\u2026" : "") + "";
}
}
this.el.innerHTML = str;
if (exp) {
DOMUtils.query("code.expression > .load", this.el).addEventListener("click", () => {
// TODO: this will need to be updated when we support other delimiters:
app.expression.value = exp[0] === "/" ? exp : "/" + exp + "/g";
});
}
if (txt) {
DOMUtils.query("code.text > .load", this.el).addEventListener("click", () => app.text.value = txt);
}
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
// also used for My Patterns.
class CommunityContent {
constructor(el) {
this.el = el;
this.example = new Example();
el.appendChild(this.example.el);
DOMUtils.query(".icon.thumbup", el).addEventListener("click", () => this._rate(1));
DOMUtils.query(".icon.thumbdown", el).addEventListener("click", () => this._rate(-1));
DOMUtils.query(".icon.favorites", el).addEventListener("click", () => this._favorite());
this.linkRow = new LinkRow(DOMUtils.query(".row.link", el));
DOMUtils.query(".icon.share", el).addEventListener("click", () => this._share());
}
set item(o) {
let el = this.el;
this._pattern = o;
DOMUtils.query(".author", el).innerText = o.author ? "by " + o.author : "";
DOMUtils.query(".name.label", el).innerText = o.name;
DOMUtils.query(".desc", el).innerText = o.description || "No description available.";
this._updateRating();
this._updateFavorite();
this.example.example = [o.expression, o.text];
this.linkRow.pattern = o;
}
// private methods:
_updateRating() {
let o = this._pattern,
el = this.el;
DOMUtils.query(".rating", el).innerText = o.rating.toFixed(1);
DOMUtils.removeClass(DOMUtils.query(".icon.rate.selected", el), "selected");
if (o.userRating === 1) {
DOMUtils.addClass(DOMUtils.query(".icon.thumbup", el), "selected");
} else if (o.userRating === -1) {
DOMUtils.addClass(DOMUtils.query(".icon.thumbdown", el), "selected");
}
}
_updateFavorite() {
let o = this._pattern,
el = this.el;
DOMUtils.toggleClass(DOMUtils.query(".icon.favorites", el), "selected", !!o.favorite);
}
_rate(val) {
let o = this._pattern;
o.userRating = val === o.userRating ? 0 : val;
this._updateRating();
Server.rate(o.id, o.userRating).then(data => this._handleRate(data));
}
_share() {
app.load(this._pattern);
app.share.show();
}
_handleRate(data) {
if (data.id === this._pattern.id) {
this._pattern.rating = data.rating;
this._updateRating();
}
}
_favorite() {
let o = this._pattern;
Server.favorite(o.id, !o.favorite).then(data => this._handleFavorite(data));
}
_handleFavorite(data) {
if (data.id === this._pattern.id) {
this._pattern.favorite = data.favorite;
this._updateFavorite();
}
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Status {
constructor(el) {
if (!el) {
el = document.createElement("div");
}
this.el = el;
DOMUtils.addClass(el, "status");
el.addEventListener("mouseover", () => this._showTooltip());
el.addEventListener("mouseout", () => this._hideTooltip());
}
distract() {
this.el.innerHTML = '';
this._show();
return this;
}
hide(t = 0) {
this._clearTimeout();
if (t) {
this._timeoutId = setTimeout(() => this._hide(), t * 1000);
} else {
this._hide();
}
return this;
}
success() {
this.el.innerHTML = '';
this._show();
return this;
}
error(msg) {
let el = this.el;
el.innerHTML = '';
this._show();
this._ttMsg = msg;
return this;
}
_showTooltip() {
if (!this._ttMsg) {
return;
}
app.tooltip.hover.showOn("status", this._ttMsg, this.el, true, 0);
}
_hideTooltip() {
app.tooltip.hover.hide("status");
}
_show() {
this.el.style.display = null;
this._ttMsg = null;
this._hideTooltip();
this._clearTimeout();
}
_hide() {
this.el.style.display = "none";
this._hideTooltip();
this._clearTimeout();
}
_clearTimeout() {
if (this._timeoutId == null) {
return;
}
clearTimeout(this._timeoutId);
this._timeoutId = null;
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Account extends EventDispatcher {
constructor() {
super();
this._value = {};
this._initUI();
}
get value() {
return this._value;
}
set value(val = {}) {
this._value = val;
this._updateUI();
this.dispatchEvent("change");
}
get userId() {
return this._value.userId;
}
get author() {
return this._value.author || this._value.username || "";
}
get username() {
return this._value.username || "";
}
get authenticated() {
return !!this._value.username;
} // this._value.authenticated;
get type() {
return this._value.type;
}
showTooltip() {
app.tooltip.toggle.toggleOn("signin", this.tooltipEl, this.signinBtn, true, 20);
}
// private methods:
_initUI() {
let template = o => '' + o;
this.signinBtn = DOMUtils.query(".header .signin");
this.tooltipEl = DOMUtils.query("#library > #tooltip-signin");
this.signinEl = DOMUtils.query(".signin", this.tooltipEl);
this.signoutEl = DOMUtils.query(".signout", this.tooltipEl);
DOMUtils.query(".signoutbtn", this.signoutEl).addEventListener("click", evt => this._doSignout());
this.signinBtn.addEventListener("click", evt => this.showTooltip());
DOMUtils.query(".icon.help", this.signinEl).addEventListener("click", () => app.sidebar.goto("signin"));
this.signinList = new List(DOMUtils.query("ul.list", this.signinEl), {
data: ["GitHub", "Google"],
template
});
this.signinList.on("change", () => this._signinListChange());
}
_updateUI() {
let auth = this.authenticated;
DOMUtils.toggleClass(this.tooltipEl, "authenticated", auth);
DOMUtils.query(".label", this.signinBtn).innerText = auth ? "Sign Out" : "Sign In";
if (auth) {
DOMUtils.query(".username", this.signoutEl).innerText = this.username;
DOMUtils.query(".type", this.signoutEl).innerText = this.type;
}
}
_doSignout() {
DOMUtils.addClass(this.tooltipEl, "wait");
Server.logout().then(data => {
this._handleSignout(data);
}).finally(() => this._cleanSignout());
}
_handleSignout(data) {
this.value = data;
}
_cleanSignout(err) {
DOMUtils.removeClass(this.tooltipEl, "wait");
}
_signinListChange() {
let service = this.signinList.selected.toLowerCase();
DOMUtils.addClass(this.tooltipEl, "wait");
Track.event("login", "access", service);
setTimeout(() => Server.login(service), 100);
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Share extends EventDispatcher {
constructor(el) {
super();
this.el = el;
this._pattern = false;
this._initUI();
app.on("change", () => this._handleAppChange());
app.on("load", () => this._handleAppLoad());
app.account.on("change", () => this._handleAccountChange());
}
// public methods:
get value() {
return {
id: this._pattern ? this._pattern.id : null,
name: this.name,
author: this.author,
description: this.description,
keywords: this.keywords
};
}
set pattern(o) {
this._pattern = o;
this.name = o.name;
this.description = o.description;
this.keywords = o.keywords;
this._updateUI();
this._pushHistory(o);
}
get name() {
return this.nameFld.value;
}
set name(val) {
this.nameFld.value = val || "";
this.hNameFld.innerText = val || "Untitled Pattern";
}
get author() {
return this.authorFld.value;
}
set author(val) {
this.authorFld.value = val || "";
}
get description() {
return this.descriptionFld.value;
}
set description(val) {
this.descriptionFld.value = val || "";
}
get keywords() {
return this.keywordsFld.value;
}
set keywords(val) {
this.keywordsFld.value = val || "";
}
show() {
app.sidebar.goto("share");
}
// private methods:
_initUI() {
let el = this.el;
let mainEl = this.mainEl = DOMUtils.query("> #share_main", el);
let comEl = this.communityEl = DOMUtils.query("> #share_community", el);
// set up header:
let hEl = DOMUtils.query(".header");
this.hNewBtn = DOMUtils.query(".new", hEl);
this.hForkBtn = DOMUtils.query(".fork", hEl);
this.hSaveBtn = DOMUtils.query(".save", hEl);
this.hNameFld = DOMUtils.query(".name", hEl);
DOMUtils.query(".settings", hEl).addEventListener("click", () => this.show());
DOMUtils.query(".savekey", this.hSaveBtn).innerText = "(" + Utils.getCtrlKey() + "-s)";
this.hSaveBtn.addEventListener("click", () => this._doSave());
this.hNewBtn.addEventListener("click", () => this._doNew());
this._defaultName = this.hNameFld.innerText;
// set up main:
this._privateRow = DOMUtils.query(".row.private", this.mainEl);
this._privateRow.addEventListener("click", () => this._doPrivate());
this._privateStatus = new Status(DOMUtils.query(".status", this._privateRow));
this._favoritesRow = DOMUtils.query(".row.favorites", this.mainEl);
this._favoritesRow.addEventListener("click", () => this._doFavorite());
this._favoritesStatus = new Status(DOMUtils.query(".status", this._favoritesRow));
this._communityRow = DOMUtils.query(".row.community", this.mainEl);
this._communityRow.addEventListener("click", () => this._showCommunity());
this._deleteRow = DOMUtils.query(".row.delete", this.mainEl);
this._deleteRow.addEventListener("click", () => this._doDelete());
this._deleteStatus = new Status(DOMUtils.query(".status", this._deleteRow));
DOMUtils.query(".row.signin a", this.mainEl).addEventListener("click", () => this._doSignin());
// set up link row:
this._linkRow = new LinkRow(DOMUtils.query(".link.row", mainEl));
// set up save buttons:
let saveEl = this.saveEl = DOMUtils.query("> .save", mainEl);
this.saveBtn = DOMUtils.query(".button.save", saveEl);
this.forkBtn = DOMUtils.query(".button.fork", saveEl);
this.saveBtn.addEventListener("click", () => this._doSave());
this.forkBtn.addEventListener("click", () => this._doSave(true));
this.saveStatus = new Status(DOMUtils.query(".status", saveEl));
this.saveMessage = DOMUtils.query(".message", saveEl);
// set up input fields:
let infoEl = this.infoEl = DOMUtils.query("> .info", mainEl);
this.nameFld = DOMUtils.query(".name", infoEl);
this.authorFld = DOMUtils.query(".author", infoEl);
this.descriptionFld = DOMUtils.query(".description", infoEl);
this.keywordsFld = DOMUtils.query(".keywords", infoEl);
// listen for changes:
this.nameFld.addEventListener("input", () => this._handleChange());
this.authorFld.addEventListener("input", () => this._handleChange());
this.descriptionFld.addEventListener("input", () => this._handleChange());
this.keywordsFld.addEventListener("input", () => this._handleChange());
/// set up community:
let comInputsEl = DOMUtils.query(".inputs", comEl);
DOMUtils.query(".button.cancel", comEl).addEventListener("click", () => app.sidebar.goto("share"));
DOMUtils.query(".button.share", comEl).addEventListener("click", () => this._doComSave());
this.comSaveStatus = new Status(DOMUtils.query(".status", comEl));
this._comNameFld = DOMUtils.query(".name", comInputsEl);
this._comAuthorFld = DOMUtils.query(".author", comInputsEl);
this._comDescriptionFld = DOMUtils.query(".description", comInputsEl);
this._comKeywordsFld = DOMUtils.query(".keywords", comInputsEl);
// set up cmd-s listener:
window.document.addEventListener("keydown", evt => this._handleKey(evt));
}
_updateUI() {
let o = this._pattern,
text;
let isChanged = this._isChanged(),
isNew = this._isNew(),
isOwned = this._isOwned();
DOMUtils.toggleClass([this.forkBtn, this.hForkBtn], "disabled", !this._canFork());
DOMUtils.toggleClass(this.saveBtn, "disabled", !this._canSave());
DOMUtils.toggleClass(this.hSaveBtn, "disabled", !this._canSave() && isOwned);
DOMUtils.query(".action", this.hSaveBtn).innerText = isOwned ? "Save" : "Fork";
if (!isOwned) {
text = "This pattern was created by '" + (o.author || "[anonymous]") + "'.";
} else if (!isChanged) {
text = "No unsaved changes.";
} else if (isNew) {
text = "Save will create a shareable public link.";
} else {
text = "Save will update the current link.";
}
if (!isOwned && !isChanged) {
text += " Fork to create your own copy.";
} else if (!isNew) {
text += " Fork will create a new copy" + (isChanged ? " with your changes." : ".");
}
this._setSaveText(text);
this._linkRow.pattern = this._pattern.id && this._pattern;
DOMUtils.toggleClass(this._privateRow, "disabled", isNew || !isOwned);
DOMUtils.toggleClass(this._favoritesRow, "disabled", isNew || !isOwned);
DOMUtils.toggleClass(this._communityRow, "disabled", isNew || !isOwned);
DOMUtils.toggleClass(this._deleteRow, "disabled", isNew || !isOwned);
DOMUtils.toggleClass(this._privateRow, "active", o.access === "private");
DOMUtils.toggleClass(this._favoritesRow, "active", !!o.favorite);
}
_isNew() {
return !this._pattern.id;
}
_isOwned() {
let o = this._pattern;
return this._isNew() || o.userId === app.account.userId;
}
_isChanged() {
return app.unsaved;
}
_canSave() {
return this._isChanged() && this._isOwned();
}
_canFork() {
return !this._isNew();
}
_pushHistory(pattern) {
let history = window.history,
url = Utils.getPatternURL(pattern);
let title = "RegExr: " + (pattern.name || "Learn, Build, & Test RegEx");
if (history.state && pattern.id === history.state.id) {
history.replaceState(pattern, title, url);
} else {
history.pushState(pattern, title, url);
}
window.document.title = title;
}
_handleKey(evt) {
let mac = Utils.isMac();
if (evt.key === "s" && (mac && evt.metaKey || !mac && evt.ctrlKey)) {
this._doSave(false);
evt.preventDefault();
}
}
_doSave(fork) {
// if we can't save for some reason, then show the panel.
if (!fork && !this._canSave()) {
app.sidebar.goto("share");
return;
}
if (fork && !this._canFork()) {
return;
}
let o = app.state;
DOMUtils.addClass(DOMUtils.query(".buttons", this.saveEl), "wait");
this.saveStatus.distract();
Server.save(o, fork).then(data => this._handleSave(data)).catch(err => this._handleSaveErr(err));
}
_handleSave(data) {
let isNew = this._pattern.id == null,
isFork = !isNew && data.id !== this._pattern.id;
DOMUtils.removeClass(DOMUtils.query(".buttons", this.saveEl), "wait");
this.saveStatus.hide();
app.state = data;
if (isFork || isNew) {
this.show();
if (isFork || !this.name) {
this.nameFld.focus();
this.nameFld.select();
}
this._linkRow.showMessage("Saved. New share link created. Click to copy to clipboard.");
}
}
_handleSaveErr(err) {
DOMUtils.removeClass(DOMUtils.query(".buttons", this.saveEl), "wait");
this.saveStatus.error(this._getErrMsg(err));
}
_doNew() {
app.newDoc();
}
_doPrivate() {
let o = this._pattern;
this._privateStatus.distract();
Server.private(o.id, o.access !== "private").then(data => this._handlePrivate(data)).catch(err => this._handleErr(err, this._privateStatus));
}
_handlePrivate(data) {
if (data.id === this._pattern.id) {
this._pattern.access = data.access;
this._privateStatus.hide();
this._updateUI();
}
}
_doFavorite() {
let o = this._pattern;
this._favoritesStatus.distract();
Server.favorite(o.id, !o.favorite).then(data => this._handleFavorite(data)).catch(err => this._handleErr(err, this._favoritesStatus));
}
_handleFavorite(data) {
if (data.id === this._pattern.id) {
this._pattern.favorite = data.favorite;
this._favoritesStatus.hide();
this._updateUI();
}
}
_doDelete() {
let o = this._pattern;
if (!confirm("Are you sure you want to permanently delete this pattern?")) {
return;
}
this._deleteStatus.distract();
Server.delete(o.id).then(data => this._handleDelete(data)).catch(err => this._handleErr(err, this._deleteStatus));
}
_handleDelete(data) {
this._deleteStatus.hide();
app.state = {
flavor: app.flavor.value
};
setTimeout(() => app.tooltip.toggle.showOn("delete", "Pattern was permanently deleted.", this._deleteRow, true, 0), 1);
}
_handleErr(err, status) {
status.error(this._getErrMsg(err)).hide(6);
}
_showCommunity() {
app.sidebar.goto("share_community");
this._comNameFld.value = this.name;
this._comAuthorFld.value = this.author;
this._comDescriptionFld.value = this.description;
this._comKeywordsFld.value = this.keywords;
}
_doComSave() {
if (!this._comNameFld.value) {
this._comNameFld.focus();
return;
}
let o = app.state;
this.name = o.name = this._comNameFld.value;
this.author = o.author = this._comAuthorFld.value;
this.description = o.description = this._comDescriptionFld.value;
this.keywords = o.keywords = this._comKeywordsFld.value;
o.access = "public";
DOMUtils.addClass(DOMUtils.query(".buttons", this.communityEl), "wait");
this.comSaveStatus.distract();
Server.save(o, true, true).then(data => this._handleComSave(data)).catch(err => this._handleComSaveErr(err));
}
_handleComSave(data) {
DOMUtils.removeClass(DOMUtils.query(".buttons", this.communityEl), "wait");
this.comSaveStatus.hide();
this.show();
}
_handleComSaveErr(err) {
DOMUtils.removeClass(DOMUtils.query(".buttons", this.communityEl), "wait");
this.comSaveStatus.error(this._getErrMsg(err));
}
_handleChange() {
this.dispatchEvent("change");
}
_handleAppChange() {
this._updateUI();
}
_handleAccountChange() {
let acc = app.account,
rowEl = DOMUtils.query(".signin.row", this.mainEl);
if (!this.authorFld.value) {
this.authorFld.value = acc.author || acc.username;
}
DOMUtils.toggleClass(rowEl, "authenticated", acc.authenticated);
DOMUtils.query(".username", rowEl).innerText = acc.username;
}
_handleAppLoad() {
DOMUtils.toggleClass(DOMUtils.query(".save .actions", this.mainEl), "disabled");
}
_doSignin() {
app.account.showTooltip();
}
_setSaveText(str) {
this.saveMessage.innerText = str;
}
_getErrMsg(err) {
return "ERROR: " + app.reference.getError("servercomm");
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Sidebar {
constructor(el) {
this.el = el;
this.itemEl = null;
this.openReq = null;
this._initUI(el);
this._content = this._prepContent(home);
this.minList.data = [{
id: "menu",
label: "Menu"
}].concat(home.kids);
app.flavor.on("change", () => this._onFlavorChange());
let id = app.prefs.read("side");
if (!id || !this._idMap[id] || id === "share") {
id = "home";
}
this.goto(id);
if (app.isNarrow) {
setTimeout(() => this.minimize(true, false), 1500);
}
}
minimize(val = true, track = true) {
if (val === this._minimized) {
return;
}
if (val && track) {
Track.event("minimize_menu", "engagement");
}
DOMUtils.togglePanel(this.el, '.full', '.min', !val);
this._minimized = val;
this._updateUI();
}
goto(id) {
this.show(this._idMap[id]);
}
showToken(token) {
this.goto(app.reference.idForToken(token));
}
show(item) {
if (!item) {
return;
}
if (item.hide) {
return this.show(item.parent);
}
if (!item || item.id === "menu") {
return;
} // expand button on the min menu
this.minimize(false);
if (item.id) {
if (item.id === "home" || item.parent && item.parent.id === "home" || this._isInReference(item)) {
app.prefs.write("side", item.id);
}
}
if (!item.el && !item.kids) {
if (this.searchMode || !item.parent || item.parent === this.curItem) {
// in a search, community / favorites, of selecting a leaf child from a list.
this.selItem = item;
this.menuList.selected = item.id;
return this._showContent(item);
} else if (item.parent !== this.curItem) {
// trying to jump to a leaf child without previously showing parent.
this.show(item.parent);
return this.show(item);
}
}
this._resetFull();
this.curItem = item;
DOMUtils.query("h1", this.titleEl).innerText = item.label;
DOMUtils.query("svg.back.icon use", this.titleEl).setAttribute("xlink:href", "#" + (item.parent ? "arrowleft" : "menu"));
if (item.el) {
this._showEl(DOMUtils.query("#library " + item.el));
} else {
this._showContent(item);
}
if (item.kids && item.list !== false) {
DOMUtils.removeClass(this.fullEl, "no-list");
this.menuList.data = item.kids || item.parent.kids;
}
if (item.search) {
DOMUtils.removeClass(this.fullEl, "no-search");
}
// special handling:
if (item.id === "community") {
this.menuList.template = this.communityListTemplate;
this._onSearchSubmit();
} else if (item.id === "favorites") {
this.menuList.template = this.communityListTemplate;
this._loadFavorites();
}
}
back() {
if (this.curItem.parent) {
this.show(this.curItem.parent);
} else {
this.minimize(true);
}
}
menuListTemplate(o) {
return (o.parent && o.parent.id === "home" ? '' : "") + '' + (o.label || o.id) + "" + (o.token ? '' + o.token.replace("<", "<") + '' : "") + (o.kids || o.el ? '' : "");
}
communityListTemplate(o) {
return '' + Utils.htmlSafe(o.name) + "" + '' + (o.favorite ? '' : '') + '' + o.rating.toFixed(1) + '';
}
// private methods:
_initUI(el) {
// set up full width content:
this.fullEl = DOMUtils.query("> .full", el);
// title bar:
this.titleEl = DOMUtils.query("> header", this.fullEl);
DOMUtils.query("> .close.icon", this.titleEl).addEventListener("click", () => this.minimize(true));
DOMUtils.query("> .backrow", this.titleEl).addEventListener("click", () => this.back());
// search:
this.searchEl = DOMUtils.query("> .search", this.fullEl);
this.searchFld = DOMUtils.query("> .search > input", this.fullEl);
this.searchFld.addEventListener("input", () => this._onSearchChange());
this.searchFld.addEventListener("keyup", evt => evt.keyCode === 13 && this._onSearchSubmit());
let searchBtn = DOMUtils.query("> svg.icon.search", this.searchEl);
searchBtn.addEventListener("click", () => this._onSearchSubmit());
// list & content:
this.listEl = DOMUtils.query("> .list", this.fullEl);
this.menuList = new List(this.listEl, {
data: home.kids,
template: this.menuListTemplate
});
this.menuList.on("change", () => {
const lastId = this.curItem.id;
this.show(this.menuList.selectedItem);
if (lastId !== this.curItem.id) {
Track.page("sidebar/" + this.curItem.id);
}
});
this.menuList.on("dblclick", () => this._onDblClick(this.menuList.selectedItem));
this.contentEl = DOMUtils.query("> .content", this.fullEl);
// set up minimized sidebar:
this.minEl = DOMUtils.query("> .min", el);
this.minEl.addEventListener("click", () => this.minimize(false));
let template = DOMUtils.template``;
this.minList = new List(DOMUtils.query("> .list", this.minEl), {
template
});
this.minList.on("change", evt => {
this.show(this.minList.selectedItem);
evt.preventDefault();
Track.page("sidebar/" + this.curItem.id);
});
// set up special content:
this.community = new CommunityContent(DOMUtils.query("#library > #community"));
this.share = new Share(DOMUtils.query("#library > #share"));
this._prepCheatsheet(); // TODO: switch to a Cheatsheet class.
DOMUtils.query(".doc > .blocker").addEventListener("mousedown", evt => {
this.minimize(true);
});
}
_updateUI() {
// TODO: this is cheating a bit:
let doc = DOMUtils.query(".doc");
DOMUtils.toggleClass(doc, "fadeback", !this._minimized);
}
_resetFull() {
if (this.itemEl) {
DOMUtils.query("#library").appendChild(this.itemEl);
this.itemEl = null;
}
this._abortReq();
DOMUtils.addClass(this.fullEl, "no-search no-list");
this.searchFld.value = "";
this.searchMode = false;
this.menuList.template = this.menuListTemplate;
DOMUtils.removeClass(this.searchEl, "wait");
}
_showContent(o) {
if ((this.curItem.id === "community" || this.curItem.id === "favorites") && o !== this.curItem) {
this._showEl(this.community.el);
this.community.item = o;
} else {
let ref = app.reference;
this.contentEl.innerHTML = this._isInReference(o) ? ref.getContent(o.id) : ref.fillTags((o.desc || "") + (o.ext || ""), o, ref);
if (o.example) {
this.contentEl.appendChild(new Example("Example", o.example).el);
}
}
}
_isInReference(o) {
return this._isIn(o, "reference");
}
_isIn(o, id) {
do {
if (o.id === id) {
return true;
}
} while (o = o.parent);
return false;
}
_onDblClick(o) {
if (o.token) {
let expr = app.expression;
if (o.parent.id === "flags") {
expr.toggleFlag(o.token);
} else {
expr.insert(o.token);
}
} else if (this.curItem.id === "community" || this.curItem.id === "favorites") {
app.load(o);
}
}
_showEl(el) {
if (this.itemEl === el) {
return;
}
this.itemEl = el;
DOMUtils.empty(this.contentEl).appendChild(el);
}
_prepContent(content) {
// inject reference:
let i = Utils.findIndex(content.kids, o => o.id === "reference");
content.kids.splice(i, 1, app.reference.content);
// grab home content from HTML:
content.desc = this.contentEl.innerHTML;
// build idMap:
this._idMap = {
home: content
};
return Utils.prepMenuContent(content, this._idMap);
}
_prepCheatsheet() {
let els = DOMUtils.queryAll("#cheatsheet *[data-id]");
let f = evt => this.goto(evt.target.dataset.id);
for (let i = 0, l = els.length; i < l; i++) {
els[i].addEventListener("click", f);
}
els = DOMUtils.queryAll("#cheatsheet tr td:first-child");
f = evt => app.expression.insert(evt.target.innerText);
for (let i = 0, l = els.length; i < l; i++) {
let el = els[i],
tokens = el.innerText.split(" ");
DOMUtils.empty(el);
for (let j = 0; j < tokens.length; j++) {
let span = DOMUtils.create("a", null, tokens[j], el);
span.addEventListener("click", f);
}
}
}
_onSearchChange() {
let id = this.curItem.id,
search = this.searchFld.value;
if (id === "reference") {
this._searchReference(search);
} else if (id === "favorites") {
this._searchFavorites(search);
} else {
return;
}
// TODO: this is a hacky way to reset the content:
this.contentEl.innerHTML = this.curItem.desc;
this.itemEl = null;
}
_searchReference(search) {
let result = app.reference.search(search);
this.searchMode = !!search;
this.menuList.data = search ? result : this.curItem.kids;
// TODO: would be nice to show a "no match" message, but difficult to do with `hide=true` entries
}
_searchFavorites(search) {
let data = this.menuList.data,
rank = Utils.searchRank;
data.forEach(o => o.hide = !rank(o, search));
this.menuList.data = data;
}
_onFlavorChange() {
let item = this.selItem || this.curItem;
if (!this._isInReference(item)) {
return;
}
this.selItem = this.curItem = null;
this.show(item);
}
_onSearchSubmit() {
this._abortReq();
let val = this.searchFld.value;
if (this.curItem.id === "community") {
if (val) {
Track.event("search", "engagement", {
search_term: val,
target: "community"
});
}
DOMUtils.addClass(this.searchEl, "wait");
this._showListMsg();
this.openReq = Server.communitySearch(val).then(data => this._showServerResults(data)).catch(msg => this._showListMsg(msg)).finally(() => this._reqCleanup());
}
this.searchFld.select();
}
_loadFavorites() {
this._abortReq();
let val = this.searchFld.value;
this.openReq = Server.patterns().then(data => this._showServerResults(data)).catch(msg => this._showListMsg(msg)).finally(() => this._reqCleanup());
this._showListMsg();
}
_showListMsg(msg = "Loading...") {
this.listEl.innerHTML = "
" + msg + "
";
}
_abortReq() {
if (this.openReq) {
this.openReq.abort();
}
this.openReq = null;
}
_showServerResults(data) {
this.menuList.data = data.results;
if (data.results.length === 0) {
this._showListMsg(this.curItem.id === "community" ? "No matches." : "No patterns created or favorited.");
}
}
_reqCleanup(msg) {
DOMUtils.removeClass(this.searchEl, "wait");
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Theme extends EventDispatcher {
constructor(el) {
super();
this.el = el;
this.urlTemplate = "./assets/themes/%name%.css";
this.targetNode = this._node = null;
this._dark = false;
this._initUI();
this.dark = !!app.prefs.read("dark");
}
set dark(val) {
val = !!val;
if (this._dark === val) {
return;
}
this._dark = val;
this._load(val ? "dark" : null);
DOMUtils.toggleClass(this.themeBtn, "selected", val);
app.prefs.write("dark", val);
}
get dark() {
return this._dark;
}
_initUI() {
this.themeBtn = DOMUtils.query(".header .button.theme", this.el);
this.themeBtn.addEventListener("click", evt => this._toggleTheme());
}
_load(id) {
if (id === this._id) {
return;
}
this._id = id;
if (this._node) {
this._node.remove();
}
if (!id) {
this._change();
return;
}
let tmpl = this.urlTemplate,
n = DOMUtils.create("link");
n.addEventListener("load", () => this._change());
n.rel = "stylesheet";
n.type = "text/css";
n.href = tmpl ? tmpl.replace(/%name%/g, id) : id;
this._node = (this.targetNode || document.head).appendChild(n);
}
_change() {
this.dispatchEvent("change");
}
_toggleTheme() {
this.dark = !this.dark;
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Reference {
constructor(content, flavor, config) {
this._config = config;
this._flavor = flavor;
this._flavor.on("change", () => this._flavorChange());
this._injectEscChars(content);
this._idMap = {
reference: content
};
this._content = Utils.prepMenuContent(content, this._idMap);
this._misc = Utils.prepMenuContent(content.misc, this._idMap);
this._flavorChange();
}
get content() {
return this._content;
}
search(searchStr) {
function srch(kids, results) {
for (let i = 0, l = kids.length; i < l; i++) {
let kid = kids[i],
points = 0;
if (kid.kids) {
srch(kid.kids, results);
continue;
}
if (points = Utils.searchRank(kid, searchStr)) {
kid.__searchPoints = points;
results.push(kid);
}
}
return results;
}
return srch(this.content.kids, []).sort((a, b) => b.__searchPoints - a.__searchPoints);
}
idForToken(token) {
let errId = token.error && token.error.id;
if (this._idMap[errId]) {
return errId;
}
if (this._idMap[token.type]) {
return token.type;
}
if (this._idMap[token.clss]) {
return token.clss;
}
return errId || token.type || token.clss;
}
// methods used in fillTags:
getChar(token) {
let chr = Reference.NONPRINTING_CHARS[token.code];
return chr ? chr : "\"" + String.fromCharCode(token.code) + "\"";
}
getQuant(token) {
let min = token.min,
max = token.max;
return min === max ? min : max === -1 ? min + " or more" : "between " + min + " and " + max;
}
getUniCat(token) {
return Reference.UNICODE_CATEGORIES[token.value] || "[Unrecognized]";
}
getModes(token) {
let str = token.on ? " Enable \"" + token.on + "\"." : "";
if (token.off) {
str += " Disable \"" + token.off + "\".";
}
return str;
}
getInsensitive(token) {
if (token.code) {
let chr = String.fromCharCode(token.code);
if (chr.toLowerCase() === chr.toUpperCase()) {
return "";
}
}
return token.modes ? `Case ${token.modes.i ? "in" : ""}sensitive.` : "";
}
getDotAll(token) {
return (token.modes.s ? "including" : "except") + " line breaks";
}
getLabel(token) {
let node = this.getNodeForToken(token);
return node ? node.label || node.id || "" : token.type;
}
getDesc(token) {
return this.getVal(this.getNodeForToken(token), "desc");
}
getLazy(token) {
return token.modes.U ? "greedy" : "lazy";
}
getLazyFew(token) {
return token.modes.U ? "many" : "few";
}
getPHPVersion() {
return this._config.PHPVersion;
}
getPCREVersion() {
return this._config.PCREVersion;
}
getCtrlKey() {
return Utils.getCtrlKey();
}
getEscChars() {
let o = this._flavor.profile.escChars,
str = "";
for (let n in o) {
str += n;
}
return str;
}
/*
Searches for tags in the string in the format:
`{{prop.prop}}` or `{{method(prop.prop)}}`
The first format will inject the specified property of the data object.
For example, `{{a.b}}` would inject the value of `data.a.b`.
The second will inject the results of calling the specified function on the functs object with a property of the data object as it's parameter (or the data object itself if empty).
For example, `{{myMethod(a.b)}}` would inject the return value of `functs.myMethod(data.a.b)`.
Currently only supports a single param.
*/
fillTags(str, data, functs, maxLength = 20, htmlSafe = true) {
let match;
while (match = str.match(/{{~?[\w.()]+}}/)) {
let val,
f,
safe = false;
val = match[0].substring(2, match[0].length - 2);
if (val[0] === "~") {
val = val.substr(1);
safe = true;
}
let match2 = val.match(/\([\w.]*\)/);
if (match2) {
f = val.substr(0, match2.index);
val = match2[0].substring(1, match2[0].length - 1);
} else {
f = null;
}
let o = data,
arr = val.split(".");
for (let i = 0; i < arr.length; i++) {
let prop = arr[i];
if (prop && o) {
o = o[prop];
}
}
val = o;
if (f) {
if (functs[f]) {
val = functs[f](val);
} else {
val = " [" + f + "] ";
}
}
if (!safe && (maxLength || htmlSafe)) {
val = Utils.shorten(val, maxLength, htmlSafe, "i");
}
str = str.replace(match[0], val);
}
return str;
}
// returns doc props from the profile or reference as appropriate (ex. tip, desc, ext)
getVal(node, prop) {
if (!node) {
return "";
}
let pDocs = this._flavor.getDocs(node.id),
pRef = pDocs && pDocs[prop];
if (pRef != null && pRef[0] !== "+") {
return pRef;
}
let ref = node && node[prop] || "";
return pRef != null ? ref + pRef.substr(1) : ref;
}
getNodeForToken(token) {
let id = this.idForToken(token),
clss = token.clss;
// Special cases:
if (clss === "quant") {
id = clss;
}
if (clss === "esc" && token.type !== "escsequence") {
id = "escchar";
}
return this.getNode(id);
}
getNode(id) {
let map = this._idMap,
node = map[id];
while (node && node.proxy) {
node = map[node.proxy];
}
return node;
}
getError(error, token) {
let errId = error && error.id;
let str = this._content.errors[errId] || "no docs for error='" + errId + "'";
if (token) {
str = this.fillTags(str, token, this, 20);
}
return str;
}
tipForToken(token) {
if (!token) {
return null;
}
let node = this.getNodeForToken(token),
label,
tip;
if (token.error && !token.error.warning) {
label = "ERROR: ";
tip = this.getError(token.error, token);
} else {
label = node ? node.label || node.id || "" : token.type;
tip = this.getVal(node, "tip") || this.getVal(node, "desc");
tip = this.fillTags(tip, token, this, 20);
if (token.type === "group") {
label += " #" + token.num;
}
label = "" + label[0].toUpperCase() + label.substr(1) + ". ";
if (token.error) {
tip += "WARNING: " + this.getError(token.error, token) + "";
}
}
return tip ? label + tip : "no docs for id='" + this.idForToken(token) + "'";
}
getContent(id) {
let node = this.getNode(id);
return this.fillTags(this.getVal(node, "desc") + this.getVal(node, "ext"), node, this);
}
// TODO: this isn't necessarily the most ideal place for this method (has nothing to do with Reference). Maybe move into Text?
tipForMatch(match, text) {
if (!match) {
return null;
}
let more = match.l > 150;
let str = "match: " + Utils.shorten(text.substr(match.i, match.l), 150, true, "i") + " range: " + match.i + "-" + (match.i + match.l - 1) + "";
let groups = match.groups,
l = groups && groups.length;
for (let i = 0; i < l; i++) {
if (i > 3 && l > 5) {
more = false;
str += " see Details for " + (l - i) + " more";
break;
}
let group = groups[i],
s;
s = group.i !== undefined ? text.substr(group.i, group.l) : group.s;
more = more || s && s.length > 50;
str += i > 0 ? " " : "";
str += "group #" + (i + 1) + ": " + Utils.shorten(s, 50, true, "i");
}
if (more) {
str += " see Details for full matches";
}
return str;
}
// private methods:
_flavorChange() {
this._updateHide(this.content);
}
_updateHide(o, list) {
// the list param is for debugging, it is populated with the ids of all nodes that were hidden.
// parent nodes aren't hidden unless all their children are.
let kids = o.kids,
hide = true;
if (kids) {
for (let i = 0, l = kids.length; i < l; i++) {
hide = this._updateHide(kids[i], list) && hide;
}
} else {
hide = o.show === false || o.show !== true && o.id && !this._flavor.isTokenSupported(o.id);
}
if (list && hide) {
list.push(o.id);
}
return o.hide = hide;
}
_injectEscChars(content) {
let kids = Utils.find(content.kids, o => o.id === "escchars").kids;
let template = Utils.find(content.misc.kids, o => o.id === "escchar").tip;
// \x07 - bell, \x1b - esc
let chars = "\t\n\v\f\r\0\x07\x1b",
tokens = "tnvfr0ae"; // .\\+*?^$[]{}()|/
for (let i = 0, l = chars.length; i < l; i++) {
kids.push(this._getEscCharDocs(chars[i], tokens[i], template));
}
}
_getEscCharDocs(c, t, template) {
let code = c.charCodeAt(0),
chr = Reference.NONPRINTING_CHARS[code] || c;
return {
id: "esc_" + code,
token: "\\" + (t || c),
label: chr.toLowerCase(),
desc: this.fillTags(template, {
code: code
}, this)
};
}
}
Reference.NONPRINTING_CHARS = {
"0": "NULL",
"1": "SOH",
"2": "STX",
"3": "ETX",
"4": "EOT",
"5": "ENQ",
"6": "ACK",
"7": "BELL",
"8": "BS",
"9": "TAB",
//
"10": "LINE FEED",
//
"11": "VERTICAL TAB",
"12": "FORM FEED",
"13": "CARRIAGE RETURN",
//
"14": "SO",
"15": "SI",
"16": "DLE",
"17": "DC1",
"18": "DC2",
"19": "DC3",
"20": "DC4",
"21": "NAK",
"22": "SYN",
"23": "ETB",
"24": "CAN",
"25": "EM",
"26": "SUB",
"27": "ESC",
"28": "FS",
"29": "GS",
"30": "RS",
"31": "US",
"32": "SPACE",
//
"127": "DEL"
};
Reference.UNICODE_CATEGORIES = {
// from: http://www.pcre.org/original/doc/html/pcrepattern.html
"C": "Other",
"Cc": "Control",
"Cf": "Format",
"Cn": "Unassigned",
"Co": "Private use",
"Cs": "Surrogate",
"L": "Letter",
"L&": "Any letter ",
"Ll": "Lower case letter",
"Lm": "Modifier letter",
"Lo": "Other letter",
"Lt": "Title case letter",
"Lu": "Upper case letter",
"M": "Mark",
"Mc": "Spacing mark",
"Me": "Enclosing mark",
"Mn": "Non-spacing mark",
"N": "Number",
"Nd": "Decimal number",
"Nl": "Letter number",
"No": "Other number",
"P": "Punctuation",
"Pc": "Connector punctuation",
"Pd": "Dash punctuation",
"Pe": "Close punctuation",
"Pf": "Final punctuation",
"Pi": "Initial punctuation",
"Po": "Other punctuation",
"Ps": "Open punctuation",
"S": "Symbol",
"Sc": "Currency symbol",
"Sk": "Modifier symbol",
"Sm": "Mathematical symbol",
"So": "Other symbol",
"Z": "Separator",
"Zl": "Line separator",
"Zp": "Paragraph separator",
"Zs": "Space separator"
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
// this is just raw content for the Reference.
// right now all examples are executed in-browser, so they need to be compatible. Maybe swap to XRegExp at some point.
// TODO: rewrite to use multiline template literals?
let reference_content = {},
o = reference_content;
o.label = "RegEx Reference";
o.id = "reference";
o.search = true, o.desc = `Information on all of the tokens available to create regular expressions.
Double-click an item in the list to insert it into your Expression.
Click the arrow beside an example to load it.
`;
o.kids = [{
label: "Character classes",
id: "charclasses",
desc: "Character classes match a character from a specific set. There are a number of predefined character classes and you can also define your own sets.",
kids: [{
id: "set",
label: "character set",
desc: "Match any character in the set.",
example: ["[aeiou]", "glib jocks vex dwarves!"],
token: "[ABC]"
}, {
id: "setnot",
label: "negated set",
desc: "Match any character that is not in the set.",
example: ["[^aeiou]", "glib jocks vex dwarves!"],
token: "[^ABC]"
}, {
id: "range",
tip: "Matches a character in the range {{getChar(prev)}} to {{getChar(next)}} (char code {{prev.code}} to {{next.code}}). {{getInsensitive()}}",
example: ["[g-s]", "abcdefghijklmnopqrstuvwxyz"],
desc: "Matches a character having a character code between the two specified characters inclusive.",
token: "[A-Z]"
}, {
id: "posixcharclass",
tip: "Matches any character in the '{{value}}' POSIX class.",
label: "POSIX class",
desc: "Matches any character in the specified POSIX class. Must be in a character set. For example, [[:alnum:]$] will match alphanumeric characters and $.",
ext: "
",
token: "[:alnum:]"
}, {
id: "dot",
tip: "Matches any character {{getDotAll()}}.",
desc: "Matches any character except linebreaks.",
ext: " Equivalent to [^\\n\\r].",
example: [".", "glib jocks vex dwarves!"],
token: "."
}, {
id: "matchanyset",
label: "match any",
desc: "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.
",
example: ["[\\s\\S]", "glib jocks vex dwarves!"],
token: "[\\s\\S]"
}, {
id: "unicodegrapheme",
label: "unicode grapheme",
desc: "Matches any single unicode grapheme (ie. character).",
ext: " This includes line breaks (regardless of the dotall mode) and graphemes encoded as multiple code points.",
token: "\\X"
}, {
id: "word",
desc: "Matches any word character (alphanumeric & underscore).",
ext: " Only matches low-ascii characters (no accented or non-roman characters). Equivalent to [A-Za-z0-9_]",
example: ["\\w", "bonjour, mon fr\u00E8re"],
token: "\\w"
}, {
id: "notword",
label: "not word",
desc: "Matches any character that is not a word character (alphanumeric & underscore).",
ext: " Equivalent to [^A-Za-z0-9_]",
example: ["\\W", "bonjour, mon fr\u00E8re"],
token: "\\W"
}, {
id: "digit",
desc: "Matches any digit character (0-9).",
ext: " Equivalent to [0-9].",
example: ["\\d", "+1-(444)-555-1234"],
token: "\\d"
}, {
id: "notdigit",
label: "not digit",
desc: "Matches any character that is not a digit character (0-9).",
ext: " Equivalent to [^0-9].",
example: ["\\D", "+1-(444)-555-1234"],
token: "\\D"
}, {
id: "whitespace",
desc: "Matches any whitespace character (spaces, tabs, line breaks).",
example: ["\\s", "glib jocks vex dwarves!"],
token: "\\s"
}, {
id: "notwhitespace",
label: "not whitespace",
desc: "Matches any character that is not a whitespace character (spaces, tabs, line breaks).",
example: ["\\S", "glib jocks vex dwarves!"],
token: "\\S"
}, {
id: "hwhitespace",
label: "horizontal whitespace",
desc: "Matches any horizontal whitespace character (spaces, tabs).",
token: "\\h"
}, {
id: "nothwhitespace",
label: "not horizontal whitespace",
desc: "Matches any character that is not a horizontal whitespace character (spaces, tabs).",
token: "\\H"
}, {
id: "vwhitespace",
label: "vertical whitespace",
desc: "Matches any vertical whitespace character (line breaks).",
token: "\\v"
}, {
id: "notvwhitespace",
label: "not vertical whitespace",
desc: "Matches any character that is not a vertical whitespace character (line breaks).",
token: "\\V"
}, {
id: "linebreak",
label: "line break",
desc: "Matches any line break character, including the CRLF pair, and CR / LF individually.",
token: "\\R"
}, {
id: "notlinebreak",
label: "not line break",
desc: "Matches any character that is not a line break.",
ext: " Similar to dot (.) but is unaffected by the dotall flag (s).",
token: "\\N"
}, {
id: "unicodecat",
tip: "Matches any character in the '{{getUniCat()}}' unicode category.",
label: "unicode category",
desc: "Matches a character in the specified unicode category. For example, \\p{Ll} will match any lowercase letter.",
ext: "
",
token: "\\p{L}"
}, {
id: "notunicodecat",
tip: "Matches any character that is not in the '{{getUniCat()}}' unicode category.",
label: "not unicode category",
desc: "Matches any character that is not in the specified unicode category.",
ext: "
",
token: "\\P{L}"
}, {
id: "unicodescript",
tip: "Matches any character in the '{{value}}' unicode script.",
label: "unicode script",
desc: "Matches any character in the specified unicode script. For example, \\p{Arabic} will match characters in the Arabic script.",
ext: "
",
token: "\\p{Han}"
}, {
id: "notunicodescript",
tip: "Matches any character that is not in the '{{value}}' unicode script.",
label: "not unicode script",
desc: "Matches any character that is not in the specified unicode script.",
ext: "
\\P{Han}\\p{^Han}",
token: "\\P{Han}"
}]
}, {
label: "Anchors",
id: "anchors",
desc: "Anchors are unique in that they match a position within a string, not a character.",
kids: [{
id: "bos",
label: "beginning of string",
desc: "Matches the beginning of the string.",
ext: " Unlike ^, this is unaffected by the multiline flag (m). This matches a position, not a character.",
token: "\\A"
}, {
id: "eos",
label: "end of string",
desc: "Matches the end of the string.",
ext: " Unlike $, this is unaffected by the multiline flag (m). This matches a position, not a character.",
token: "\\Z"
}, {
id: "abseos",
label: "strict end of string",
desc: "Matches the end of the string. Unlike $ or \\Z, it does not allow for a trailing newline.",
ext: " This is unaffected by the multiline flag (m). This matches a position, not a character.",
token: "\\z"
}, {
id: "bof",
label: "beginning",
desc: "Matches the beginning of the string, or the beginning of a line if the multiline flag (m) is enabled.",
ext: " This matches a position, not a character.",
example: ["^\\w+", "she sells seashells"],
token: "^"
}, {
id: "eof",
label: "end",
desc: "Matches the end of the string, or the end of a line if the multiline flag (m) is enabled.",
ext: " This matches a position, not a character.",
example: ["\\w+$", "she sells seashells"],
token: "$"
}, {
id: "wordboundary",
label: "word boundary",
desc: "Matches a word boundary position between a word character and non-word character or position (start / end of string).",
ext: " See the word character class (\w) for more info.",
example: ["s\\b", "she sells seashells"],
token: "\\b"
}, {
id: "notwordboundary",
label: "not word boundary",
desc: "Matches any position that is not a word boundary.",
ext: " This matches a position, not a character.",
example: ["s\\B", "she sells seashells"],
token: "\\B"
}, {
id: "prevmatchend",
label: "previous match end",
desc: "Matches the end position of the previous match.",
ext: " This matches a position, not a character.",
token: "\\G"
}]
}, {
label: "Escaped characters",
id: "escchars",
desc: "Escape sequences can be used to insert reserved, special, and unicode characters. All escaped characters begin with the \\ character.",
kids: [{
id: "reservedchar",
label: "reserved characters",
desc: "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.
",
example: ["\\+", "1 + 1 = 2"],
token: "\\+",
show: true
}, {
id: "escoctal",
label: "octal escape",
desc: "Octal escaped character in the form \\000.",
ext: " Value must be less than 255 (\\377).",
// PCRE profile adds to ext.
example: ["\\251", "RegExr is \u00A92014"],
token: "\\000"
}, {
id: "eschexadecimal",
label: "hexadecimal escape",
desc: "Hexadecimal escaped character in the form \\xFF.",
example: ["\\xA9", "RegExr is \u00A92014"],
token: "\\xFF"
}, {
id: "escunicodeu",
label: "unicode escape",
desc: "Unicode escaped character in the form \\uFFFF",
example: ["\\u00A9", "RegExr is \u00A92014"],
token: "\\uFFFF"
}, {
id: "escunicodeub",
label: "extended unicode escape",
desc: "Unicode escaped character in the form \\u{FFFF}.",
ext: " Supports a full range of unicode point escapes with any number of hex digits.
Requires the unicode flag (u).
",
token: "\\u{FFFF}"
}, {
id: "escunicodexb",
label: "unicode escape",
desc: "Unicode escaped character in the form \\x{FF}.",
token: "\\x{FF}"
}, {
id: "esccontrolchar",
label: "control character escape",
desc: "Escaped control character in the form \\cZ.",
ext: " This can range from \\cA (SOH, char code 1) to \\cZ (SUB, char code 26).
Example:
\\cI matches TAB (char code 9).",
token: "\\cI"
}, {
id: "escsequence",
label: "escape sequence",
tip: "Matches the literal string '{{value}}'.",
desc: "All characters between the \\Q and the \\E are interpreted as a literal string. If \\E is omitted, it continues to the end of the expression.",
ext: " For example, the expression /\\Q(?.)\\E/ will match the string (?.).",
token: "\\Q...\\E"
}]
}, {
label: "Groups & References",
id: "groups",
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.",
kids: [{
id: "group",
label: "capturing group",
desc: "Groups multiple tokens together and creates a capture group for extracting a substring or using a backreference.",
example: ["(ha)+", "hahaha haa hah!"],
token: "(ABC)"
}, {
id: "namedgroup",
label: "named capturing group",
tip: "Creates a capturing group named '{{name}}'.",
desc: "Creates a capturing group that can be referenced via the specified name.",
ext: "
There are multiple syntaxes for this feature:
(?'name'ABC)(?P<name>ABC)(?<name>ABC)
",
token: "(?ABC)"
}, {
id: "namedref",
label: "named reference",
tip: "Matches the results of the capture group named '{{group.name}}'.",
desc: "Matches the results of a named capture group.",
ext: "
There are multiple syntaxes for this feature:
\\k'name'\\k<name>\\k{name}\\g{name}(?P=name)
",
token: "\\k'name'"
}, {
id: "numref",
label: "numeric reference",
tip: "Matches the results of capture group #{{group.num}}.",
desc: "Matches the results of a capture group. For example \\1 matches the results of the first capture group & \\3 matches the third.",
// PCRE adds relative and alternate syntaxes in ext
example: ["(\\w)a\\1", "hah dad bad dab gag gab"],
token: "\\1"
}, {
id: "branchreset",
label: "branch reset group",
desc: "Define alternative groups that share the same group numbers.",
ext: "
For example, in (?|(a)|(b)) both groups (a and b) would be counted as group #1.",
token: "(?|(a)|(b))"
}, {
id: "noncapgroup",
label: "non-capturing group",
desc: "Groups multiple tokens together without creating a capture group.",
example: ["(?:ha)+", "hahaha haa hah!"],
token: "(?:ABC)"
}, {
id: "atomic",
label: "atomic group",
desc: "Non-capturing group that discards backtracking positions once matched.",
ext: "
For example, /(?>ab|a)b/ will match abb but not ab because once the ab option has matched, the atomic group prevents backtracking to retry with the a option.
",
token: "(?>ABC)"
}, {
id: "define",
desc: "Used to define named groups for use as subroutines without including them in the match.",
ext: "
For example, /A(?(DEFINE)(?'foo'Z))B\\g'foo'/ will match ABZ, because the define group is ignored in the match except to define the foo subroutine that is referenced later with \\g'foo'.
",
token: "(?(DEFINE)(?'foo'ABC))"
}, {
id: "numsubroutine",
label: "numeric subroutine",
tip: "Matches the expression in capture group #{{group.num}}.",
desc: "Matches the expression in a capture group. Compare this to a reference, that matches the result." + " For example /(a|b)\\g'1'/ can match ab, because the expression a|b is evaluated again.",
ext: "
There are multiple syntaxes for this feature: \\g<1>\\g'1'(?1).
" + "
Relative values preceded by + or - are also supported. For example \\g<-1> would match the group preceding the reference.
",
token: "\\g'1'"
}, {
id: "namedsubroutine",
label: "named subroutine",
tip: "Matches the expression in the capture group named '{{group.name}}'.",
desc: "Matches the expression in a capture group. Compare this to a reference, that matches the result.",
ext: "
There are multiple syntaxes for this feature: \\g<name>\\g'name'(?&name)(?P>name).
",
token: "\\g'name'"
}]
}, {
label: "Lookaround",
id: "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.
",
kids: [{
id: "poslookahead",
label: "positive lookahead",
desc: "Matches a group after the main expression without including it in the result.",
example: ["\\d(?=px)", "1pt 2px 3em 4px"],
token: "(?=ABC)"
}, {
id: "neglookahead",
label: "negative lookahead",
desc: "Specifies a group that can not match after the main expression (if it matches, the result is discarded).",
example: ["\\d(?!px)", "1pt 2px 3em 4px"],
token: "(?!ABC)"
}, {
id: "poslookbehind",
label: "positive lookbehind",
desc: "Matches a group before the main expression without including it in the result.",
token: "(?<=ABC)"
}, {
id: "neglookbehind",
label: "negative lookbehind",
desc: "Specifies a group that can not match before the main expression (if it matches, the result is discarded).",
token: "(?/o\\Kbar/ will match bar within the string foobar",
token: "\\K"
}]
}, {
label: "Quantifiers & Alternation",
id: "quants",
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." + "Alternation acts like a boolean OR, matching one sequence or another.",
kids: [{
id: "plus",
desc: "Matches 1 or more of the preceding token.",
example: ["b\\w+", "b be bee beer beers"],
token: "+"
}, {
id: "star",
desc: "Matches 0 or more of the preceding token.",
example: ["b\\w*", "b be bee beer beers"],
token: "*"
}, {
id: "quant",
label: "quantifier",
tip: "Match {{getQuant()}} of the preceding token.",
desc: "Matches the specified quantity of the previous token. " + "{1,3} will match 1 to 3. " + "{3} will match exactly 3. " + "{3,} will match 3 or more. ",
example: ["b\\w{2,3}", "b be bee beer beers"],
token: "{1,3}"
}, {
id: "opt",
label: "optional",
desc: "Matches 0 or 1 of the preceding token, effectively making it optional.",
example: ["colou?r", "color colour"],
token: "?"
}, {
id: "lazy",
tip: "Makes the preceding quantifier {{getLazy()}}, causing it to match as {{getLazyFew()}} characters as possible.",
desc: "Makes the preceding quantifier lazy, causing it to match as few characters as possible.",
ext: " By default, quantifiers are greedy, and will match as many characters as possible.",
example: ["b\\w+?", "b be bee beer beers"],
token: "?"
}, {
id: "possessive",
desc: "Makes the preceding quantifier possessive. It will match as many characters as possible, and will not release them to match subsequent tokens.",
ext: "
For example /.*a/ would match aaa, but /.*+a/ would not, because the repeating dot would match and not release the last character to match a.
",
token: "+"
}, {
id: "alt",
label: "alternation",
desc: "Acts like a boolean OR. Matches the expression before or after the |.",
ext: "
It can operate within a group, or on a whole expression. The patterns will be tested in order.
",
example: ["b(a|e|i)d", "bad bud bod bed bid"],
token: "|"
}]
}, {
label: "Special",
id: "other",
desc: "Tokens that don't quite fit anywhere else.",
kids: [{
id: "comment",
desc: "Allows you to insert a comment into your expression that is ignored when finding a match.",
token: "(?#foo)"
}, {
id: "conditional",
desc: "Conditionally matches one of two options based on whether a lookaround is matched.",
ext: "
For example, /(?(?=a)ab|..)/ will match ab and zx but not ax, because if the first character matches the condition a then it evaluates the pattern ab.
" + "
Any lookaround can be used as the condition. A lookahead will start the subsequent match at the start of the condition, a lookbehind will start it after.
",
token: "(?(?=A)B|C)"
}, {
id: "conditionalgroup",
label: "group conditional",
desc: "Conditionally matches one of two options based on whether group '{{name}}' matched.",
ext: "
For example, /(z)?(?(1)a|b)/ will match za because the first capture group matches z successfully, which causes the conditional to match the first option a.
" + "
The same pattern will also match b on its own, because group 1 doesn't match, so it instead tries to match the second option b.
" + "
You can reference a group by name, number, or relative position (ex. -1).
",
token: "(?(1)B|C)"
}, {
id: "recursion",
desc: "Attempts to match the full expression again at the current position.",
ext: "
For example, /a(?R)?b/ will match any number of a followed by the same number of z: the full text of az or aaaazzzz, but not azzz.
" + "
There are multiple syntaxes for this feature:
(?R)(?0)\\g<0>\\g'0'
",
token: "(?R)"
}, {
id: "mode",
label: "mode modifier",
tip: "{{~getDesc()}}{{~getModes()}}",
desc: "Enables or disables modes for the remainder of the expression.",
ext: "Matching modes generally map to expression flags. For example (?i) would enable case insensitivity for the remainder of the expression." + "
Multiple modifiers can be specified, and any modifiers that follow - are disabled. For example (?im-s) would enable case insensitivity & multiline modes, and disable dotall.
" + "
Supported modifiers are: i - case insensitive, s - dotall, m - multiline, x - free spacing, J - allow duplicate names, U - ungreedy.
",
token: "(?i)"
}]
}, {
label: "Substitution",
desc: "These tokens are used in a substitution string to insert different parts of the match.",
target: "subst",
id: "subst",
kids: [{
id: "subst_$&match",
label: "match",
desc: "Inserts the matched text.",
token: "$&"
}, {
id: "subst_0match",
label: "match",
desc: "Inserts the matched text.",
ext: "
There are multiple syntaxes for this feature:
$0\\0\\{0}
",
token: "$0"
}, {
id: "subst_group",
label: "capture group",
tip: "Inserts the results of capture group #{{group.num}}.",
desc: "Inserts the results of the specified capture group. For example, $3 would insert the third capture group.",
// NOTE: javascript profile overrides this:
ext: "
There are multiple syntaxes for this feature:
$1\\1\\{1}
",
token: "$1"
}, {
id: "subst_$before",
label: "before match",
desc: "Inserts the portion of the source string that precedes the match.",
token: "$`"
}, {
id: "subst_$after",
label: "after match",
desc: "Inserts the portion of the source string that follows the match.",
token: "$'"
}, {
id: "subst_$esc",
label: "escaped $",
desc: "Inserts a dollar sign character ($).",
token: "$$"
}, {
id: "subst_esc",
label: "escaped characters",
token: "\\n",
desc: "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."
}]
}, {
id: "flags",
label: "Flags",
tooltip: "Expression flags change how the expression is interpreted. Click to edit.",
desc: "Expression flags change how the expression is interpreted. Flags follow the closing forward slash of the expression (ex. /.+/igm ).",
target: "flags",
kids: [{
id: "caseinsensitive",
label: "ignore case",
desc: "Makes the whole expression case-insensitive.",
ext: " For example, /aBc/i would match AbC.",
token: "i"
}, {
id: "global",
label: "global search",
tip: "Retain the index of the last match, allowing iterative searches.",
desc: "Retain the index of the last match, allowing subsequent searches to start from the end of the previous match." + "
Without the global flag, subsequent searches will return the same match.
" + "RegExr only searches for a single match when the global flag is disabled to avoid infinite match errors.",
token: "g"
}, {
id: "multiline",
tip: "Beginning/end anchors (^/$) will match the start/end of a line.",
desc: "When the multiline flag is enabled, beginning and end anchors (^ and $) will match the start and end of a line, instead of the start and end of the whole string." + "
Note that patterns such as /^[\\s\\S]+$/m may return matches that span multiple lines because the anchors will match the start/end of any line.
",
token: "m"
}, {
id: "unicode",
tip: "Enables \\x{FFFFF} unicode escapes.",
desc: "When the unicode flag is enabled, you can use extended unicode escapes in the form \\x{FFFFF}." + "
It also makes other escapes stricter, causing unrecognized escapes (ex. \\j) to throw an error.
",
token: "u"
}, {
id: "sticky",
desc: "The expression will only match from its lastIndex position and ignores the global (g) flag if set.",
ext: " Because each search in RegExr is discrete, this flag has no further impact on the displayed results.",
token: "y"
}, {
id: "dotall",
desc: "Dot (.) will match any character, including newline.",
token: "s"
}, {
id: "extended",
desc: "Literal whitespace characters are ignored, except in character sets.",
token: "x"
}, {
id: "ungreedy",
tip: "Makes quantifiers ungreedy (lazy) by default.",
desc: "Makes quantifiers ungreedy (lazy) by default. Quantifiers followed by ? will become greedy.",
token: "U"
}]
}];
// content that isn't included in the Reference menu item:
o.misc = {
kids: [{
id: "ignorews",
label: "ignored whitespace",
tip: "Whitespace character ignored due to the extended flag or mode."
}, {
id: "extnumref",
// alternative syntaxes.
proxy: "numref"
}, {
id: "char",
label: "character",
tip: "Matches a {{getChar()}} character (char code {{code}}). {{getInsensitive()}}"
}, {
id: "escchar",
label: "escaped character",
tip: "Matches a {{getChar()}} character (char code {{code}})."
}, {
id: "open",
tip: "Indicates the start of a regular expression."
}, {
id: "close",
tip: "Indicates the end of a regular expression and the start of expression flags."
}, {
id: "condition",
tip: "The lookaround to match in resolving the enclosing conditional statement. See 'conditional' in the Reference for info."
}, {
id: "conditionalelse",
label: "conditional else",
tip: "Delimits the 'else' portion of the conditional."
}, {
id: "ERROR",
tip: "Errors in the expression are underlined in red. Roll over errors for more info."
}, {
id: "PREG_INTERNAL_ERROR",
tip: "Internal PCRE error"
}, {
id: "PREG_BACKTRACK_LIMIT_ERROR",
tip: "Backtrack limit was exhausted."
}, {
id: "PREG_RECURSION_LIMIT_ERROR",
tip: "Recursion limit was exhausted"
}, {
id: "PREG_BAD_UTF8_ERROR",
tip: "Malformed UTF-8 data"
}, {
id: "PREG_BAD_UTF8_OFFSET_ERROR",
tip: "Malformed UTF-8 data"
}]
};
o.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?
};
/*
classes:
quant
set
special
ref
esc
anchor
charclass
group
comment
*/
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class BrowserSolver {
constructor() {
const workerBlob = new Blob([document.querySelector('#regexWorker').textContent], {
type: "text/javascript"
});
this._workerObjectURL = URL.createObjectURL(workerBlob);
}
solve(o, callback) {
this._callback = callback;
this._req = o;
let regex,
text = o.text,
tests = o.tests,
mode = o.mode;
try {
this._regex = regex = new RegExp(o.pattern, o.flags);
} catch (e) {
return this._onRegExComplete({
id: "regexparse",
name: e.name,
message: e.message
}, null, mode);
}
if (window.Worker) {
const worker = new Worker(this._workerObjectURL);
worker.onmessage = evt => {
if (evt.data === "onload") {
this._startTime = Utils.now();
this._timeoutId = setTimeout(() => {
worker.terminate();
this._onRegExComplete({
id: "timeout"
}, null, mode); // TODO: make this a warning, and return all results so far.
}, 250);
} else {
clearTimeout(this._timeoutId);
worker.terminate();
this._onRegExComplete(evt.data.error, evt.data.matches, evt.data.mode);
}
};
// we need to pass the pattern and flags as text, because Safari strips the unicode flag when passing a RegExp to a Worker
worker.postMessage({
pattern: o.pattern,
flags: o.flags,
text,
tests,
mode
});
} else {
this._startTime = Utils.now();
// shared between BrowserSolver & RegExWorker
var matches = [],
match,
index,
error;
if (mode === "tests") {
for (var i = 0, l = tests.length; i < l; i++) {
let test = tests[i];
text = test.text;
regex.lastIndex = 0;
match = regex.exec(text);
matches[i] = match ? {
i: match.index,
l: match[0].length,
id: test.id
} : {
id: test.id
};
}
} else {
while (match = regex.exec(text)) {
if (index === regex.lastIndex) {
error = {
id: "infinite",
warning: true
};
++regex.lastIndex;
}
index = regex.lastIndex;
var groups = match.reduce(function (arr, s, i) {
return (i === 0 || arr.push({
s: s
})) && arr;
}, []);
matches.push({
i: match.index,
l: match[0].length,
groups: groups
});
if (!regex.global) {
break;
} // or it will become infinite.
}
}
// end share
this._onRegExComplete(error, matches, mode);
}
}
_onRegExComplete(error, matches, mode) {
let result = {
time: error ? null : Utils.now() - this._startTime,
error,
mode,
matches
};
let tool = this._req.tool;
if (tool) {
result.tool = {
id: tool.id
};
if (!error || error.warning && tool.input != null) {
let str = Utils.unescSubstStr(tool.input);
result.tool.result = tool.id === "replace" ? this._getReplace(str) : this._getList(str);
}
}
this._callback(result);
}
_getReplace(str) {
return this._req.text.replace(this._regex, str);
}
_getList(str) {
// TODO: should we move this into a worker?
let source = this._req.text,
result = "",
repl,
ref,
trimR = 0,
regex;
// build a RegExp without the global flag:
try {
regex = new RegExp(this._req.pattern, this._req.flags.replace("g", ""));
} catch (e) {
return null;
}
if (str.search(/\$[&1-9`']/) === -1) {
trimR = str.length;
str = "$&" + str;
}
do {
ref = source.replace(regex, "\b"); // bell char - just a placeholder to find
let index = ref.indexOf("\b"),
empty = ref.length > source.length;
if (index === -1) {
break;
}
repl = source.replace(regex, str);
result += repl.substr(index, repl.length - ref.length + 1);
source = ref.substr(index + (empty ? 2 : 1));
} while (source.length);
if (trimR) {
result = result.substr(0, result.length - trimR);
}
return result;
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class ServerSolver {
solve(o, callback) {
// unescape tool input:
if (o.tool && o.tool.input != null) {
o.tool.input = Utils.unescSubstStr(o.tool.input);
}
if (this._serverPromise) {
this._serverPromise.abort();
}
Utils.defer(() => this._solve(o, callback), "ServerSolver._solve", 250);
}
_solve(o, callback) {
this._callback = callback;
this._serverPromise = Server.solve(o).then(o => this._onLoad(o)).catch(o => this._onError(o));
}
_onLoad(data) {
this._callback(data);
}
_onError(msg) {
this._callback({
error: {
id: msg
}
});
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Flavor extends EventDispatcher {
constructor(flavor) {
super();
this.value = app.prefs.read("flavor");
this._browserSolver = new BrowserSolver();
this._serverSolver = new ServerSolver();
}
set value(id) {
let profile = profiles[id && id.toLowerCase() || "js"];
if (!profile || profile === this._profile) {
return;
}
this._profile = profile;
this._buildSupportMap(profile);
app.prefs.write("flavor", id);
this.dispatchEvent("change");
}
get value() {
return this._profile.id;
}
get profile() {
return this._profile;
}
get profiles() {
return [profiles.js, profiles.pcre];
}
get solver() {
return this._profile.browser ? this._browserSolver : this._serverSolver;
}
isTokenSupported(id) {
return !!this._profile._supportMap[id];
}
getDocs(id) {
return this._profile.docs[id];
}
validateFlags(list) {
let flags = this._profile.flags,
dupes = {};
return list.filter(id => !!flags[id] && !dupes[id] && (dupes[id] = true));
}
validateFlagsStr(str) {
return this.validateFlags(str.split("")).join("");
}
isFlagSupported(id) {
return !!this._profile.flags[id];
}
_buildSupportMap(profile) {
if (profile._supportMap) {
return;
}
let map = profile._supportMap = {},
props = Flavor.SUPPORT_MAP_PROPS,
n;
for (n in props) {
this._addToSupportMap(map, profile[n], !!props[n]);
}
let o = profile.escCharCodes,
esc = profile.escChars;
for (n in o) {
map["esc_" + o[n]] = true;
}
for (n in esc) {
map["esc_" + esc[n]] = true;
}
}
_addToSupportMap(map, o, rev) {
if (rev) {
for (let n in o) {
map[o[n]] = true;
}
} else {
for (let n in o) {
map[n] = o[n];
}
}
}
}
Flavor.SUPPORT_MAP_PROPS = {
// 1 = reverse, 0 - normal
flags: 1,
// escape is handled separately
// escCharCodes is handled separately
escCharTypes: 1,
charTypes: 1,
// unquantifiables not included
// unicodeScripts not included
// unicodeCategories not included
// posixCharClasses not included
// modes not included
tokens: 0,
substTokens: 0
// config not included
// docs not included
};
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class RefCoverage {
constructor() {
app.flavor._buildSupportMap(core);
let ref = app.reference._idMap,
undoc = [],
unused = [],
all = core._supportMap;
let ignore = {
"escchar": true,
// literal char
"groupclose": true,
"setclose": true,
"condition": true,
// proxies to conditional
"conditionalelse": true,
// proxies to conditional
subst_$group: true,
// resolved to subst_group
subst_$bgroup: true,
// resolved to subst_group
subst_bsgroup: true,
// resolved to subst_group
escoctalo: true // resolved to escoctal
};
for (let n in all) {
if (!ref[n] && !ignore[n]) {
undoc.push(n);
}
}
for (let n in ref) {
if (!all[n] && !ref[n].kids) {
unused.push(n);
}
}
console.log("--- UNDOCUMENTED IDS ---\n" + undoc.join("\n") + "\n\n--- UNUSED DOCS? ---\n" + unused.join("\n"));
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class Prefs {
constructor(el) {
this._load();
}
read(key) {
return this._data[key];
}
write(key, value) {
if (this._data[key] === value) {
return;
}
this._data[key] = value;
this._save();
}
clear(key) {
delete this._data[key];
this._save();
}
_load() {
let match = /(?:^|;\s*)prefs=\s*([^;]*)/.exec(document.cookie);
if (match && match[1]) {
try {
this._data = JSON.parse(unescape(match[1]));
return;
} catch (e) {}
}
this._data = {};
}
_save() {
let str = escape(JSON.stringify(this._data));
document.cookie = "prefs=" + str + "; expires=Fri, 31 Dec 9999 23:59:59 GMT;";
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
class RegExr extends EventDispatcher {
constructor() {
super();
}
init(state, account, config = {}) {
this.prefs = new Prefs();
this.flavor = new Flavor();
this.reference = new Reference(reference_content, this.flavor, config);
this._migrateFavorites();
this._initUI();
this.account.value = account;
if (state === false) {
this._localInit();
} else if (this.account.authenticated && !state) {
this.newDoc(false);
} else {
this.state = state;
}
this._savedHash = null;
let params = Utils.getUrlParams();
if (Utils.isLocal && params.id) {
Server.load(params.id).then(o => this.state = o);
params = {};
}
if (params.engine) {
this.flavor.value = params.engine;
}
if (params.expression) {
this.expression.value = params.expression;
}
if (params.text) {
this.text.value = params.text;
}
if (params.tool) {
this.tools.value = {
id: params.tool,
input: params.input
};
}
window.onbeforeunload = e => this.unsaved ? "You have unsaved changes." : null;
this.resetUnsaved();
setTimeout(() => this._initAds(), 100);
}
_initAds() {
_native && _native.init("CK7D65QM", {
// "CK7D65QM" use "CK7D4KQE" to test Carbon ads
carbonZoneKey: 'CK7DPKQU',
targetClass: 'native-js'
});
}
_localInit() {
console.log("local init");
//Server.verify().then((data) => this.account.value = data);
new RefCoverage();
}
// getter / setters:
get state() {
console.log(this.text.mode);
let o = {
expression: this.expression.value,
text: this.text.value,
tests: this.text.tests,
flavor: this.flavor.value,
tool: this.tools.value,
mode: this.text.mode
};
// copy share values onto the pattern object:
return Utils.copy(this.share.value, o);
}
set state(o) {
if (!o) {
return;
}
this.flavor.value = o.flavor;
this.expression.value = o.expression;
this.text.value = o.text;
this.text.tests = o.tests;
this.text.mode = o.mode;
this.tools.value = o.tool;
this.share.pattern = o;
this.resetUnsaved();
}
get hash() {
let share = this.share;
return Utils.getHashCode(this.expression.value + "\t" + this.text.value + "\t" + this.flavor.value + "\t" + share.author + "\t" + share.name + "\t" + share.description + "\t" + share.keywords + "\t" + JSON.stringify(this.text.tests) + "\t"
//+ this.tools.value.input+"\t"
//+ this.tools.value.id+"\t"
);
}
get unsaved() {
return this.hash !== this._savedHash;
}
get isNarrow() {
return this._matchList.matches;
}
// public methods:
resetUnsaved() {
this._savedHash = this.hash;
}
newDoc(warn = true) {
this.load({
flavor: this.flavor.value,
expression: ".",
text: "Text"
}, warn);
this.expression.selectAll();
}
load(state, warn = true) {
if (warn === true) {
warn = "You have unsaved changes. Continue without saving?";
}
if (warn && this.unsaved && !confirm(warn)) {
return;
}
this.state = Utils.clone(state);
}
// private methods:
_initUI() {
// TODO: break into own Device class? Rename mobile.scss too?
// mobile setup
// keep synced with "mobile.scss":
if (screen.width < 500) {
document.getElementById("viewport").setAttribute("content", "width=500, user-scalable=0");
}
this._matchList = window.matchMedia("(max-width: 900px)");
this._matchList.addListener(q => this.dispatchEvent("narrow")); // currently unused.
// UI:
this.el = DOMUtils.query(".container");
this.tooltip = {
hover: new Tooltip(DOMUtils.query("#library #tooltip").cloneNode(true)),
toggle: new Tooltip(DOMUtils.query("#library #tooltip"), true)
};
this.theme = new Theme(this.el);
let el = this.docEl = DOMUtils.query(".app > .doc", this.el);
this.expression = new Expression(DOMUtils.query("> section.expression", el));
this.text = new Text(DOMUtils.query("> section.text", el));
this.tools = new Tools(DOMUtils.query("> section.tools", el));
this.account = new Account();
this.sidebar = new Sidebar(DOMUtils.query(".app > .sidebar", this.el));
this.share = this.sidebar.share;
this.expression.on("change", () => this._change());
this.text.on("change", () => this._change());
this.text.on("modechange", () => this._modeChange());
this.flavor.on("change", () => this._change());
this.tools.on("change", () => this._change());
this.share.on("change", () => this._change());
}
_migrateFavorites() {
let ls = window.localStorage,
l = ls.length;
if (!l || ls.getItem("f_v3") >= "1") {
return;
}
let ids = [];
for (let i = 0; i < l; i++) {
let key = ls.key(i),
val = ls.getItem(key);
if (key[0] === "f" && val === "1") {
ids.push(key.substr(1));
}
}
if (!ids.length) {
ls.setItem("f_v3", "1");
return;
}
Server.multiFavorite(ids).then(() => ls.setItem("f_v3", "1"));
}
_change() {
this.dispatchEvent("change");
let solver = this.flavor.solver,
exp = this.expression;
let o = {
pattern: exp.pattern,
flags: exp.flags,
mode: this.text.mode
};
if (o.mode === "tests") {
o.tests = this.text.tests;
} else {
o.text = this.text.value;
o.tool = this.tools.value;
}
solver.solve(o, result => this._handleResult(result));
}
_modeChange() {
DOMUtils.toggleClass(this.docEl, "tests-mode", this.text.mode === "tests");
this._change();
}
_handleResult(result) {
this.result = this._processResult(result);
this.dispatchEvent("result");
}
_processResult(result) {
if (result.mode === "text") {
result.matches && result.matches.forEach((o, i) => o.num = i);
}
return result;
}
}
/*
RegExr: Learn, Build, & Test RegEx
Copyright (C) 2017 gskinner.com, inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
let app = new RegExr();
return app;
}());
//# sourceMappingURL=regexr.js.map