Upload 5037 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+node_modules/.pnpm/@[email protected]/node_modules/@esbuild/win32-x64/esbuild.exe filter=lfs diff=lfs merge=lfs -text

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Fragment.d.ts

@@ -0,0 +1,8 @@
+export default class Fragment {
+    start: number;
+    end: number;
+    groups: string[];
+    slice: string;
+    constructor(source: string, start: number, end: number, groups?: string[]);
+    get length(): number;
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Fragment.js

@@ -0,0 +1,11 @@
+export default class Fragment {
+    constructor(source, start, end, groups = []) {
+        this.start = start;
+        this.end = end;
+        this.groups = groups;
+        this.slice = source.slice(start, end);
+    }
+    get length() {
+        return this.slice.length;
+    }
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Language.d.ts

@@ -0,0 +1,5 @@
+import Rule from "./Rule.js";
+declare type Language = {
+    readonly rules: Rule[];
+};
+export default Language;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Language.js

@@ -0,0 +1 @@
+export {};

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Match.d.ts

@@ -0,0 +1 @@
+export declare type Match = RegExpExecArray | RegExpMatchArray;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Match.js

@@ -0,0 +1 @@
+export {};

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Parser.d.ts

@@ -0,0 +1,25 @@
+import Rule from "./Rule.js";
+import Fragment from "./Fragment.js";
+import { LanguageName } from "./languages/index.js";
+export declare type FromTo = {
+    from: string | RegExp;
+    to: string | RegExp;
+};
+export default class Parser {
+    content: string;
+    private stopExpressionCache;
+    private _rules;
+    private language?;
+    get rules(): Rule[];
+    constructor(content: string, rules: LanguageName | Rule[]);
+    find(...expressions: Array<string | RegExp>): Fragment[];
+    replace(...fromTos: FromTo[]): string;
+    findDependencies(): Fragment[];
+    replaceDependencies(to: string): string;
+    private parse;
+    private getRuleExpression;
+    private getRuleStopExpression;
+    private getNextMatchExpression;
+    private getMatchingRule;
+    private resolveFragment;
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Parser.js

@@ -0,0 +1,154 @@
+import Fragment from "./Fragment.js";
+import languages from "./languages/index.js";
+export default class Parser {
+    constructor(content, rules) {
+        this.content = content;
+        this.stopExpressionCache = new Map();
+        this._rules = [];
+        if (typeof rules === "string")
+            this.language = rules;
+        else
+            this._rules = rules;
+    }
+    get rules() {
+        if (this.language)
+            return new languages[this.language]().rules;
+        return this._rules;
+    }
+    find(...expressions) {
+        const result = [];
+        const rules = [
+            ...expressions.map((expression) => ({ type: "match", expression })),
+            ...this.rules,
+        ];
+        this.parse(rules, (fragment) => result.push(fragment));
+        return result;
+    }
+    replace(...fromTos) {
+        let result = "";
+        let offset = 0;
+        const rules = [
+            ...fromTos.map(({ from, to }) => ({
+                type: "match",
+                expression: from,
+                from: new RegExp(`^${typeof from === "string" ? from : from.source}$`),
+                to,
+            })),
+            ...this.rules,
+        ];
+        this.parse(rules, (fragment, rule) => {
+            result += this.content.slice(offset, fragment.start);
+            if (rule.from !== undefined && rule.to !== undefined) {
+                result += fragment.slice.replace(rule.from, rule.to);
+            }
+            else {
+                result += fragment.slice;
+            }
+            offset = fragment.end;
+        });
+        result += this.content.slice(offset);
+        return result;
+    }
+    findDependencies() {
+        if (!this.language)
+            throw "[findDependencies] No language specified";
+        const importExpression = languages[this.language].importExpression;
+        if (!importExpression)
+            throw `[findDependencies] No importExpression for language ${this.language}`;
+        return this.find(importExpression);
+    }
+    replaceDependencies(to) {
+        if (!this.language)
+            throw "[findDependencies] No language specified";
+        const importExpression = languages[this.language].importExpression;
+        if (!importExpression)
+            throw `[findDependencies] No importExpression for language ${this.language}`;
+        return this.replace({ from: importExpression, to });
+    }
+    parse(rules, onMatch) {
+        const nextMatch = this.getNextMatchExpression(rules);
+        let match;
+        while ((match = nextMatch.exec(this.content))) {
+            const matchingRule = this.getMatchingRule(rules, match);
+            if (matchingRule == null)
+                continue;
+            const [rule, ruleMatch] = matchingRule;
+            const fragment = this.resolveFragment(rule, match, ruleMatch.slice(1));
+            if (!fragment) {
+                // the fragment has no end (good chances it is a syntax error)
+                console.warn("No stop found for rule", rule);
+                break;
+            }
+            // console.log("fragment:", fragment.slice)
+            nextMatch.lastIndex = fragment.end;
+            if (rule.type === "match")
+                onMatch(fragment, rule);
+        }
+    }
+    getRuleExpression(rule) {
+        const expression = "expression" in rule ? rule.expression : rule.startAt;
+        return typeof expression === "string" ? expression : expression.source;
+    }
+    getRuleStopExpression(rule) {
+        let expression = this.stopExpressionCache.get(rule);
+        if (expression)
+            return expression;
+        if ("expression" in rule)
+            throw "A standalone expression has no stop delimiter";
+        expression = new RegExp(typeof rule.stopAt === "string" ? rule.stopAt : rule.stopAt.source, "gm");
+        this.stopExpressionCache.set(rule, expression);
+        return expression;
+    }
+    getNextMatchExpression(rules) {
+        return new RegExp(rules.map((rule) => `(?:${this.getRuleExpression(rule)})`).join("|"), "gm");
+    }
+    getMatchingRule(rules, match) {
+        const [input] = match;
+        let noMatch = true;
+        // console.log(`Get matching rule of: '${input}'`)
+        for (const rule of rules) {
+            const ruleExpression = this.getRuleExpression(rule);
+            const ruleMatch = input.match(ruleExpression);
+            if (ruleMatch &&
+                ruleMatch.index === 0 &&
+                ruleMatch[0].length === input.length) {
+                noMatch = false;
+                if ("expression" in rule) {
+                    if ("onExpressionMatch" in rule &&
+                        rule.onExpressionMatch &&
+                        rule.onExpressionMatch(ruleMatch) === false) {
+                        continue;
+                    }
+                }
+                else {
+                    if (rule.onStartMatch && rule.onStartMatch(ruleMatch) === false)
+                        continue;
+                }
+                return [rule, ruleMatch];
+            }
+        }
+        if (noMatch) {
+            console.log("[getMatchingRule] No rules matched with match:", match);
+            throw "[getMatchingRule] No rules matched";
+        }
+        return null;
+    }
+    resolveFragment(rule, match, groups = []) {
+        const start = match.index;
+        const input = match[0];
+        const offset = start + input.length;
+        if ("expression" in rule)
+            return new Fragment(this.content, start, offset, groups);
+        else {
+            const nextStop = this.getRuleStopExpression(rule);
+            nextStop.lastIndex = offset - 1;
+            let stop;
+            while ((stop = nextStop.exec(this.content))) {
+                if (!rule.onStopMatch || rule.onStopMatch(stop) !== false) {
+                    return new Fragment(this.content, start, stop.index + stop[0].length, groups);
+                }
+            }
+            return null;
+        }
+    }
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/README.md

@@ -0,0 +1,160 @@
+**_Grubber_** is a lightweight and friendly utility to parse code with regular expressions in a 100% safe way - without having to use an AST 🐛
+
+In a higher level, Grubber also exposes helper functions to parse the dependencies of a file in many languages (Javascript, Typescript, Css, Scss, Python, Rust, C / C++, Nim, ...).
+
+## How?
+
+The problem with parsing a source file with regular expressions is that you cannot be sure your match is not commented or inside a string.
+
+For example, let's say you are looking for all `const` statements in a Javascript file - you would use a regular expression similar to:
+
+```ts
+/\bconst\s+/g;
+```
+
+But what if the file you want to parse is something like:
+
+```ts
+const x = 12;
+// const y = 13;
+let z = "const ";
+```
+
+Then you would match three `const` when only one should be matched.
+
+Grubber understands what is a string, what is a comment and what is code so that you can overcome the issue very easily:
+
+```ts
+import { grub } from "@digitak/grubber";
+
+const content = `
+const x = 12
+// const y = 13
+let z = "const "
+`;
+
+const results = grub(content).find(/\bconst\s+/);
+console.log(results.length); // will print 1 as expected
+```
+
+> For the sake of the demonstration we used a simple regex, but remember that Ecmascript is a tricky language! Effectively finding all `const` statements would require a more refined regex. Ex: `foo.const = 12` would be matched. Languages that use semi-colon at the end of every statement or strict indentation are much easier to parse in a 100% safe way.
+
+## Installation
+
+Use your favorite package manager:
+
+```
+npm install @digitak/grubber
+```
+
+## Grubber API
+
+Grubber exports one main function `grub`:
+
+```ts
+export function grub(
+	source: string,
+	languageOrRules: LanguageName | Rule[] = "es",
+): {
+	// find one or more expressions and return an array of fragments
+	find: (...expressions: Array<string | RegExp>) => Fragment[];
+
+	// replace one or more expressions and return the patched string
+	replace: (
+		...fromTos: Array<{
+			from: string | RegExp;
+			to: string | RegExp;
+		}>
+	) => string;
+
+	// find all dependencies (ex: `imports` in Typescript, `use` in Rust)
+	findDependencies: () => Fragment[];
+
+	// replace all dependencies by the given value
+	// you can use special replace patterns like "$1" to replace
+	// with the first captured group
+	replaceDependencies: (to: string) => string;
+};
+```
+
+The `find` and `findDependencies` methods both return an array of fragments:
+
+```ts
+export type Fragment = {
+	slice: string; // the matched substring
+	start: number; // start of the matched substring
+	end: number; // end of the matched substring
+	groups: string[] = []; // the captured groups
+};
+```
+
+### Using grubber with one of the preset languages
+
+You can use any of the preset languages:
+
+```ts
+export type LanguageName =
+	| "es" // Ecmascript (Javascript / Typescript / Haxe): the default
+	| "rs" // Rust
+	| "css"
+	| "scss"
+	| "sass"
+	| "c"
+	| "cpp"
+	| "py" // Python
+	| "nim";
+```
+
+Example:
+
+```ts
+// find all semi-colons inside the rust source code
+grub(rustCodeToParse, "rs").find(";");
+```
+
+### Using grubber with custom rules
+
+You may define custom rules for the grubber parser, ie. what should be ignored an treated as "not code".
+
+A `Rule` has the following type:
+
+```ts
+export type Rule =
+	| {
+			expression: string | RegExp; // the expression to ignore
+
+			// if returns false, the match is ignored
+			onExpressionMatch?: (match: RegExpExecArray) => boolean | void;
+	  }
+	| {
+			startAt: string | RegExp; // start of the expression to ignore
+			stopAt: string | RegExp; // stop of the expression to ignore
+
+			// if returns false, the match is ignored
+			onStartMatch?: (match: RegExpExecArray) => boolean | void;
+			onStopMatch?: (match: RegExpExecArray) => boolean | void;
+	  };
+```
+
+For example, the rules used for the `C` language are:
+
+```ts
+const rules: Rule[] = [
+	{
+		// string
+		expression: /".*?[^\\](?:\\\\)*"/,
+	},
+	{
+		// single line comment
+		expression: /\/\/.*/,
+	},
+	{
+		// multiline comment
+		expression: /\/\*((?:.|\s)*?)\*\//,
+	},
+];
+```
+
+> Rules are quite simple for most languages but get complicated for Ecmascript because of the `${...}` syntax. Hopefully the job is already done for you!
+
+🌿 🐛 🌿

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Rule.d.ts

@@ -0,0 +1,19 @@
+import { Match } from "./Match.js";
+export declare type MatchRule = {
+    type: "match";
+    expression: string | RegExp;
+    from?: RegExp;
+    to?: string;
+};
+declare type Rule = MatchRule | {
+    type?: undefined;
+    expression: string | RegExp;
+    onExpressionMatch?: (match: Match) => boolean | void;
+} | {
+    type?: undefined;
+    startAt: string | RegExp;
+    stopAt: string | RegExp;
+    onStartMatch?: (match: Match) => boolean | void;
+    onStopMatch?: (match: Match) => boolean | void;
+};
+export default Rule;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/Rule.js

@@ -0,0 +1 @@
+export {};

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/index.d.ts

@@ -0,0 +1,9 @@
+import Rule from "./Rule.js";
+import Parser from "./Parser.js";
+import Fragment from "./Fragment.js";
+import { LanguageName } from "./languages/index.js";
+/**
+ * @return a Parser instance with which the user can execute find and replace operations
+ */
+export declare function grub(content: string, rules?: Rule[] | LanguageName): Parser;
+export { Rule, LanguageName, Fragment, Parser };

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/index.js

@@ -0,0 +1,9 @@
+import Parser from "./Parser.js";
+import Fragment from "./Fragment.js";
+/**
+ * @return a Parser instance with which the user can execute find and replace operations
+ */
+export function grub(content, rules = "es") {
+    return new Parser(content, rules);
+}
+export { Fragment, Parser };

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/c.d.ts

@@ -0,0 +1,6 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/c.js

@@ -0,0 +1,19 @@
+export default class default_1 {
+    constructor() {
+        this.rules = [
+            {
+                // string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // single line comment
+                expression: /\/\/.*/,
+            },
+            {
+                // multiline comment
+                expression: /\/\*((?:.|\s)*?)\*\//,
+            },
+        ];
+    }
+}
+default_1.importExpression = /#include\s*"(.+?)"/g;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/cpp.d.ts

@@ -0,0 +1,6 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/cpp.js

@@ -0,0 +1,19 @@
+export default class default_1 {
+    constructor() {
+        this.rules = [
+            {
+                // string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // single line comment
+                expression: /\/\/.*/,
+            },
+            {
+                // multiline comment
+                expression: /\/\*((?:.|\s)*?)\*\//,
+            },
+        ];
+    }
+}
+default_1.importExpression = /#include\s*((?:".+?")|(?:<.+?>))/g;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/css.d.ts

@@ -0,0 +1,6 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/css.js

@@ -0,0 +1,19 @@
+export default class default_1 {
+    constructor() {
+        this.rules = [
+            {
+                // string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // string
+                expression: /'.*?[^\\](?:\\\\)*'/,
+            },
+            {
+                // comment
+                expression: /\/\*((?:.|\s)*?)\*\//,
+            },
+        ];
+    }
+}
+default_1.importExpression = /@import\s+("|')(.+?)\1/g;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/es.d.ts

@@ -0,0 +1,10 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    private backtickScope;
+    private get backtickLevel();
+    private get currentScope();
+    private set currentScope(value);
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/es.js

@@ -0,0 +1,65 @@
+export default class default_1 {
+    constructor() {
+        this.backtickScope = [];
+        this.rules = [
+            {
+                // single quote string
+                expression: /'.*?[^\\](?:\\\\)*'/,
+            },
+            {
+                // double quote string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // backtick string
+                startAt: /`|{|}/,
+                onStartMatch: (match) => {
+                    if (match[0] === "{") {
+                        if (this.backtickLevel)
+                            this.currentScope++;
+                        return false;
+                    }
+                    else if (match[0] === "}") {
+                        if (this.backtickLevel) {
+                            if (this.currentScope === 0) {
+                                this.backtickScope.pop();
+                                return true;
+                            }
+                            this.currentScope--;
+                        }
+                        return false;
+                    }
+                    return true;
+                },
+                stopAt: /[^\\](?:\\\\)*(\${|`)/,
+                onStopMatch: (match) => {
+                    if (match[1] === "${")
+                        this.backtickScope.push(0);
+                    return true;
+                },
+            },
+            {
+                // single line comment
+                expression: /\/\/.*/,
+            },
+            {
+                // multiline comment
+                expression: /\/\*((?:.|\s)*?)\*\//,
+            },
+            {
+                // regular expression
+                expression: /[=,;?(\n]\s*\/[^/*].*?[^\\](?:\\\\)*\//,
+            },
+        ];
+    }
+    get backtickLevel() {
+        return this.backtickScope.length;
+    }
+    get currentScope() {
+        return this.backtickScope[this.backtickScope.length - 1];
+    }
+    set currentScope(value) {
+        this.backtickScope[this.backtickScope.length - 1] = value;
+    }
+}
+default_1.importExpression = /\b(?:import|export)(?:\s+([^;()[\]=/'"`+\-:.]+?)\s+from)?\s+('|")(.+?)\2/g;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/index.d.ts

@@ -0,0 +1,22 @@
+import es from "./es.js";
+import c from "./c.js";
+import cpp from "./cpp.js";
+import css from "./css.js";
+import scss from "./scss.js";
+import sass from "./sass.js";
+import nim from "./nim.js";
+import py from "./py.js";
+import rs from "./rs.js";
+declare const languages: {
+    es: typeof es;
+    c: typeof c;
+    cpp: typeof cpp;
+    css: typeof css;
+    scss: typeof scss;
+    sass: typeof sass;
+    nim: typeof nim;
+    py: typeof py;
+    rs: typeof rs;
+};
+export default languages;
+export declare type LanguageName = keyof typeof languages;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/index.js

@@ -0,0 +1,21 @@
+import es from "./es.js";
+import c from "./c.js";
+import cpp from "./cpp.js";
+import css from "./css.js";
+import scss from "./scss.js";
+import sass from "./sass.js";
+import nim from "./nim.js";
+import py from "./py.js";
+import rs from "./rs.js";
+const languages = {
+    es,
+    c,
+    cpp,
+    css,
+    scss,
+    sass,
+    nim,
+    py,
+    rs,
+};
+export default languages;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/nim.d.ts

@@ -0,0 +1,6 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/nim.js

@@ -0,0 +1,19 @@
+export default class default_1 {
+    constructor() {
+        this.rules = [
+            {
+                // string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // multiline comment
+                expression: /#\[((?:.|\s)*?)\]#/,
+            },
+            {
+                // comment
+                expression: /#.*/,
+            },
+        ];
+    }
+}
+default_1.importExpression = /^(?:(?:(\bfrom +(.*?) +)?(\bimport) +(.*?))|(?:(\binclude) +(.*?))) *$/gm;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/py.d.ts

@@ -0,0 +1,6 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/py.js

@@ -0,0 +1,23 @@
+export default class default_1 {
+    constructor() {
+        this.rules = [
+            {
+                // multi line string
+                expression: /"""((?:.|\s)*?)[^\\](?:\\\\)*"""/,
+            },
+            {
+                // single quote string
+                expression: /'.*?[^\\](?:\\\\)*'/,
+            },
+            {
+                // double quote string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // comment
+                expression: /#.*/,
+            },
+        ];
+    }
+}
+default_1.importExpression = /^(?:(?:\bfrom +(.*?) +)?(\bimport) +(.*?)) *(?:\bas +(.*?))? *$/gm;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/rs.d.ts

@@ -0,0 +1,6 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/rs.js

@@ -0,0 +1,19 @@
+export default class default_1 {
+    constructor() {
+        this.rules = [
+            {
+                // string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // single line comment
+                expression: /\/\/.*/,
+            },
+            {
+                // multiline comment
+                expression: /\/\*((?:.|\s)*?)\*\//,
+            },
+        ];
+    }
+}
+default_1.importExpression = /\buse\s+(.+?)\s*;/g;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/sass.d.ts

@@ -0,0 +1,6 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/sass.js

@@ -0,0 +1,23 @@
+export default class default_1 {
+    constructor() {
+        this.rules = [
+            {
+                // string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // string
+                expression: /'.*?[^\\](?:\\\\)*'/,
+            },
+            {
+                // single line comment
+                expression: /\/\/.*/,
+            },
+            {
+                // multiline comment
+                expression: /\/\*((?:.|\s)*?)\*\//,
+            },
+        ];
+    }
+}
+default_1.importExpression = /@(import|use)[ \t]+([^ \t]+?)[ \t]*(?:\n|$|;)/gm;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/scss.d.ts

@@ -0,0 +1,6 @@
+import Language from "../Language.js";
+import Rule from "../Rule.js";
+export default class implements Language {
+    static readonly importExpression: RegExp;
+    readonly rules: Rule[];
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/languages/scss.js

@@ -0,0 +1,23 @@
+export default class default_1 {
+    constructor() {
+        this.rules = [
+            {
+                // string
+                expression: /".*?[^\\](?:\\\\)*"/,
+            },
+            {
+                // string
+                expression: /'.*?[^\\](?:\\\\)*'/,
+            },
+            {
+                // single line comment
+                expression: /\/\/.*/,
+            },
+            {
+                // multiline comment
+                expression: /\/\*((?:.|\s)*?)\*\//,
+            },
+        ];
+    }
+}
+default_1.importExpression = /@(import|use)\s*("|')(.+?)\2/g;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "@digitak/grubber",
+	"version": "3.1.4",
+	"description": "Parse code files and patch it without having to use an AST",
+	"type": "module",
+	"main": "index.js",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"scripts": {
+		"test": "esrun test",
+		"test:jsimports": "esrun test/patchJsImports",
+		"build": "esrun scripts/build",
+		"lint": "eslint source",
+		"lint:fix": "eslint source --fix"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/digital-loukoum/grubber.git"
+	},
+	"keywords": [
+		"dependencies",
+		"parse",
+		"patch",
+		"find",
+		"replace",
+		"code",
+		"typescript",
+		"javascript",
+		"python",
+		"rust",
+		"c",
+		"c++",
+		"css",
+		"scss",
+		"nim"
+	],
+	"author": "Gin Quin",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/digital-loukoum/grubber/issues"
+	},
+	"homepage": "https://github.com/digital-loukoum/grubber#readme",
+	"devDependencies": {
+		"@digitak/esrun": "^3.1.2",
+		"@types/node": "^17.0.17",
+		"@typescript-eslint/eslint-plugin": "^5.28.0",
+		"@typescript-eslint/parser": "^5.28.0",
+		"eslint": "^8.17.0",
+		"eslint-plugin-import": "^2.26.0",
+		"fartest": "^2.1.8",
+		"ncp": "^2.0.0",
+		"prettier": "^2.7.1",
+		"typescript": "^4.7.3"
+	}
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/utilities/addJsExtensions.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @param resolve callback that take a module endpoint as entry and the right .js file that is imported
+ */
+export default function addJsExtensions(content: string, resolve: (imported: string) => string): string;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/utilities/addJsExtensions.js

@@ -0,0 +1,22 @@
+import Parser from "../Parser.js";
+// import { createRequire } from "module"
+/**
+ * @param resolve callback that take a module endpoint as entry and the right .js file that is imported
+ */
+export default function addJsExtensions(content, resolve) {
+    const dependencies = new Parser(content, "es").findDependencies();
+    let result = "";
+    let offset = 0;
+    for (const dependency of dependencies) {
+        const imported = dependency.groups[2].trim();
+        const patchedImport = resolve(imported);
+        if (patchedImport !== imported) {
+            result +=
+                content.slice(offset, dependency.start) +
+                    dependency.slice.replace(imported, patchedImport);
+            offset = dependency.end;
+        }
+    }
+    result += content.slice(offset);
+    return result;
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/utilities/patchJsImports.d.ts

@@ -0,0 +1,10 @@
+import { AliasResolver } from "./resolveAliases.js";
+/**
+ * When Typescript compiles dependencies, it adds no '.js' extension at the end of imports.
+ * The problem is: browser, Node and Deno all need this '.js' extension.
+ * (Thanks #TypescriptTeam for not being standard, look at all the additional work you make me do!)
+ * (All this work for three stupid letters!...)
+ * (Love your work though, Typescript is an awesome language <3)
+ * This utility function can be used after a Typescript compilation to add the mandatory '.js'
+ */
+export default function patchJsImports(directories: string[], aliases?: Array<AliasResolver>): void;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/utilities/patchJsImports.js

@@ -0,0 +1,55 @@
+import { readdirSync, statSync, readFileSync, writeFileSync } from "fs";
+import addJsExtensions from "./addJsExtensions.js";
+import { relative as relativePath, resolve as resolvePath, sep, posix } from "path";
+import { createRequire } from "module";
+import { resolveAliases } from "./resolveAliases.js";
+const require = createRequire(process.cwd());
+const resolve = (dependency, directory) => require
+    .resolve(dependency, { paths: [directory] })
+    .split(sep)
+    .join(posix.sep);
+const relative = (directory, path) => relativePath(directory, path).split(sep).join(posix.sep);
+const NODE_MODULES_DIR_REGEX = /(^|\/)node_modules(\/|$)/;
+/**
+ * When Typescript compiles dependencies, it adds no '.js' extension at the end of imports.
+ * The problem is: browser, Node and Deno all need this '.js' extension.
+ * (Thanks #TypescriptTeam for not being standard, look at all the additional work you make me do!)
+ * (All this work for three stupid letters!...)
+ * (Love your work though, Typescript is an awesome language <3)
+ * This utility function can be used after a Typescript compilation to add the mandatory '.js'
+ */
+export default function patchJsImports(directories, aliases) {
+    for (let directory of directories) {
+        directory = resolvePath(directory);
+        for (const element of readdirSync(directory)) {
+            const entity = `${directory}/${element}`;
+            if (statSync(entity).isDirectory()) {
+                patchJsImports([entity], aliases);
+            }
+            else {
+                // only patch .js, .cjs and .mjs files
+                if (!element.match(/\.[mc]?js$/))
+                    continue;
+                const content = readFileSync(entity, "utf8");
+                const patchedContent = addJsExtensions(content, imported => {
+                    const resolvedAlias = resolveAliases(imported, aliases);
+                    if (resolvedAlias != null)
+                        return resolvedAlias;
+                    let path = resolve(imported, directory);
+                    if (path !== imported) {
+                        const isNodeModulePath = NODE_MODULES_DIR_REGEX.test(path);
+                        if (isNodeModulePath)
+                            path = imported;
+                        else {
+                            path = relative(directory, path);
+                            if (path[0] !== "." && path[0] !== "/")
+                                path = `./${path}`;
+                        }
+                    }
+                    return path;
+                });
+                writeFileSync(entity, patchedContent);
+            }
+        }
+    }
+}

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/utilities/resolveAliases.d.ts

@@ -0,0 +1,5 @@
+export declare type AliasResolver = {
+    find: RegExp;
+    replacement: string | null;
+};
+export declare function resolveAliases(path: string, aliases?: Array<AliasResolver>): string | null;

node_modules/.pnpm/@[email protected]/node_modules/@digitak/grubber/utilities/resolveAliases.js

@@ -0,0 +1,13 @@
+export function resolveAliases(path, aliases) {
+    if (aliases) {
+        for (const { find, replacement } of aliases) {
+            if (find.test(path)) {
+                if (replacement)
+                    return path.replace(find, replacement);
+                else
+                    return path;
+            }
+        }
+    }
+    return null;
+}

node_modules/.pnpm/@[email protected]/node_modules/@esbuild/win32-x64/README.md

@@ -0,0 +1,3 @@
+# esbuild
+
+This is the Windows 64-bit binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild for details.

node_modules/.pnpm/@[email protected]/node_modules/@esbuild/win32-x64/esbuild.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:feeb10cd8033b936130dcd8f9c82c4bf6da66ca9f003c12455e6a94a80ba8753
+size 9303552

node_modules/.pnpm/@[email protected]/node_modules/@esbuild/win32-x64/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@esbuild/win32-x64",
+  "version": "0.17.19",
+  "description": "The Windows 64-bit binary for esbuild, a JavaScript bundler.",
+  "repository": "https://github.com/evanw/esbuild",
+  "license": "MIT",
+  "preferUnplugged": true,
+  "engines": {
+    "node": ">=12"
+  },
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

node_modules/.pnpm/@[email protected]/node_modules/@silentbot1/nat-api/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "04:00"
+  open-pull-requests-limit: 10

node_modules/.pnpm/@[email protected]/node_modules/@silentbot1/nat-api/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: ci
+on: [push,pull_request]
+jobs:
+  test:
+    name: Node ${{ matrix.node }} / ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+        node:
+          - '10'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm install
+      - run: npm test

node_modules/.pnpm/@[email protected]/node_modules/@silentbot1/nat-api/.idea/aws.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="accountSettings">
+    <option name="activeProfile" value="profile:default" />
+    <option name="activeRegion" value="us-east-1" />
+    <option name="recentlyUsedProfiles">
+      <list>
+        <option value="profile:default" />
+      </list>
+    </option>
+    <option name="recentlyUsedRegions">
+      <list>
+        <option value="us-east-1" />
+      </list>
+    </option>
+  </component>
+</project>

node_modules/.pnpm/@[email protected]/node_modules/@silentbot1/nat-api/.idea/codeStyles/Project.xml

@@ -0,0 +1,31 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <JSCodeStyleSettings version="0">
+      <option name="USE_SEMICOLON_AFTER_STATEMENT" value="false" />
+      <option name="FORCE_SEMICOLON_STYLE" value="true" />
+      <option name="SPACE_BEFORE_GENERATOR_MULT" value="true" />
+      <option name="USE_DOUBLE_QUOTES" value="false" />
+      <option name="FORCE_QUOTE_STYlE" value="true" />
+      <option name="SPACES_WITHIN_OBJECT_LITERAL_BRACES" value="true" />
+      <option name="SPACES_WITHIN_IMPORTS" value="true" />
+    </JSCodeStyleSettings>
+    <TypeScriptCodeStyleSettings version="0">
+      <option name="SPACES_WITHIN_OBJECT_LITERAL_BRACES" value="true" />
+      <option name="SPACES_WITHIN_IMPORTS" value="true" />
+    </TypeScriptCodeStyleSettings>
+    <codeStyleSettings language="JavaScript">
+      <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
+      <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
+      <option name="ALIGN_MULTILINE_FOR" value="false" />
+      <option name="SPACE_BEFORE_METHOD_PARENTHESES" value="true" />
+      <option name="TERNARY_OPERATION_SIGNS_ON_NEXT_LINE" value="true" />
+      <option name="KEEP_SIMPLE_BLOCKS_IN_ONE_LINE" value="true" />
+      <option name="KEEP_SIMPLE_METHODS_IN_ONE_LINE" value="true" />
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="2" />
+        <option name="TAB_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
+  </code_scheme>
+</component>

node_modules/.pnpm/@[email protected]/node_modules/@silentbot1/nat-api/.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

node_modules/.pnpm/@[email protected]/node_modules/@silentbot1/nat-api/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="StandardJS" enabled="true" level="ERROR" enabled_by_default="true" />
+  </profile>
+</component>