958 lines
20 KiB
TypeScript
958 lines
20 KiB
TypeScript
import { MathX } from "../math/MathX";
|
|
import { Arrays } from "../tools/Arrays";
|
|
import { LevenshteinDistance } from "./Levehshtein";
|
|
import { LexerMatcher } from "./lexer/LexerMatcher";
|
|
|
|
export class RegExpUtility
|
|
{
|
|
static repeat( text:string, times:number )
|
|
{
|
|
let output = [];
|
|
|
|
while ( times > 0 )
|
|
{
|
|
output.push( text );
|
|
times--;
|
|
}
|
|
|
|
return output.join( "" );
|
|
}
|
|
|
|
static collapse( text:string, collapsingPattern:string )
|
|
{
|
|
let collapsingRegex = /((?:XXX)+)/g;
|
|
let escapedRegexContent = collapsingRegex.source;
|
|
let escapedCollapsedPattern = RegExpUtility.toRegexSource( collapsingPattern );
|
|
escapedRegexContent = escapedRegexContent.replace( "XXX", escapedCollapsedPattern );
|
|
|
|
let regex = new RegExp( escapedRegexContent, "g" );
|
|
|
|
return text.replace( regex, collapsingPattern );
|
|
}
|
|
|
|
static collapseWhiteSpace( text:string )
|
|
{
|
|
text = text.replace( /((?:\s|\n|\r|\t)+)/g, " " );
|
|
|
|
return text.trim();
|
|
}
|
|
|
|
static toFileName( text:string )
|
|
{
|
|
let fileNameOutput:string[] = [];
|
|
|
|
for ( let i = 0; i < text.length; i++ )
|
|
{
|
|
let character = text[ i ];
|
|
|
|
if ( /[a-zA-Z0-9\-]/.test( character ) )
|
|
{
|
|
fileNameOutput.push( character );
|
|
//console.log( "Not escaped:", character );
|
|
}
|
|
else
|
|
{
|
|
fileNameOutput.push( "_" );
|
|
//console.log( "Escaped:", character, ">>", "_" );
|
|
}
|
|
}
|
|
|
|
return fileNameOutput.join( "" );
|
|
|
|
}
|
|
|
|
static trimCharacters( text:string, fromStart:number, fromEnd:number )
|
|
{
|
|
let start = fromStart;
|
|
let end = text.length - fromEnd;
|
|
|
|
return text.substring( start, end );
|
|
}
|
|
|
|
static splitLines( text:string )
|
|
{
|
|
return text.split( /(?:\r\n)|\n|\r/g );
|
|
}
|
|
|
|
static splitLinesCaptureBreaks( text:string )
|
|
{
|
|
return text.split( /((?:\r\n)|\n|\r)/g );
|
|
}
|
|
|
|
static createMatcherFromCombiningWords( words:string[], noSubmatches:boolean ):RegExp
|
|
{
|
|
let sources = words.map( w => RegExpUtility.toRegexSource( w ) );
|
|
|
|
let regexSource = sources.join( "|" );
|
|
|
|
if ( ! noSubmatches )
|
|
{
|
|
regexSource = `^(${regexSource})$`;
|
|
}
|
|
|
|
|
|
return new RegExp( regexSource );
|
|
}
|
|
|
|
static matches( value:string, matcher:string|RegExp )
|
|
{
|
|
if ( ! matcher )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if ( typeof matcher === "string" )
|
|
{
|
|
return value === matcher;
|
|
}
|
|
|
|
return matcher.test( value );
|
|
}
|
|
|
|
static cutout( value:string, regex:RegExp ):string[]
|
|
{
|
|
let result = regex.exec( value );
|
|
|
|
if ( ! result )
|
|
{
|
|
return [ value, null ];
|
|
}
|
|
|
|
let match = result[ 0 ];
|
|
|
|
let cutout = RegExpUtility.cutoutRange( value, result.index, match.length );
|
|
|
|
return [ cutout, match ];
|
|
}
|
|
|
|
static chopRange( value:string, start:number, end:number )
|
|
{
|
|
let chopped:string[] = [];
|
|
|
|
if ( start > 0 )
|
|
{
|
|
chopped.push( value.substring( 0, start ) );
|
|
}
|
|
else
|
|
{
|
|
chopped.push( null );
|
|
}
|
|
|
|
chopped.push( value.substring( start, end ) );
|
|
|
|
if ( end < value.length )
|
|
{
|
|
chopped.push( value.substring( end, value.length ) );
|
|
}
|
|
else
|
|
{
|
|
chopped.push( null );
|
|
}
|
|
|
|
return chopped;
|
|
}
|
|
|
|
static cutoutRange( value:string, start:number, length:number ):string
|
|
{
|
|
if ( start == 0 )
|
|
{
|
|
return value.substring( length );
|
|
}
|
|
|
|
let before = value.substring( 0, start );
|
|
|
|
let after = value.substring( start + length );
|
|
|
|
return before + after;
|
|
}
|
|
|
|
static parseDuration( value:string, alternative:number = 0 )
|
|
{
|
|
if ( ! value )
|
|
{
|
|
return alternative;
|
|
}
|
|
|
|
if ( value.indexOf( ":" ) === -1 )
|
|
{
|
|
return parseFloat( value );
|
|
}
|
|
|
|
let values = this.parseNumbers( value, [ 0, 0 ], ":" );
|
|
|
|
return values[ 0 ] * 60 + values[ 1 ];
|
|
}
|
|
|
|
static asDurationString( duration:number, delimiter:string = ":", zerofillMinutes:boolean = false )
|
|
{
|
|
let seconds = Math.floor( MathX.repeat( duration, 60 ) ) + "";
|
|
let minutes = Math.floor( duration / 60 ) + "";
|
|
|
|
if ( seconds.length < 2 ){ seconds = "0" + seconds; }
|
|
if ( zerofillMinutes && minutes.length < 2 ){ minutes = "0" + minutes; }
|
|
|
|
return minutes + delimiter + seconds;
|
|
}
|
|
|
|
static parseNumbers( value:string, alternative:number[] = [], delimiter = "," )
|
|
{
|
|
if ( ! value )
|
|
{
|
|
return alternative;
|
|
}
|
|
|
|
var splitted = value.split( delimiter );
|
|
|
|
var numberValues = [];
|
|
|
|
for ( let i = 0; i < splitted.length; i++ )
|
|
{
|
|
var splitValue = splitted[ i ].trim();
|
|
var numericValue = parseFloat( splitValue );
|
|
|
|
numberValues.push( numericValue );
|
|
}
|
|
|
|
return numberValues;
|
|
}
|
|
|
|
|
|
static splitPath( path:string )
|
|
{
|
|
return path.split( /\\|\// );
|
|
}
|
|
|
|
static startsWithSome( text:string, starts:string[] )
|
|
{
|
|
return starts.some( s => text.startsWith( s ) );
|
|
}
|
|
|
|
static escapePathFragmentForWindows( fragmentWithoutSlashes:string, replacement:string = "_" ):string
|
|
{
|
|
return fragmentWithoutSlashes.replace( /(\\|\/|\?|\:|\||\*|\<|\>)/g, replacement );
|
|
}
|
|
|
|
static resolvePath( path:string )
|
|
{
|
|
let pathFragments = path.split( "/" );
|
|
let resolvedFragments = [];
|
|
|
|
for ( let i = 0; i < pathFragments.length; i++ )
|
|
{
|
|
if ( pathFragments[ i ] === ".." )
|
|
{
|
|
if ( resolvedFragments.length === 0 || resolvedFragments[ i - 1 ] === ".." )
|
|
{
|
|
resolvedFragments.push( ".." );
|
|
}
|
|
else
|
|
{
|
|
resolvedFragments.pop();
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
resolvedFragments.push( pathFragments[ i ] );
|
|
}
|
|
}
|
|
|
|
let resolvedPath = resolvedFragments.join( "/" );
|
|
return resolvedPath;
|
|
}
|
|
|
|
static createRelativeDirectoryPath( sourceDirectory:string, targetDirectory:string)
|
|
{
|
|
if ( sourceDirectory === targetDirectory )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
sourceDirectory = this.normalizePath( sourceDirectory );
|
|
targetDirectory = this.normalizePath( targetDirectory );
|
|
|
|
if ( sourceDirectory === targetDirectory )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
|
|
let matching = RegExpUtility.getMatchingDirectories( sourceDirectory, targetDirectory );
|
|
|
|
|
|
let shortSource = sourceDirectory.substring( matching.length );
|
|
let shortTarget = targetDirectory.substring( matching.length );
|
|
|
|
shortSource = this.normalizePath( shortSource );
|
|
shortTarget = this.normalizePath( shortTarget );
|
|
|
|
if ( this.isEmptyPath( shortSource ) )
|
|
{
|
|
return shortTarget;
|
|
}
|
|
|
|
let sourceDirectories = RegExpUtility.splitPath( shortSource );
|
|
|
|
let path = "";
|
|
|
|
for ( let i = 0; i < sourceDirectories.length; i++ )
|
|
{
|
|
if ( path !== "" )
|
|
{
|
|
path += "/";
|
|
}
|
|
|
|
path += "..";
|
|
|
|
}
|
|
|
|
if ( path !== "" )
|
|
{
|
|
path += "/"
|
|
}
|
|
|
|
path += shortTarget;
|
|
return path;
|
|
}
|
|
|
|
static isEmptyPath( path:string )
|
|
{
|
|
return /^\s*(\\|\/)?\s*$/.test( path );
|
|
}
|
|
|
|
static getAllMatchResultsOf( source:string, regex:RegExp )
|
|
{
|
|
let matcher = new LexerMatcher( "match", RegExpUtility.makeSticky( regex ) );
|
|
let offset = 0;
|
|
|
|
let results:RegExpExecArray[] = [];
|
|
|
|
while ( offset < source.length )
|
|
{
|
|
let result = matcher.getMatchResult( source, offset );
|
|
|
|
if ( result )
|
|
{
|
|
results.push( result );
|
|
offset += result[ 0 ].length;
|
|
}
|
|
else
|
|
{
|
|
offset ++;
|
|
}
|
|
}
|
|
|
|
return results;
|
|
|
|
|
|
}
|
|
|
|
static removeLeadingSlashes( text:string )
|
|
{
|
|
return text.replace( /^\s*(\\|\/)/, "" );
|
|
}
|
|
|
|
static removeTrailingSlashes( text:string )
|
|
{
|
|
return text.replace( /(\\|\/)\s*$/, "" );
|
|
}
|
|
|
|
static trimSlashes( text:string )
|
|
{
|
|
return this.removeTrailingSlashes( this.removeLeadingSlashes( text ) );
|
|
}
|
|
|
|
static removeLeadingSpace( textContent:string, removeFirstEmpty:boolean = true )
|
|
{
|
|
var lines = textContent.split( /(?:\r\n|\r|\n)/ );
|
|
|
|
if ( removeFirstEmpty && /^\s*$/.test( lines[ 0 ] ))
|
|
{
|
|
lines.shift();
|
|
}
|
|
|
|
var offset:number|null = null;
|
|
|
|
lines.forEach(
|
|
( line ) =>
|
|
{
|
|
if ( /^\s*$/.test( line ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
var result = /^\s+/.exec( line );
|
|
|
|
//console.log( "LINE RESULT:", result, "line:", line );
|
|
|
|
if ( result == null )
|
|
{
|
|
return;
|
|
}
|
|
|
|
var numSpaces = result[ 0 ].length;
|
|
|
|
|
|
offset = offset === null ? numSpaces : Math.min( offset, numSpaces );
|
|
}
|
|
)
|
|
|
|
//console.log( "offset", offset );
|
|
|
|
if ( offset == null )
|
|
{
|
|
return lines.join( "\n" );
|
|
}
|
|
|
|
lines = lines.map( line =>
|
|
{
|
|
if ( /^\s*$/.test( line ) )
|
|
{
|
|
return line;
|
|
}
|
|
|
|
var result = /^\s+/.exec( line );
|
|
if ( result === null )
|
|
{
|
|
return line;
|
|
}
|
|
|
|
return line.substring( offset );
|
|
}
|
|
);
|
|
|
|
return lines.join( "\n" );
|
|
}
|
|
|
|
static getMatchingStartOfAll( s:string[] ):string
|
|
{
|
|
if ( s === null || s === undefined || s.length === 0 )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
let empty = s.some( e => e === null || e === undefined || e === "" );
|
|
|
|
if ( empty )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
if ( s.length === 1 )
|
|
{
|
|
return s[ 0 ];
|
|
}
|
|
|
|
let length = s.map( e => e.length ).reduce( ( a, b ) => Math.min( a,b ) );
|
|
|
|
for ( let i = 0; i < length; i++ )
|
|
{
|
|
let value = s[ 0 ][ i ];
|
|
|
|
for ( let j = 1; j < s.length; j ++ )
|
|
{
|
|
if ( s[ j ][ i ] !== value )
|
|
{
|
|
return s[ 0 ].substring( 0, i );
|
|
}
|
|
}
|
|
}
|
|
|
|
return s[ 0 ].substring( 0, length );
|
|
|
|
|
|
}
|
|
|
|
static getMatchingDirectories( a:string, b:string )
|
|
{
|
|
let matching = [];
|
|
|
|
let directoriesA = this.splitPath( a );
|
|
let directoriesB = this.splitPath( b );
|
|
|
|
for ( let i = 0; i < directoriesA.length && i < directoriesB.length; i++ )
|
|
{
|
|
if ( directoriesA[ i ] == directoriesB[ i ] )
|
|
{
|
|
matching.push( directoriesA[ i ] );
|
|
}
|
|
else
|
|
{
|
|
return matching.join( "/" );
|
|
}
|
|
}
|
|
|
|
return matching.join( "/" );
|
|
}
|
|
|
|
static getMatchingStart( a:string, b:string )
|
|
{
|
|
if ( ! a || ! b )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
let length = Math.min( a.length, b.length );
|
|
|
|
for ( let i = 0; i < length; i++ )
|
|
{
|
|
if ( a[ i ] !== b[ i ] )
|
|
{
|
|
return a.substring( 0, i );
|
|
}
|
|
}
|
|
|
|
if ( length === a.length )
|
|
{
|
|
return a;
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
static getMatchingEnd( a:string, b:string )
|
|
{
|
|
if ( ! a || ! b )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
let length = Math.min( a.length, b.length );
|
|
|
|
for ( let i = 0 ; i < length; i++ )
|
|
{
|
|
let aIndex = a.length - ( 1 + i );
|
|
let bIndex = b.length - ( 1 + i );
|
|
|
|
if ( a[ aIndex ] !== b[ bIndex ] )
|
|
{
|
|
return a.substring( aIndex + 1, a.length );
|
|
}
|
|
}
|
|
|
|
if ( length === a.length )
|
|
{
|
|
return a;
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
static readonly tagMatchingRegex =
|
|
/(<tag(?: (?:\w|\s|\-|\=|"(?:\.|(?:\\\")|[^\""\n])*"|'(?:\.|(?:\\\')|[^\''\n])*')*)?>)((?:.|\n)*)(<\/tag>)/;
|
|
|
|
static getTagRegex( tag:string )
|
|
{
|
|
return new RegExp( RegExpUtility.tagMatchingRegex.source.replace( /tag/g, tag ) );
|
|
}
|
|
|
|
static getTagContent( source:string, tag:string )
|
|
{
|
|
let regex = RegExpUtility.getTagRegex( tag );
|
|
|
|
let result = regex.exec( source );
|
|
|
|
if ( ! result )
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return result[ 2 ];
|
|
}
|
|
|
|
static setTagContent( source:string, tag:string, value:string )
|
|
{
|
|
let regex = RegExpUtility.getTagRegex( tag );
|
|
|
|
return source.replace( regex, `$1${value}$3`);
|
|
}
|
|
|
|
static ensureSlash( path:string )
|
|
{
|
|
if ( path.endsWith( "/" ) )
|
|
{
|
|
return path;
|
|
}
|
|
|
|
return path + "/";
|
|
}
|
|
|
|
static minimumDigitsInt( value:number, digits:number = 2 )
|
|
{
|
|
let stringValue = Math.round( value ) + "";
|
|
|
|
while ( stringValue.length < digits )
|
|
{
|
|
stringValue = "0" + stringValue;
|
|
}
|
|
|
|
return stringValue;
|
|
}
|
|
|
|
static round( value:number, numZeros:number )
|
|
{
|
|
if ( numZeros <= 0 )
|
|
{
|
|
return Math.round( value ) + "";
|
|
}
|
|
|
|
numZeros = Math.round( numZeros );
|
|
|
|
var sign = value < 0 ? "-" : "";
|
|
value = Math.abs( value );
|
|
|
|
var roundedBiggerValue = Math.round( value * Math.pow( 10, numZeros ) );
|
|
var stringValue = roundedBiggerValue + "";
|
|
var minimumLength = numZeros + 1;
|
|
|
|
while ( stringValue.length < minimumLength )
|
|
{
|
|
stringValue = "0" + stringValue;
|
|
}
|
|
|
|
|
|
var split = stringValue.length - numZeros;
|
|
|
|
return sign + stringValue.substring( 0, split ) + "." + stringValue.substring( split );
|
|
}
|
|
|
|
static createFromList( list:string[] )
|
|
{
|
|
list = list.map( l => RegExpUtility.toRegexSource( l ) );
|
|
|
|
return new RegExp( list.join( "|" ) );
|
|
}
|
|
|
|
static toRegexSource( source:string )
|
|
{
|
|
source = source.replace( /\./g, "\\." );
|
|
source = source.replace( /\(/g, "\\(" );
|
|
source = source.replace( /\)/g, "\\)" );
|
|
source = source.replace( /\[/g, "\\[" );
|
|
source = source.replace( /\]/g, "\\]" );
|
|
source = source.replace( /\^/g, "\\^" );
|
|
source = source.replace( /\$/g, "\\$" );
|
|
source = source.replace( /\*/g, "\\*" );
|
|
source = source.replace( /\+/g, "\\+" );
|
|
source = source.replace( /\-/g, "\\-" );
|
|
source = source.replace( /\?/g, "\\?" );
|
|
source = source.replace( /\//g, "\\/" );
|
|
source = source.replace( /\|/g, "\\|" );
|
|
|
|
return source;
|
|
}
|
|
|
|
static upperCaseFirst( source:string )
|
|
{
|
|
if ( source === null || source === undefined || source.length === 0 )
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return source[ 0 ].toUpperCase() + source.substring( 1 );
|
|
}
|
|
|
|
static lowerCaseFirst( source:string )
|
|
{
|
|
if ( source === null || source === undefined || source.length === 0 )
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return source[ 0 ].toLowerCase() + source.substring( 1 );
|
|
}
|
|
|
|
private static fileTypeExtensionRegex = /\.(\w+)$/;
|
|
|
|
static trimProtocols( link:string, protocols:string[]=["https","http","ftp","sftp"] )
|
|
{
|
|
let genericRegex = /^XXX?\:\/\//;
|
|
let escapedProtocols = protocols.map( p => RegExpUtility.toRegexSource( p ) );
|
|
let combinedProtocols = `(${escapedProtocols.join("|")})`;
|
|
let protocolRegexSource = genericRegex.source.replace( "XXX", combinedProtocols );
|
|
|
|
let regex = new RegExp( protocolRegexSource );
|
|
|
|
// console.log( "REGEX:", regex, ">>", link );
|
|
return link.replace( regex, "" );
|
|
|
|
}
|
|
|
|
static trimFileTypeExtension( source:string )
|
|
{
|
|
return source.replace( RegExpUtility.fileTypeExtensionRegex, "" );
|
|
}
|
|
|
|
static replaceAll( text:string, replacements:Map<string,string> )
|
|
{
|
|
for ( let [ variable, replacement ] of replacements )
|
|
{
|
|
let replacementRegexSource = RegExpUtility.toRegexSource( variable );
|
|
let regex = new RegExp( replacementRegexSource, "g" );
|
|
text = text.replace( regex, replacement );
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
static getFileTypeExtension( source:string )
|
|
{
|
|
let result = source.lastIndexOf( "." );
|
|
|
|
if ( result === - 1 )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
return source.substring( result + 1 );
|
|
|
|
}
|
|
|
|
static removeStarting( text:string, start:string )
|
|
{
|
|
if ( text.startsWith( start ) )
|
|
{
|
|
return text.substring( start.length );
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
static removeInner( text:string, start:number, length:number )
|
|
{
|
|
return text.substring( 0, start ) + text.substring( start + length );
|
|
}
|
|
|
|
static makeSticky( regexp:RegExp )
|
|
{
|
|
if ( regexp.sticky )
|
|
{
|
|
return regexp;
|
|
}
|
|
|
|
var source = regexp.source;
|
|
var flags = regexp.flags;
|
|
|
|
if ( flags.indexOf( "y" ) === -1 )
|
|
{
|
|
flags += "y";
|
|
}
|
|
|
|
return new RegExp( source, flags );
|
|
}
|
|
|
|
static getClosestMatching<T>( list:T[], matching:string, getText:(t:T)=>string = null ):T
|
|
{
|
|
let index = this.getClosestIndex( list, matching, getText );
|
|
|
|
return list[ index ];
|
|
}
|
|
|
|
static getClosestIndex<T>( list:T[], matching:string, getText:(t:T)=>string = null ):number
|
|
{
|
|
if ( ! getText )
|
|
{
|
|
getText = ( t )=>{ return t + "" };
|
|
}
|
|
|
|
let index = list.findIndex( l => getText( l ) === matching );
|
|
|
|
if ( index !== -1 )
|
|
{
|
|
return index;
|
|
}
|
|
|
|
let closestIndex = -1;
|
|
let closestValue = 100000;
|
|
|
|
for ( let i = 0; i < list.length; i++ )
|
|
{
|
|
let listValue = getText( list[ i ] );
|
|
let distance = LevenshteinDistance.compute( listValue, matching );
|
|
|
|
if ( distance >= closestValue )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
closestValue = distance;
|
|
closestIndex = i;
|
|
|
|
}
|
|
|
|
return closestIndex;
|
|
|
|
}
|
|
|
|
static makeGlobal( regexp:RegExp )
|
|
{
|
|
if ( regexp.global )
|
|
{
|
|
return regexp;
|
|
}
|
|
|
|
var source = regexp.source;
|
|
var flags = regexp.flags + "g";
|
|
|
|
return new RegExp( source, flags );
|
|
}
|
|
|
|
static makeIgnoreCase( regexp:RegExp )
|
|
{
|
|
if ( regexp.ignoreCase )
|
|
{
|
|
return regexp;
|
|
}
|
|
|
|
var source = regexp.source;
|
|
var flags = regexp.flags + "i";
|
|
|
|
return new RegExp( source, flags );
|
|
}
|
|
|
|
static prependZeros( source:string, minimumLength:number = 2 )
|
|
{
|
|
while ( source.length < minimumLength )
|
|
{
|
|
source = "0" + source;
|
|
}
|
|
|
|
return source;
|
|
}
|
|
|
|
static createWordMatcher( source:string )
|
|
{
|
|
source = "\\b" + RegExpUtility.toRegexSource( source ) + "\\b";
|
|
return new RegExp( source );
|
|
}
|
|
|
|
static createClassMatcher( source:string )
|
|
{
|
|
source = "(^|\\s)" + RegExpUtility.toRegexSource( source ) + "(\\s|$)";
|
|
return new RegExp( source );
|
|
}
|
|
|
|
static createMatcher( source:string )
|
|
{
|
|
return new RegExp( RegExpUtility.toRegexSource( source ) );
|
|
}
|
|
|
|
|
|
static createRegExp( regexp:RegExp, matching:string, replacement:string )
|
|
{
|
|
let source = regexp.source;
|
|
let flags = regexp.flags;
|
|
source = source.replace( matching, replacement );
|
|
|
|
return new RegExp( source, flags );
|
|
}
|
|
|
|
static readonly ES_NUMBER_REGEX = /((\d+)?\.)?\d+(e(\+|\-)\d+)?/;
|
|
|
|
static isESNumber( value:string )
|
|
{
|
|
return RegExpUtility.ES_NUMBER_REGEX.test( value );
|
|
}
|
|
|
|
static parentPath( path:string, alternative:string ="")
|
|
{
|
|
let lastSlash = path.lastIndexOf( "/" );
|
|
let lastBackSlash = path.lastIndexOf( "\\" )
|
|
|
|
if ( lastSlash === -1 && lastBackSlash === -1 )
|
|
{
|
|
return alternative;
|
|
}
|
|
|
|
let highest = Math.max( lastSlash, lastBackSlash );
|
|
|
|
return path.substring( 0, highest );
|
|
}
|
|
|
|
|
|
static fileNameWithoutExtension( path:string )
|
|
{
|
|
return RegExpUtility.trimFileTypeExtension( RegExpUtility.fileNameOrLastPath( path ) );
|
|
}
|
|
|
|
static fileNameOrLastPath( path:string )
|
|
{
|
|
path = this.normalizePath( path );
|
|
let lastSlash = path.lastIndexOf( "/" );
|
|
|
|
if ( lastSlash === -1 )
|
|
{
|
|
return path;
|
|
}
|
|
|
|
return path.substring( lastSlash + 1 );
|
|
|
|
/*
|
|
path = path.replace( /(\\|\/)$/, "" );
|
|
let parentPath = RegExpUtility.parentPath( path );
|
|
|
|
if ( parentPath === "" )
|
|
{
|
|
path = path.replace( /^(\/|\\)/, "" );
|
|
return path;
|
|
}
|
|
|
|
let last = path.substring( parentPath.length + 1 );
|
|
|
|
last = last.replace( /^(\/|\\)/, "" );
|
|
return last;
|
|
*/
|
|
}
|
|
|
|
static join( pathA:string, pathB:string, ...paths:string[] )
|
|
{
|
|
let normalizedPaths = [pathA,pathB].concat( paths );
|
|
|
|
for ( let i = 0; i < normalizedPaths.length; i++ )
|
|
{
|
|
normalizedPaths[ i ] = this.normalizePath( normalizedPaths[ i ] );
|
|
}
|
|
|
|
return normalizedPaths.join( "/" );
|
|
}
|
|
|
|
static joinPaths( paths:string[] )
|
|
{
|
|
let normalizedPaths = paths;
|
|
|
|
for ( let i = normalizedPaths.length - 1; i >= 0; i-- )
|
|
{
|
|
if ( this.isEmptyPath( normalizedPaths[ i ] ) )
|
|
{
|
|
Arrays.removeAt( normalizedPaths, i );
|
|
}
|
|
}
|
|
|
|
for ( let i = 0; i < normalizedPaths.length; i++ )
|
|
{
|
|
normalizedPaths[ i ] = this.normalizePath( normalizedPaths[ i ] );
|
|
}
|
|
|
|
return normalizedPaths.join( "/" );
|
|
}
|
|
|
|
static normalizePath( path:string )
|
|
{
|
|
let slashMatcher = /\\/g;
|
|
let multiples = /\/\/+/g;
|
|
let startSlashes = /^\/+/;
|
|
let endSlashes = /\/+$/;
|
|
|
|
|
|
path = path.replace( slashMatcher, "/" );
|
|
path = path.replace( multiples, "/" );
|
|
path = path.replace( startSlashes, "" );
|
|
path = path.replace( endSlashes, "" );
|
|
|
|
|
|
return path;
|
|
}
|
|
|
|
|
|
}
|