yaml-language-server
Version:
133 lines • 4.65 kB
JavaScript
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.startsWith = startsWith;
exports.endsWith = endsWith;
exports.convertSimple2RegExp = convertSimple2RegExp;
exports.convertSimple2RegExpPattern = convertSimple2RegExpPattern;
exports.getIndentation = getIndentation;
exports.safeCreateUnicodeRegExp = safeCreateUnicodeRegExp;
exports.getFirstNonWhitespaceCharacterAfterOffset = getFirstNonWhitespaceCharacterAfterOffset;
exports.extendedRegExp = extendedRegExp;
function startsWith(haystack, needle) {
if (haystack.length < needle.length) {
return false;
}
for (let i = 0; i < needle.length; i++) {
if (haystack[i] !== needle[i]) {
return false;
}
}
return true;
}
/**
* Determines if haystack ends with needle.
*/
function endsWith(haystack, needle) {
const diff = haystack.length - needle.length;
if (diff > 0) {
return haystack.lastIndexOf(needle) === diff;
}
else if (diff === 0) {
return haystack === needle;
}
else {
return false;
}
}
function convertSimple2RegExp(pattern) {
const match = pattern.match(new RegExp('^/(.*?)/([gimy]*)$'));
return match ? convertRegexString2RegExp(match[1], match[2]) : convertGlobalPattern2RegExp(pattern);
}
function convertGlobalPattern2RegExp(pattern) {
return new RegExp(pattern.replace(/[-\\{}+?|^$.,[\]()#\s]/g, '\\$&').replace(/[*]/g, '.*') + '$');
}
function convertRegexString2RegExp(pattern, flag) {
return new RegExp(pattern, flag);
}
function convertSimple2RegExpPattern(pattern) {
return pattern.replace(/[-\\{}+?|^$.,[\]()#\s]/g, '\\$&').replace(/[*]/g, '.*');
}
function getIndentation(lineContent, position) {
if (lineContent.length < position) {
return 0;
}
for (let i = 0; i < position; i++) {
const char = lineContent.charCodeAt(i);
if (char !== 32 /* CharCode.Space */ && char !== 9 /* CharCode.Tab */) {
return i;
}
}
// assuming that current position is indentation
return position;
}
function safeCreateUnicodeRegExp(pattern) {
let flags = '';
pattern = pattern.replace(/\(\?([ims]+)\)/g, (_match, modifiers) => {
for (const modifier of modifiers) {
if (!flags.includes(modifier)) {
flags += modifier;
}
}
return '';
});
// fall back to regular regexp if we cannot create Unicode one
try {
return new RegExp(pattern, flags + 'u');
}
catch {
try {
return new RegExp(pattern, flags);
}
catch {
return undefined;
}
}
}
function getFirstNonWhitespaceCharacterAfterOffset(str, offset) {
offset++;
for (let i = offset; i < str.length; i++) {
const char = str.charAt(i);
if (char === ' ' || char === '\t') {
offset++;
}
else {
return offset;
}
}
return offset;
}
function extendedRegExp(pattern) {
let flags = '';
if (startsWith(pattern, '(?i)')) {
pattern = pattern.substring(4);
flags = 'i';
}
try {
return new RegExp(pattern, flags + 'u');
}
catch {
// could be an exception due to the 'u ' flag
try {
return new RegExp(pattern, flags);
}
catch {
// invalid pattern
return undefined;
}
}
}
});
//# sourceMappingURL=strings.js.map