WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1,11 @@
|
||||
/* eslint-disable @typescript-eslint/ban-ts-comment */
|
||||
|
||||
// @ts-ignore `terser` may not be installed
|
||||
export type * as Terser from 'terser'
|
||||
// @ts-ignore `terser` may not be installed
|
||||
import type * as Terser from 'terser'
|
||||
|
||||
/* eslint-enable @typescript-eslint/ban-ts-comment */
|
||||
|
||||
export type TerserMinifyOptions = Terser.MinifyOptions
|
||||
export type TerserMinifyOutput = Terser.MinifyOutput
|
||||
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"main": "../../cjs/_class_static_private_method_get.cjs",
|
||||
"module": "../../esm/_class_static_private_method_get.js"
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
export declare const version: string;
|
||||
export declare const versionMajorMinor = "7.0";
|
||||
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"main": "../../cjs/_apply_decorated_descriptor.cjs",
|
||||
"module": "../../esm/_apply_decorated_descriptor.js"
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,6 @@
|
||||
function _check_private_redeclaration(obj, privateCollection) {
|
||||
if (privateCollection.has(obj)) {
|
||||
throw new TypeError("Cannot initialize the same private elements twice on an object");
|
||||
}
|
||||
}
|
||||
export { _check_private_redeclaration as _ };
|
||||
@@ -0,0 +1,24 @@
|
||||
'use strict'
|
||||
|
||||
const test = require('node:test')
|
||||
const assert = require('node:assert')
|
||||
const { join } = require('node:path')
|
||||
const execa = require('execa')
|
||||
|
||||
test('when using a custom transport outside node_modules, the first file outside node_modules should be used', async function () {
|
||||
const evalApp = join(__dirname, '../', '/fixtures/eval/index.js')
|
||||
const { stdout } = await execa(process.argv[0], [evalApp])
|
||||
assert.match(stdout, /done!/)
|
||||
})
|
||||
|
||||
test('when using a custom transport where some files in stacktrace are in the node_modules, the first file outside node_modules should be used', async function () {
|
||||
const evalApp = join(__dirname, '../', '/fixtures/eval/node_modules/2-files.js')
|
||||
const { stdout } = await execa(process.argv[0], [evalApp])
|
||||
assert.match(stdout, /done!/)
|
||||
})
|
||||
|
||||
test('when using a custom transport where all files in stacktrace are in the node_modules, the first file inside node_modules should be used', async function () {
|
||||
const evalApp = join(__dirname, '../', '/fixtures/eval/node_modules/14-files.js')
|
||||
const { stdout } = await execa(process.argv[0], [evalApp])
|
||||
assert.match(stdout, /done!/)
|
||||
})
|
||||
@@ -0,0 +1,16 @@
|
||||
"use strict";
|
||||
// THIS CODE WAS AUTOMATICALLY GENERATED
|
||||
// DO NOT EDIT THIS CODE BY HAND
|
||||
// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
|
||||
// npx nx generate-lib repo
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.esnext_collection = void 0;
|
||||
const base_config_1 = require("./base-config");
|
||||
const es2025_collection_1 = require("./es2025.collection");
|
||||
exports.esnext_collection = {
|
||||
libs: [es2025_collection_1.es2025_collection],
|
||||
variables: [
|
||||
['Map', base_config_1.TYPE],
|
||||
['WeakMap', base_config_1.TYPE],
|
||||
],
|
||||
};
|
||||
@@ -0,0 +1,81 @@
|
||||
# fast-stable-stringify
|
||||
*Notice: The License of this repository has been changed from GPL-3.0 to MIT as of 2017-08-25. All following commits will fall under the MIT license.*
|
||||
|
||||
[](https://travis-ci.org/nickyout/fast-stable-stringify)
|
||||
[](https://saucelabs.com/u/nickyout_fast-stable)
|
||||
|
||||
_The test only succeeds when mine is faster than substack's in a particular browser._
|
||||
|
||||
The most popular repository providing this feature is [substack's json-stable-stringify][sub]. The intent if this library is to provide a faster alternative for when performance is more important than features. It assumes you provide basic javascript values without circular references, and returns a non-indented string.
|
||||
|
||||
It currently offers a performance boost in popular browsers of about 40%. See the comparsion table below.
|
||||
|
||||
Usage:
|
||||
|
||||
```javascript
|
||||
var stringify = require('fast-stable-stringify');
|
||||
stringify({ d: 0, c: 1, a: 2, b: 3, e: 4 }); // '{"a":2,"b":3,"c":1,"d":0,"e":4}'
|
||||
```
|
||||
|
||||
Just like substack's, it does:
|
||||
|
||||
* handle all variations of all basic javascript values (number, string, boolean, array, object, null, Date)
|
||||
* handle undefined _and_ function in the same way as `JSON.stringify`
|
||||
* **not support ie8 (and below) with complete certainty**.
|
||||
|
||||
Unlike substack's, it does:
|
||||
|
||||
* not implement the 'replacer' or 'space' arguments of the JSON.stringify method
|
||||
* not check for circular references
|
||||
|
||||
## Test results
|
||||
Tested validity (answer equal to substack's) and benchmark (faster than substack's). A test passes only if it has the same output as substack's but is faster (as concluded by [benchmark.js][ben]).
|
||||
|
||||
To (hopefully) prevent [certain smart browsers][cat] from concluding the stringification is not necessary because it is never used anywhere, I summed up all the lengths of the resulting strings of each benchmark contestant and printed it along with the result data.
|
||||
|
||||
### Latest interpreted result
|
||||
|
||||
See [caniuse browser usage][usg] for the 'most popular browsers'.
|
||||
|
||||
| Suite | Browser | JSON.stringify@native | fast-stable-stringify@a9f81e8 | json-stable-stringify@1.0.1 | faster-stable-stringify@1.0.0 |
|
||||
| :---- | :-------------------------------------- | --------------------: | ----------------------------: | --------------------------: | ----------------------------: |
|
||||
| libs | Chrome 60.0.3112 (Windows 7 0.0.0) | 414.45% (±2.67%) | *146.41% (±1.74%) | 100.00% (±1.11%) | 111.26% (±1.24%) |
|
||||
| libs | Chrome Mobile 55.0.2883 (Android 6.0.0) | 495.16% (±16.9%) | *162.18% (±3.59%) | 100.00% (±5.44%) | 129.66% (±3.20%) |
|
||||
| libs | Edge 14.14393.0 (Windows 10 0.0.0) | 487.88% (±11.9%) | *138.69% (±2.27%) | 100.00% (±1.51%) | 113.19% (±1.56%) |
|
||||
| libs | Firefox 54.0.0 (Windows 7 0.0.0) | 530.66% (±17.6%) | *169.34% (±2.38%) | 100.00% (±1.68%) | 152.30% (±2.48%) |
|
||||
| libs | IE 10.0.0 (Windows 7 0.0.0) | 427.80% (±10.9%) | *183.26% (±3.02%) | 100.00% (±2.42%) | ? |
|
||||
| libs | IE 11.0.0 (Windows 7 0.0.0) | 298.01% (±4.35%) | *136.25% (±1.89%) | 100.00% (±1.73%) | ? |
|
||||
| libs | IE 9.0.0 (Windows 7 0.0.0) | 316.18% (±4.01%) | *170.14% (±2.30%) | 100.00% (±1.52%) | ? |
|
||||
| libs | Mobile Safari 10.0.0 (iOS 10.3.0) | 554.98% (±23.7%) | *115.33% (±4.23%) | 100.00% (±3.11%) | *118.66% (±2.96%) |
|
||||
| libs | Safari 10.0.1 (Mac OS X 10.12.1) | 722.94% (±24.8%) | *119.49% (±3.62%) | 100.00% (±2.12%) | 106.06% (±3.12%) |
|
||||
|
||||
Click the build status badge to view the original output.
|
||||
|
||||
Disclaimer: the more I test the more I realize how many factors actually affect the outcome. Not only the browser and browser version, but particularly the json content and a random factor in every test run. Outcomes may sometimes vary more than 10% between tests, despite my attempt to reduce this by increasing the sample size to 2.5 times. Nevertheless, the overall picture typically still holds.
|
||||
|
||||
`JSON.stringify` has been added for reference. In general, aside from the cases where you need the guarantee of a stable result, I would recommend against using this library, or any stable stringification library for that matter.
|
||||
|
||||
[`faster-stable-stringify`][fss] has been added for comparison. It seems it does not work in IE 9 to 11 without a polyfill solution for WeakMap. It is displayed as somewhat slower, but as I decided on the JSON input to test and develop against, this result may be somewhat biased. In some test runs, [`faster-stable-stringify`][fss] will be faster in a browser. In fact, it is consistently somewhat faster in the Mobile Safari 10.
|
||||
|
||||
## Note about string escaping
|
||||
The original implementation was with regexp. A pull request showed a literal string approach that was faster in some browsers. Other libraries would just use JSON.stringify. After a speed comparison between all three methods, it became clear that native JSON.stringify is generally much faster in string escaping than both these methods, even in the IE legacy browsers. The browsers that do not have `JSON.stringify` are not offered for test automation, and when looking at the [usage percentage][usg] of such browsers I no longer see a reason to not use `JSON.stringify`.
|
||||
|
||||
Therefore, the exposed regexp and string are removed from the API. If you still need this functionality, I simply encourage you to use `JSON.stringify`.
|
||||
|
||||
## Running tests
|
||||
It runs karma-benchmark tests now. For testing in node, do:
|
||||
|
||||
```
|
||||
npm test
|
||||
```
|
||||
|
||||
This requires [saucelabs credentials in your env][env]. That, or edit the karma.conf.js to your liking.
|
||||
|
||||
Running this test will cause files in `./results/libs/` to update. Run `npm run table` to get a pretty md table of the results.
|
||||
|
||||
[sub]: https://github.com/substack/json-stable-stringify
|
||||
[ben]: https://github.com/bestiejs/benchmark.js
|
||||
[cat]: http://mrale.ph/blog/2014/02/23/the-black-cat-of-microbenchmarks.html
|
||||
[usg]: http://caniuse.com/usage-table
|
||||
[env]: https://wiki.saucelabs.com/display/DOCS/Best+Practice%3A+Use+Environment+Variables+for+Authentication+Credentials
|
||||
[fss]: https://github.com/ppaskaris/faster-stable-stringify
|
||||
@@ -0,0 +1,12 @@
|
||||
function _defineEnumerableProperties(e, r) {
|
||||
for (var t in r) {
|
||||
var n = r[t];
|
||||
n.configurable = n.enumerable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, t, n);
|
||||
}
|
||||
if (Object.getOwnPropertySymbols) for (var a = Object.getOwnPropertySymbols(r), b = 0; b < a.length; b++) {
|
||||
var i = a[b];
|
||||
(n = r[i]).configurable = n.enumerable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, i, n);
|
||||
}
|
||||
return e;
|
||||
}
|
||||
export { _defineEnumerableProperties as default };
|
||||
@@ -0,0 +1,142 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils_1 = require("@typescript-eslint/utils");
|
||||
const util_1 = require("../util");
|
||||
const confusingOperators = new Set([
|
||||
'=',
|
||||
'==',
|
||||
'===',
|
||||
'in',
|
||||
'instanceof',
|
||||
]);
|
||||
function isConfusingOperator(operator) {
|
||||
return confusingOperators.has(operator);
|
||||
}
|
||||
exports.default = (0, util_1.createRule)({
|
||||
name: 'no-confusing-non-null-assertion',
|
||||
meta: {
|
||||
type: 'problem',
|
||||
docs: {
|
||||
description: 'Disallow non-null assertion in locations that may be confusing',
|
||||
recommended: 'stylistic',
|
||||
},
|
||||
hasSuggestions: true,
|
||||
messages: {
|
||||
confusingAssign: 'Confusing combination of non-null assertion and assignment like `a! = b`, which looks very similar to `a != b`.',
|
||||
confusingEqual: 'Confusing combination of non-null assertion and equality test like `a! == b`, which looks very similar to `a !== b`.',
|
||||
confusingOperator: 'Confusing combination of non-null assertion and `{{operator}}` operator like `a! {{operator}} b`, which might be misinterpreted as `!(a {{operator}} b)`.',
|
||||
notNeedInAssign: 'Remove unnecessary non-null assertion (!) in assignment left-hand side.',
|
||||
notNeedInEqualTest: 'Remove unnecessary non-null assertion (!) in equality test.',
|
||||
notNeedInOperator: 'Remove possibly unnecessary non-null assertion (!) in the left operand of the `{{operator}}` operator.',
|
||||
wrapUpLeft: 'Wrap the left-hand side in parentheses to avoid confusion with "{{operator}}" operator.',
|
||||
},
|
||||
schema: [],
|
||||
},
|
||||
defaultOptions: [],
|
||||
create(context) {
|
||||
function confusingOperatorToMessageData(operator) {
|
||||
switch (operator) {
|
||||
case '=':
|
||||
return {
|
||||
messageId: 'confusingAssign',
|
||||
};
|
||||
case '==':
|
||||
case '===':
|
||||
return {
|
||||
messageId: 'confusingEqual',
|
||||
};
|
||||
case 'in':
|
||||
case 'instanceof':
|
||||
return {
|
||||
messageId: 'confusingOperator',
|
||||
data: { operator },
|
||||
};
|
||||
// istanbul ignore next
|
||||
default:
|
||||
operator;
|
||||
throw new Error(`Unexpected operator ${operator}`);
|
||||
}
|
||||
}
|
||||
return {
|
||||
'BinaryExpression, AssignmentExpression'(node) {
|
||||
const operator = node.operator;
|
||||
if (isConfusingOperator(operator)) {
|
||||
// Look for a non-null assertion as the last token on the left hand side.
|
||||
// That way, we catch things like `1 + two! === 3`, even though the left
|
||||
// hand side isn't a non-null assertion AST node.
|
||||
const leftHandFinalToken = context.sourceCode.getLastToken(node.left);
|
||||
const tokenAfterLeft = context.sourceCode.getTokenAfter(node.left);
|
||||
if (leftHandFinalToken?.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
|
||||
leftHandFinalToken.value === '!' &&
|
||||
tokenAfterLeft?.value !== ')') {
|
||||
if (node.left.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
|
||||
let suggestions;
|
||||
switch (operator) {
|
||||
case '=':
|
||||
suggestions = [
|
||||
{
|
||||
messageId: 'notNeedInAssign',
|
||||
fix: (fixer) => fixer.remove(leftHandFinalToken),
|
||||
},
|
||||
];
|
||||
break;
|
||||
case '==':
|
||||
case '===':
|
||||
suggestions = [
|
||||
{
|
||||
messageId: 'notNeedInEqualTest',
|
||||
fix: (fixer) => fixer.remove(leftHandFinalToken),
|
||||
},
|
||||
];
|
||||
break;
|
||||
case 'in':
|
||||
case 'instanceof':
|
||||
suggestions = [
|
||||
{
|
||||
messageId: 'notNeedInOperator',
|
||||
data: { operator },
|
||||
fix: (fixer) => fixer.remove(leftHandFinalToken),
|
||||
},
|
||||
{
|
||||
messageId: 'wrapUpLeft',
|
||||
data: { operator },
|
||||
fix: wrapUpLeftFixer(node),
|
||||
},
|
||||
];
|
||||
break;
|
||||
// istanbul ignore next
|
||||
default:
|
||||
operator;
|
||||
return;
|
||||
}
|
||||
context.report({
|
||||
node,
|
||||
...confusingOperatorToMessageData(operator),
|
||||
suggest: suggestions,
|
||||
});
|
||||
}
|
||||
else {
|
||||
context.report({
|
||||
node,
|
||||
...confusingOperatorToMessageData(operator),
|
||||
suggest: [
|
||||
{
|
||||
messageId: 'wrapUpLeft',
|
||||
data: { operator },
|
||||
fix: wrapUpLeftFixer(node),
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
});
|
||||
function wrapUpLeftFixer(node) {
|
||||
return (fixer) => [
|
||||
fixer.insertTextBefore(node.left, '('),
|
||||
fixer.insertTextAfter(node.left, ')'),
|
||||
];
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
import * as core from "../core/index.cjs";
|
||||
import { type ZodError } from "./errors.cjs";
|
||||
export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
|
||||
export type ZodSafeParseSuccess<T> = {
|
||||
success: true;
|
||||
data: T;
|
||||
error?: never;
|
||||
};
|
||||
export type ZodSafeParseError<T> = {
|
||||
success: false;
|
||||
data?: never;
|
||||
error: ZodError<T>;
|
||||
};
|
||||
export declare const parse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
|
||||
callee?: core.util.AnyFunc;
|
||||
Err?: core.$ZodErrorClass;
|
||||
}) => core.output<T>;
|
||||
export declare const parseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
|
||||
callee?: core.util.AnyFunc;
|
||||
Err?: core.$ZodErrorClass;
|
||||
}) => Promise<core.output<T>>;
|
||||
export declare const safeParse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
|
||||
export declare const safeParseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;
|
||||
export declare const encode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.input<T>;
|
||||
export declare const decode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.output<T>;
|
||||
export declare const encodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.input<T>>;
|
||||
export declare const decodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.output<T>>;
|
||||
export declare const safeEncode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.input<T>>;
|
||||
export declare const safeDecode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
|
||||
export declare const safeEncodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.input<T>>>;
|
||||
export declare const safeDecodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;
|
||||
@@ -0,0 +1,13 @@
|
||||
"use strict";
|
||||
// THIS CODE WAS AUTOMATICALLY GENERATED
|
||||
// DO NOT EDIT THIS CODE BY HAND
|
||||
// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
|
||||
// npx nx generate-lib repo
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.es2020_number = void 0;
|
||||
const base_config_1 = require("./base-config");
|
||||
const es2020_intl_1 = require("./es2020.intl");
|
||||
exports.es2020_number = {
|
||||
libs: [es2020_intl_1.es2020_intl],
|
||||
variables: [['Number', base_config_1.TYPE]],
|
||||
};
|
||||
@@ -0,0 +1,39 @@
|
||||
{{## def.checkMissingProperty:_properties:
|
||||
{{~ _properties:$propertyKey:$i }}
|
||||
{{?$i}} || {{?}}
|
||||
{{
|
||||
var $prop = it.util.getProperty($propertyKey)
|
||||
, $useData = $data + $prop;
|
||||
}}
|
||||
( ({{# def.noPropertyInData }}) && (missing{{=$lvl}} = {{= it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop) }}) )
|
||||
{{~}}
|
||||
#}}
|
||||
|
||||
|
||||
{{## def.errorMissingProperty:_error:
|
||||
{{
|
||||
var $propertyPath = 'missing' + $lvl
|
||||
, $missingProperty = '\' + ' + $propertyPath + ' + \'';
|
||||
if (it.opts._errorDataPathProperty) {
|
||||
it.errorPath = it.opts.jsonPointers
|
||||
? it.util.getPathExpr($currentErrorPath, $propertyPath, true)
|
||||
: $currentErrorPath + ' + ' + $propertyPath;
|
||||
}
|
||||
}}
|
||||
{{# def.error:_error }}
|
||||
#}}
|
||||
|
||||
|
||||
{{## def.allErrorsMissingProperty:_error:
|
||||
{{
|
||||
var $prop = it.util.getProperty($propertyKey)
|
||||
, $missingProperty = it.util.escapeQuotes($propertyKey)
|
||||
, $useData = $data + $prop;
|
||||
if (it.opts._errorDataPathProperty) {
|
||||
it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);
|
||||
}
|
||||
}}
|
||||
if ({{# def.noPropertyInData }}) {
|
||||
{{# def.addError:_error }}
|
||||
}
|
||||
#}}
|
||||
@@ -0,0 +1,107 @@
|
||||
declare namespace delay {
|
||||
interface ClearablePromise<T> extends Promise<T> {
|
||||
/**
|
||||
Clears the delay and settles the promise.
|
||||
*/
|
||||
clear(): void;
|
||||
}
|
||||
|
||||
/**
|
||||
Minimal subset of `AbortSignal` that delay will use if passed.
|
||||
This avoids a dependency on dom.d.ts.
|
||||
The dom.d.ts `AbortSignal` is compatible with this one.
|
||||
*/
|
||||
interface AbortSignal {
|
||||
readonly aborted: boolean;
|
||||
addEventListener(
|
||||
type: 'abort',
|
||||
listener: () => void,
|
||||
options?: {once?: boolean}
|
||||
): void;
|
||||
removeEventListener(type: 'abort', listener: () => void): void;
|
||||
}
|
||||
|
||||
interface Options {
|
||||
/**
|
||||
An optional AbortSignal to abort the delay.
|
||||
If aborted, the Promise will be rejected with an AbortError.
|
||||
*/
|
||||
signal?: AbortSignal;
|
||||
}
|
||||
}
|
||||
|
||||
type Delay = {
|
||||
/**
|
||||
Create a promise which resolves after the specified `milliseconds`.
|
||||
|
||||
@param milliseconds - Milliseconds to delay the promise.
|
||||
@returns A promise which resolves after the specified `milliseconds`.
|
||||
*/
|
||||
(milliseconds: number, options?: delay.Options): delay.ClearablePromise<void>;
|
||||
|
||||
/**
|
||||
Create a promise which resolves after the specified `milliseconds`.
|
||||
|
||||
@param milliseconds - Milliseconds to delay the promise.
|
||||
@returns A promise which resolves after the specified `milliseconds`.
|
||||
*/
|
||||
<T>(
|
||||
milliseconds: number,
|
||||
options?: delay.Options & {
|
||||
/**
|
||||
Value to resolve in the returned promise.
|
||||
*/
|
||||
value: T;
|
||||
}
|
||||
): delay.ClearablePromise<T>;
|
||||
|
||||
/**
|
||||
Create a promise which resolves after a random amount of milliseconds between `minimum` and `maximum` has passed.
|
||||
|
||||
Useful for tests and web scraping since they can have unpredictable performance. For example, if you have a test that asserts a method should not take longer than a certain amount of time, and then run it on a CI, it could take longer. So with `.range()`, you could give it a threshold instead.
|
||||
|
||||
@param minimum - Minimum amount of milliseconds to delay the promise.
|
||||
@param maximum - Maximum amount of milliseconds to delay the promise.
|
||||
@returns A promise which resolves after a random amount of milliseconds between `maximum` and `maximum` has passed.
|
||||
*/
|
||||
range<T>(
|
||||
minimum: number,
|
||||
maximum: number,
|
||||
options?: delay.Options & {
|
||||
/**
|
||||
Value to resolve in the returned promise.
|
||||
*/
|
||||
value: T;
|
||||
}
|
||||
): delay.ClearablePromise<T>;
|
||||
|
||||
// TODO: Allow providing value type after https://github.com/Microsoft/TypeScript/issues/5413 is resolved.
|
||||
/**
|
||||
Create a promise which rejects after the specified `milliseconds`.
|
||||
|
||||
@param milliseconds - Milliseconds to delay the promise.
|
||||
@returns A promise which rejects after the specified `milliseconds`.
|
||||
*/
|
||||
reject(
|
||||
milliseconds: number,
|
||||
options?: delay.Options & {
|
||||
/**
|
||||
Value to reject in the returned promise.
|
||||
*/
|
||||
value?: unknown;
|
||||
}
|
||||
): delay.ClearablePromise<never>;
|
||||
};
|
||||
|
||||
declare const delay: Delay & {
|
||||
// The types are intentionally loose to make it work with both Node.js and browser versions of these methods.
|
||||
createWithTimers(timers: {
|
||||
clearTimeout: (timeoutId: any) => void;
|
||||
setTimeout: (callback: (...args: any[]) => void, milliseconds: number, ...args: any[]) => unknown;
|
||||
}): Delay;
|
||||
|
||||
// TODO: Remove this for the next major release.
|
||||
default: typeof delay;
|
||||
};
|
||||
|
||||
export = delay;
|
||||
@@ -0,0 +1,350 @@
|
||||
'use strict'
|
||||
|
||||
const debug = require('../internal/debug')
|
||||
const { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')
|
||||
const { safeRe: re, t } = require('../internal/re')
|
||||
|
||||
const parseOptions = require('../internal/parse-options')
|
||||
const { compareIdentifiers } = require('../internal/identifiers')
|
||||
|
||||
const isPrereleaseIdentifier = (prerelease, identifier) => {
|
||||
const identifiers = identifier.split('.')
|
||||
if (identifiers.length > prerelease.length) {
|
||||
return false
|
||||
}
|
||||
|
||||
for (let i = 0; i < identifiers.length; i++) {
|
||||
if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
class SemVer {
|
||||
constructor (version, options) {
|
||||
options = parseOptions(options)
|
||||
|
||||
if (version instanceof SemVer) {
|
||||
if (version.loose === !!options.loose &&
|
||||
version.includePrerelease === !!options.includePrerelease) {
|
||||
return version
|
||||
} else {
|
||||
version = version.version
|
||||
}
|
||||
} else if (typeof version !== 'string') {
|
||||
throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
|
||||
}
|
||||
|
||||
if (version.length > MAX_LENGTH) {
|
||||
throw new TypeError(
|
||||
`version is longer than ${MAX_LENGTH} characters`
|
||||
)
|
||||
}
|
||||
|
||||
debug('SemVer', version, options)
|
||||
this.options = options
|
||||
this.loose = !!options.loose
|
||||
// this isn't actually relevant for versions, but keep it so that we
|
||||
// don't run into trouble passing this.options around.
|
||||
this.includePrerelease = !!options.includePrerelease
|
||||
|
||||
const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
|
||||
|
||||
if (!m) {
|
||||
throw new TypeError(`Invalid Version: ${version}`)
|
||||
}
|
||||
|
||||
this.raw = version
|
||||
|
||||
// these are actually numbers
|
||||
this.major = +m[1]
|
||||
this.minor = +m[2]
|
||||
this.patch = +m[3]
|
||||
|
||||
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
|
||||
throw new TypeError('Invalid major version')
|
||||
}
|
||||
|
||||
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
|
||||
throw new TypeError('Invalid minor version')
|
||||
}
|
||||
|
||||
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
|
||||
throw new TypeError('Invalid patch version')
|
||||
}
|
||||
|
||||
// numberify any prerelease numeric ids
|
||||
if (!m[4]) {
|
||||
this.prerelease = []
|
||||
} else {
|
||||
this.prerelease = m[4].split('.').map((id) => {
|
||||
if (/^[0-9]+$/.test(id)) {
|
||||
const num = +id
|
||||
if (num >= 0 && num < MAX_SAFE_INTEGER) {
|
||||
return num
|
||||
}
|
||||
}
|
||||
return id
|
||||
})
|
||||
}
|
||||
|
||||
this.build = m[5] ? m[5].split('.') : []
|
||||
this.format()
|
||||
}
|
||||
|
||||
format () {
|
||||
this.version = `${this.major}.${this.minor}.${this.patch}`
|
||||
if (this.prerelease.length) {
|
||||
this.version += `-${this.prerelease.join('.')}`
|
||||
}
|
||||
return this.version
|
||||
}
|
||||
|
||||
toString () {
|
||||
return this.version
|
||||
}
|
||||
|
||||
compare (other) {
|
||||
debug('SemVer.compare', this.version, this.options, other)
|
||||
if (!(other instanceof SemVer)) {
|
||||
if (typeof other === 'string' && other === this.version) {
|
||||
return 0
|
||||
}
|
||||
other = new SemVer(other, this.options)
|
||||
}
|
||||
|
||||
if (other.version === this.version) {
|
||||
return 0
|
||||
}
|
||||
|
||||
return this.compareMain(other) || this.comparePre(other)
|
||||
}
|
||||
|
||||
compareMain (other) {
|
||||
if (!(other instanceof SemVer)) {
|
||||
other = new SemVer(other, this.options)
|
||||
}
|
||||
|
||||
if (this.major < other.major) {
|
||||
return -1
|
||||
}
|
||||
if (this.major > other.major) {
|
||||
return 1
|
||||
}
|
||||
if (this.minor < other.minor) {
|
||||
return -1
|
||||
}
|
||||
if (this.minor > other.minor) {
|
||||
return 1
|
||||
}
|
||||
if (this.patch < other.patch) {
|
||||
return -1
|
||||
}
|
||||
if (this.patch > other.patch) {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
comparePre (other) {
|
||||
if (!(other instanceof SemVer)) {
|
||||
other = new SemVer(other, this.options)
|
||||
}
|
||||
|
||||
// NOT having a prerelease is > having one
|
||||
if (this.prerelease.length && !other.prerelease.length) {
|
||||
return -1
|
||||
} else if (!this.prerelease.length && other.prerelease.length) {
|
||||
return 1
|
||||
} else if (!this.prerelease.length && !other.prerelease.length) {
|
||||
return 0
|
||||
}
|
||||
|
||||
let i = 0
|
||||
do {
|
||||
const a = this.prerelease[i]
|
||||
const b = other.prerelease[i]
|
||||
debug('prerelease compare', i, a, b)
|
||||
if (a === undefined && b === undefined) {
|
||||
return 0
|
||||
} else if (b === undefined) {
|
||||
return 1
|
||||
} else if (a === undefined) {
|
||||
return -1
|
||||
} else if (a === b) {
|
||||
continue
|
||||
} else {
|
||||
return compareIdentifiers(a, b)
|
||||
}
|
||||
} while (++i)
|
||||
}
|
||||
|
||||
compareBuild (other) {
|
||||
if (!(other instanceof SemVer)) {
|
||||
other = new SemVer(other, this.options)
|
||||
}
|
||||
|
||||
let i = 0
|
||||
do {
|
||||
const a = this.build[i]
|
||||
const b = other.build[i]
|
||||
debug('build compare', i, a, b)
|
||||
if (a === undefined && b === undefined) {
|
||||
return 0
|
||||
} else if (b === undefined) {
|
||||
return 1
|
||||
} else if (a === undefined) {
|
||||
return -1
|
||||
} else if (a === b) {
|
||||
continue
|
||||
} else {
|
||||
return compareIdentifiers(a, b)
|
||||
}
|
||||
} while (++i)
|
||||
}
|
||||
|
||||
// preminor will bump the version up to the next minor release, and immediately
|
||||
// down to pre-release. premajor and prepatch work the same way.
|
||||
inc (release, identifier, identifierBase) {
|
||||
if (release.startsWith('pre')) {
|
||||
if (!identifier && identifierBase === false) {
|
||||
throw new Error('invalid increment argument: identifier is empty')
|
||||
}
|
||||
// Avoid an invalid semver results
|
||||
if (identifier) {
|
||||
const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE])
|
||||
if (!match || match[1] !== identifier) {
|
||||
throw new Error(`invalid identifier: ${identifier}`)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
switch (release) {
|
||||
case 'premajor':
|
||||
this.prerelease.length = 0
|
||||
this.patch = 0
|
||||
this.minor = 0
|
||||
this.major++
|
||||
this.inc('pre', identifier, identifierBase)
|
||||
break
|
||||
case 'preminor':
|
||||
this.prerelease.length = 0
|
||||
this.patch = 0
|
||||
this.minor++
|
||||
this.inc('pre', identifier, identifierBase)
|
||||
break
|
||||
case 'prepatch':
|
||||
// If this is already a prerelease, it will bump to the next version
|
||||
// drop any prereleases that might already exist, since they are not
|
||||
// relevant at this point.
|
||||
this.prerelease.length = 0
|
||||
this.inc('patch', identifier, identifierBase)
|
||||
this.inc('pre', identifier, identifierBase)
|
||||
break
|
||||
// If the input is a non-prerelease version, this acts the same as
|
||||
// prepatch.
|
||||
case 'prerelease':
|
||||
if (this.prerelease.length === 0) {
|
||||
this.inc('patch', identifier, identifierBase)
|
||||
}
|
||||
this.inc('pre', identifier, identifierBase)
|
||||
break
|
||||
case 'release':
|
||||
if (this.prerelease.length === 0) {
|
||||
throw new Error(`version ${this.raw} is not a prerelease`)
|
||||
}
|
||||
this.prerelease.length = 0
|
||||
break
|
||||
|
||||
case 'major':
|
||||
// If this is a pre-major version, bump up to the same major version.
|
||||
// Otherwise increment major.
|
||||
// 1.0.0-5 bumps to 1.0.0
|
||||
// 1.1.0 bumps to 2.0.0
|
||||
if (
|
||||
this.minor !== 0 ||
|
||||
this.patch !== 0 ||
|
||||
this.prerelease.length === 0
|
||||
) {
|
||||
this.major++
|
||||
}
|
||||
this.minor = 0
|
||||
this.patch = 0
|
||||
this.prerelease = []
|
||||
break
|
||||
case 'minor':
|
||||
// If this is a pre-minor version, bump up to the same minor version.
|
||||
// Otherwise increment minor.
|
||||
// 1.2.0-5 bumps to 1.2.0
|
||||
// 1.2.1 bumps to 1.3.0
|
||||
if (this.patch !== 0 || this.prerelease.length === 0) {
|
||||
this.minor++
|
||||
}
|
||||
this.patch = 0
|
||||
this.prerelease = []
|
||||
break
|
||||
case 'patch':
|
||||
// If this is not a pre-release version, it will increment the patch.
|
||||
// If it is a pre-release it will bump up to the same patch version.
|
||||
// 1.2.0-5 patches to 1.2.0
|
||||
// 1.2.0 patches to 1.2.1
|
||||
if (this.prerelease.length === 0) {
|
||||
this.patch++
|
||||
}
|
||||
this.prerelease = []
|
||||
break
|
||||
// This probably shouldn't be used publicly.
|
||||
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
|
||||
case 'pre': {
|
||||
const base = Number(identifierBase) ? 1 : 0
|
||||
|
||||
if (this.prerelease.length === 0) {
|
||||
this.prerelease = [base]
|
||||
} else {
|
||||
let i = this.prerelease.length
|
||||
while (--i >= 0) {
|
||||
if (typeof this.prerelease[i] === 'number') {
|
||||
this.prerelease[i]++
|
||||
i = -2
|
||||
}
|
||||
}
|
||||
if (i === -1) {
|
||||
// didn't increment anything
|
||||
if (identifier === this.prerelease.join('.') && identifierBase === false) {
|
||||
throw new Error('invalid increment argument: identifier already exists')
|
||||
}
|
||||
this.prerelease.push(base)
|
||||
}
|
||||
}
|
||||
if (identifier) {
|
||||
// 1.2.0-beta.1 bumps to 1.2.0-beta.2,
|
||||
// 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
|
||||
let prerelease = [identifier, base]
|
||||
if (identifierBase === false) {
|
||||
prerelease = [identifier]
|
||||
}
|
||||
if (isPrereleaseIdentifier(this.prerelease, identifier)) {
|
||||
const prereleaseBase = this.prerelease[identifier.split('.').length]
|
||||
if (isNaN(prereleaseBase)) {
|
||||
this.prerelease = prerelease
|
||||
}
|
||||
} else {
|
||||
this.prerelease = prerelease
|
||||
}
|
||||
}
|
||||
break
|
||||
}
|
||||
default:
|
||||
throw new Error(`invalid increment argument: ${release}`)
|
||||
}
|
||||
this.raw = this.format()
|
||||
if (this.build.length) {
|
||||
this.raw += `+${this.build.join('.')}`
|
||||
}
|
||||
return this
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = SemVer
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"vlq.d.ts","sourceRoot":"","sources":["../src/vlq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE5D,eAAO,MAAM,KAAK,QAAoB,CAAC;AACvC,eAAO,MAAM,SAAS,QAAoB,CAAC;AAY3C,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoB5E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAY1F;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,WAG3D"}
|
||||
@@ -0,0 +1,8 @@
|
||||
var _typeof = require("./typeof.js")["default"];
|
||||
var assertThisInitialized = require("./assertThisInitialized.js");
|
||||
function _possibleConstructorReturn(t, e) {
|
||||
if (e && ("object" == _typeof(e) || "function" == typeof e)) return e;
|
||||
if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
|
||||
return assertThisInitialized(t);
|
||||
}
|
||||
module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Audited & minimal JS implementation of hash functions, MACs and KDFs. Check out individual modules.
|
||||
* @module
|
||||
* @example
|
||||
```js
|
||||
import {
|
||||
sha256, sha384, sha512, sha224, sha512_224, sha512_256
|
||||
} from '@noble/hashes/sha2';
|
||||
import {
|
||||
sha3_224, sha3_256, sha3_384, sha3_512,
|
||||
keccak_224, keccak_256, keccak_384, keccak_512,
|
||||
shake128, shake256
|
||||
} from '@noble/hashes/sha3';
|
||||
import {
|
||||
cshake128, cshake256,
|
||||
turboshake128, turboshake256,
|
||||
kmac128, kmac256,
|
||||
tuplehash256, parallelhash256,
|
||||
k12, m14, keccakprg
|
||||
} from '@noble/hashes/sha3-addons';
|
||||
import { blake3 } from '@noble/hashes/blake3';
|
||||
import { blake2b, blake2s } from '@noble/hashes/blake2';
|
||||
import { hmac } from '@noble/hashes/hmac';
|
||||
import { hkdf } from '@noble/hashes/hkdf';
|
||||
import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2';
|
||||
import { scrypt, scryptAsync } from '@noble/hashes/scrypt';
|
||||
import { md5, ripemd160, sha1 } from '@noble/hashes/legacy';
|
||||
import * as utils from '@noble/hashes/utils';
|
||||
```
|
||||
*/
|
||||
throw new Error('root module cannot be imported: import submodules instead. Check out README');
|
||||
export {};
|
||||
//# sourceMappingURL=index.js.map
|
||||
@@ -0,0 +1,41 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getParserServices = getParserServices;
|
||||
const parserSeemsToBeTSESLint_1 = require("./parserSeemsToBeTSESLint");
|
||||
const ERROR_MESSAGE_REQUIRES_PARSER_SERVICES = "You have used a rule which requires type information, but don't have parserOptions set to generate type information for this file. See https://tseslint.com/typed-linting for enabling linting with type information.";
|
||||
const ERROR_MESSAGE_UNKNOWN_PARSER = 'Note: detected a parser other than @typescript-eslint/parser. Make sure the parser is configured to forward "parserOptions.project" to @typescript-eslint/parser.';
|
||||
function getParserServices(context, allowWithoutFullTypeInformation = false) {
|
||||
const parser =
|
||||
// eslint-disable-next-line @typescript-eslint/no-deprecated -- For compatibility with ESLint 8
|
||||
context.parserPath || context.languageOptions.parser?.meta?.name;
|
||||
// This check is unnecessary if the user is using the latest version of our parser.
|
||||
//
|
||||
// However the world isn't perfect:
|
||||
// - Users often use old parser versions.
|
||||
// Old versions of the parser would not return any parserServices unless parserOptions.project was set.
|
||||
// - Users sometimes use parsers that aren't @typescript-eslint/parser
|
||||
// Other parsers won't return the parser services we expect (if they return any at all).
|
||||
//
|
||||
// This check allows us to handle bad user setups whilst providing a nice user-facing
|
||||
// error message explaining the problem.
|
||||
if (context.sourceCode.parserServices?.esTreeNodeToTSNodeMap == null ||
|
||||
context.sourceCode.parserServices.tsNodeToESTreeNodeMap == null) {
|
||||
throwError(parser);
|
||||
}
|
||||
// if a rule requires full type information, then hard fail if it doesn't exist
|
||||
// this forces the user to supply parserOptions.project
|
||||
if (context.sourceCode.parserServices.program == null &&
|
||||
!allowWithoutFullTypeInformation) {
|
||||
throwError(parser);
|
||||
}
|
||||
return context.sourceCode.parserServices;
|
||||
}
|
||||
/* eslint-enable @typescript-eslint/unified-signatures */
|
||||
function throwError(parser) {
|
||||
const messages = [
|
||||
ERROR_MESSAGE_REQUIRES_PARSER_SERVICES,
|
||||
`Parser: ${parser || '(unknown)'}`,
|
||||
!(0, parserSeemsToBeTSESLint_1.parserSeemsToBeTSESLint)(parser) && ERROR_MESSAGE_UNKNOWN_PARSER,
|
||||
].filter(Boolean);
|
||||
throw new Error(messages.join('\n'));
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
function _defaults(e, r) {
|
||||
for (var t = Object.getOwnPropertyNames(r), o = 0; o < t.length; o++) {
|
||||
var n = t[o],
|
||||
a = Object.getOwnPropertyDescriptor(r, n);
|
||||
a && a.configurable && void 0 === e[n] && Object.defineProperty(e, n, a);
|
||||
}
|
||||
return e;
|
||||
}
|
||||
module.exports = _defaults, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,68 @@
|
||||
//#region src/get-log-filter.ts
|
||||
/**
|
||||
* A helper function to generate log filters using the same syntax as the CLI.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* import { defineConfig } from 'rolldown';
|
||||
* import { getLogFilter } from 'rolldown/getLogFilter';
|
||||
*
|
||||
* const logFilter = getLogFilter(['code:FOO', 'code:BAR']);
|
||||
*
|
||||
* export default defineConfig({
|
||||
* input: 'main.js',
|
||||
* onLog(level, log, handler) {
|
||||
* if (logFilter(log)) {
|
||||
* handler(level, log);
|
||||
* }
|
||||
* }
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* @category Config
|
||||
*/
|
||||
const getLogFilter = (filters) => {
|
||||
if (filters.length === 0) return () => true;
|
||||
const normalizedFilters = filters.map((filter) => filter.split("&").map((subFilter) => {
|
||||
const inverted = subFilter.startsWith("!");
|
||||
if (inverted) subFilter = subFilter.slice(1);
|
||||
const [key, ...value] = subFilter.split(":");
|
||||
return {
|
||||
inverted,
|
||||
key: key.split("."),
|
||||
parts: value.join(":").split("*")
|
||||
};
|
||||
}));
|
||||
return (log) => {
|
||||
nextIntersectedFilter: for (const intersectedFilters of normalizedFilters) {
|
||||
for (const { inverted, key, parts } of intersectedFilters) {
|
||||
const isFilterSatisfied = testFilter(log, key, parts);
|
||||
if (inverted ? isFilterSatisfied : !isFilterSatisfied) continue nextIntersectedFilter;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
};
|
||||
const testFilter = (log, key, parts) => {
|
||||
let rawValue = log;
|
||||
for (let index = 0; index < key.length; index++) {
|
||||
if (!rawValue) return false;
|
||||
const part = key[index];
|
||||
if (!(part in rawValue)) return false;
|
||||
rawValue = rawValue[part];
|
||||
}
|
||||
let value = typeof rawValue === "object" ? JSON.stringify(rawValue) : String(rawValue);
|
||||
if (parts.length === 1) return value === parts[0];
|
||||
if (!value.startsWith(parts[0])) return false;
|
||||
const lastPartIndex = parts.length - 1;
|
||||
for (let index = 1; index < lastPartIndex; index++) {
|
||||
const part = parts[index];
|
||||
const position = value.indexOf(part);
|
||||
if (position === -1) return false;
|
||||
value = value.slice(position + part.length);
|
||||
}
|
||||
return value.endsWith(parts[lastPartIndex]);
|
||||
};
|
||||
//#endregion
|
||||
export { getLogFilter as default };
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"i16.d.ts","sourceRoot":"","sources":["../../src/i16.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}
|
||||
Reference in New Issue
Block a user