@codingame/monaco-vscode-api 1.76.2 → 1.76.3-next.0

package/dist/resources.js

@@ -0,0 +1,197 @@
+import { posix, dirname, normalize, relative, resolve, sep } from 'monaco-editor/esm/vs/base/common/path.js';
+import { compare, equalsIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isEqualOrParent, toSlashes, toPosixPath, getRoot } from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { URI, uriToFsPath } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+function originalFSPath(uri) {
+    return uriToFsPath(uri, true);
+}
+class ExtUri {
+    constructor(_ignorePathCasing) {
+        this._ignorePathCasing = _ignorePathCasing;
+    }
+    compare(uri1, uri2, ignoreFragment = false) {
+        if (uri1 === uri2) {
+            return 0;
+        }
+        return compare(this.getComparisonKey(uri1, ignoreFragment), this.getComparisonKey(uri2, ignoreFragment));
+    }
+    isEqual(uri1, uri2, ignoreFragment = false) {
+        if (uri1 === uri2) {
+            return true;
+        }
+        if (!uri1 || !uri2) {
+            return false;
+        }
+        return this.getComparisonKey(uri1, ignoreFragment) === this.getComparisonKey(uri2, ignoreFragment);
+    }
+    getComparisonKey(uri, ignoreFragment = false) {
+        return ( uri.with({
+            path: this._ignorePathCasing(uri) ? uri.path.toLowerCase() : undefined,
+            fragment: ignoreFragment ? null : undefined
+        }).toString());
+    }
+    ignorePathCasing(uri) {
+        return this._ignorePathCasing(uri);
+    }
+    isEqualOrParent(base, parentCandidate, ignoreFragment = false) {
+        if (base.scheme === parentCandidate.scheme) {
+            if (base.scheme === Schemas.file) {
+                return isEqualOrParent(originalFSPath(base), originalFSPath(parentCandidate), this._ignorePathCasing(base)) && base.query === parentCandidate.query && (ignoreFragment || base.fragment === parentCandidate.fragment);
+            }
+            if (isEqualAuthority(base.authority, parentCandidate.authority)) {
+                return isEqualOrParent(base.path, parentCandidate.path, this._ignorePathCasing(base), '/') && base.query === parentCandidate.query && (ignoreFragment || base.fragment === parentCandidate.fragment);
+            }
+        }
+        return false;
+    }
+    joinPath(resource, ...pathFragment) {
+        return URI.joinPath(resource, ...pathFragment);
+    }
+    basenameOrAuthority(resource) {
+        return basename(resource) || resource.authority;
+    }
+    basename(resource) {
+        return posix.basename(resource.path);
+    }
+    extname(resource) {
+        return posix.extname(resource.path);
+    }
+    dirname(resource) {
+        if (resource.path.length === 0) {
+            return resource;
+        }
+        let dirname$1;
+        if (resource.scheme === Schemas.file) {
+            dirname$1 = URI.file(dirname(originalFSPath(resource))).path;
+        }
+        else {
+            dirname$1 = posix.dirname(resource.path);
+            if (resource.authority && dirname$1.length && dirname$1.charCodeAt(0) !== 47 ) {
+                console.error(`dirname("${resource.toString})) resulted in a relative path`);
+                dirname$1 = '/';
+            }
+        }
+        return resource.with({
+            path: dirname$1
+        });
+    }
+    normalizePath(resource) {
+        if (!resource.path.length) {
+            return resource;
+        }
+        let normalizedPath;
+        if (resource.scheme === Schemas.file) {
+            normalizedPath = URI.file(normalize(originalFSPath(resource))).path;
+        }
+        else {
+            normalizedPath = posix.normalize(resource.path);
+        }
+        return resource.with({
+            path: normalizedPath
+        });
+    }
+    relativePath(from, to) {
+        if (from.scheme !== to.scheme || !isEqualAuthority(from.authority, to.authority)) {
+            return undefined;
+        }
+        if (from.scheme === Schemas.file) {
+            const relativePath = relative(originalFSPath(from), originalFSPath(to));
+            return isWindows ? toSlashes(relativePath) : relativePath;
+        }
+        let fromPath = from.path || '/';
+        const toPath = to.path || '/';
+        if (this._ignorePathCasing(from)) {
+            let i = 0;
+            for (const len = Math.min(fromPath.length, toPath.length); i < len; i++) {
+                if (fromPath.charCodeAt(i) !== toPath.charCodeAt(i)) {
+                    if (fromPath.charAt(i).toLowerCase() !== toPath.charAt(i).toLowerCase()) {
+                        break;
+                    }
+                }
+            }
+            fromPath = toPath.substr(0, i) + fromPath.substr(i);
+        }
+        return posix.relative(fromPath, toPath);
+    }
+    resolvePath(base, path) {
+        if (base.scheme === Schemas.file) {
+            const newURI = URI.file(resolve(originalFSPath(base), path));
+            return base.with({
+                authority: newURI.authority,
+                path: newURI.path
+            });
+        }
+        path = toPosixPath(path);
+        return base.with({
+            path: posix.resolve(base.path, path)
+        });
+    }
+    isAbsolutePath(resource) {
+        return !!resource.path && resource.path[0] === '/';
+    }
+    isEqualAuthority(a1, a2) {
+        return a1 === a2 || (a1 !== undefined && a2 !== undefined && equalsIgnoreCase(a1, a2));
+    }
+    hasTrailingPathSeparator(resource, sep$1 = sep) {
+        if (resource.scheme === Schemas.file) {
+            const fsp = originalFSPath(resource);
+            return fsp.length > getRoot(fsp).length && fsp[fsp.length - 1] === sep$1;
+        }
+        else {
+            const p = resource.path;
+            return ((p.length > 1 && p.charCodeAt(p.length - 1) === 47) ) && !(/^[a-zA-Z]:(\/$|\\$)/.test(resource.fsPath));
+        }
+    }
+    removeTrailingPathSeparator(resource, sep$1 = sep) {
+        if (hasTrailingPathSeparator(resource, sep$1)) {
+            return resource.with({ path: resource.path.substr(0, resource.path.length - 1) });
+        }
+        return resource;
+    }
+    addTrailingPathSeparator(resource, sep$1 = sep) {
+        let isRootSep = false;
+        if (resource.scheme === Schemas.file) {
+            const fsp = originalFSPath(resource);
+            isRootSep = ((fsp !== undefined) && (fsp.length === getRoot(fsp).length) && (fsp[fsp.length - 1] === sep$1));
+        }
+        else {
+            sep$1 = '/';
+            const p = resource.path;
+            isRootSep = p.length === 1 && p.charCodeAt(p.length - 1) === 47 ;
+        }
+        if (!isRootSep && !hasTrailingPathSeparator(resource, sep$1)) {
+            return resource.with({ path: resource.path + '/' });
+        }
+        return resource;
+    }
+}
+const extUri = ( new ExtUri(() => false));
+extUri.isEqual.bind(extUri);
+extUri.isEqualOrParent.bind(extUri);
+extUri.getComparisonKey.bind(extUri);
+extUri.basenameOrAuthority.bind(extUri);
+const basename = extUri.basename.bind(extUri);
+extUri.extname.bind(extUri);
+extUri.dirname.bind(extUri);
+extUri.joinPath.bind(extUri);
+extUri.normalizePath.bind(extUri);
+extUri.relativePath.bind(extUri);
+extUri.resolvePath.bind(extUri);
+extUri.isAbsolutePath.bind(extUri);
+const isEqualAuthority = extUri.isEqualAuthority.bind(extUri);
+const hasTrailingPathSeparator = extUri.hasTrailingPathSeparator.bind(extUri);
+extUri.removeTrailingPathSeparator.bind(extUri);
+extUri.addTrailingPathSeparator.bind(extUri);
+function toLocalResource(resource, authority, localScheme) {
+    if (authority) {
+        let path = resource.path;
+        if (path && path[0] !== posix.sep) {
+            path = posix.sep + path;
+        }
+        return resource.with({ scheme: localScheme, authority, path });
+    }
+    return resource.with({ scheme: localScheme });
+}
+export { toLocalResource as t };