🎉 initiate project *astro_rewrite*

node_modules/@emmetio/abbreviation/dist/convert.d.ts

@@ -0,0 +1,8 @@
+import { TokenGroup } from './parser/index.js';
+import { Abbreviation, ParserOptions } from './types.js';
+/**
+ * Converts given token-based abbreviation into simplified and unrolled node-based
+ * abbreviation
+ */
+export default function convert(abbr: TokenGroup, options?: ParserOptions): Abbreviation;
+export declare function isGroup(node: any): node is TokenGroup;

node_modules/@emmetio/abbreviation/dist/index.d.ts

@@ -0,0 +1,12 @@
+import parse, { type TokenGroup } from './parser/index.js';
+import tokenize, { getToken, type AllTokens } from './tokenizer/index.js';
+import convert from './convert.js';
+import type { ParserOptions } from './types.js';
+export { parse, tokenize, getToken, convert };
+export * from './tokenizer/tokens.js';
+export * from './types.js';
+export type MarkupAbbreviation = TokenGroup;
+/**
+ * Parses given abbreviation into node tree
+ */
+export default function parseAbbreviation(abbr: string | AllTokens[], options?: ParserOptions): import("./types.js").Abbreviation;

node_modules/@emmetio/abbreviation/dist/parser/TokenScanner.d.ts

@@ -0,0 +1,17 @@
+import { AllTokens } from '../tokenizer/index.js';
+export interface TokenScanner {
+    tokens: AllTokens[];
+    start: number;
+    pos: number;
+    size: number;
+}
+type TestFn = (token?: AllTokens) => boolean;
+export default function tokenScanner(tokens: AllTokens[]): TokenScanner;
+export declare function peek(scanner: TokenScanner): AllTokens | undefined;
+export declare function next(scanner: TokenScanner): AllTokens | undefined;
+export declare function slice(scanner: TokenScanner, from?: number, to?: number): AllTokens[];
+export declare function readable(scanner: TokenScanner): boolean;
+export declare function consume(scanner: TokenScanner, test: TestFn): boolean;
+export declare function error(scanner: TokenScanner, message: string, token?: AllTokens | undefined): Error;
+export declare function consumeWhile(scanner: TokenScanner, test: TestFn): boolean;
+export {};

node_modules/@emmetio/abbreviation/dist/parser/index.d.ts

@@ -0,0 +1,31 @@
+import type { NameToken, ValueToken, Repeater, AllTokens, BracketType, Bracket, Operator, OperatorType, Quote } from '../tokenizer/index.js';
+import type { ParserOptions } from '../types.js';
+export type TokenStatement = TokenElement | TokenGroup;
+export interface TokenAttribute {
+    name?: ValueToken[];
+    value?: ValueToken[];
+    expression?: boolean;
+    /**
+     * Indicates that current attribute was repeated multiple times in a row.
+     * Used to alter output of multiple shorthand attributes like `..` (double class)
+     */
+    multiple?: boolean;
+}
+export interface TokenElement {
+    type: 'TokenElement';
+    name?: NameToken[];
+    attributes?: TokenAttribute[];
+    value?: ValueToken[];
+    repeat?: Repeater;
+    selfClose: boolean;
+    elements: TokenStatement[];
+}
+export interface TokenGroup {
+    type: 'TokenGroup';
+    elements: TokenStatement[];
+    repeat?: Repeater;
+}
+export default function abbreviation(abbr: AllTokens[], options?: ParserOptions): TokenGroup;
+export declare function isBracket(token: AllTokens | undefined, context?: BracketType, isOpen?: boolean): token is Bracket;
+export declare function isOperator(token: AllTokens | undefined, type?: OperatorType): token is Operator;
+export declare function isQuote(token: AllTokens | undefined, isSingle?: boolean): token is Quote;

node_modules/@emmetio/abbreviation/dist/stringify.d.ts

@@ -0,0 +1,6 @@
+import { ValueToken } from './tokenizer/tokens.js';
+import { ConvertState } from './types.js';
+/**
+ * Converts given value token to string
+ */
+export default function stringify(token: ValueToken, state: ConvertState): string;

node_modules/@emmetio/abbreviation/dist/tokenizer/index.d.ts

@@ -0,0 +1,13 @@
+import Scanner from '@emmetio/scanner';
+import type { BracketType, AllTokens } from './tokens.js';
+export * from './tokens.js';
+type Context = {
+    [ctx in BracketType]: number;
+} & {
+    quote: number;
+};
+export default function tokenize(source: string): AllTokens[];
+/**
+ * Returns next token from given scanner, if possible
+ */
+export declare function getToken(scanner: Scanner, ctx: Context): AllTokens | undefined;

node_modules/@emmetio/abbreviation/dist/tokenizer/tokens.d.ts

@@ -0,0 +1,63 @@
+export type OperatorType = 'child' | 'sibling' | 'climb' | 'class' | 'id' | 'close' | 'equal';
+export type BracketType = 'group' | 'attribute' | 'expression';
+export type AllTokens = Bracket | Field | Literal | Operator | Quote | Repeater | RepeaterNumber | RepeaterPlaceholder | WhiteSpace;
+export type NameToken = Literal | RepeaterNumber;
+export type ValueToken = Literal | Quote | Bracket | Field | RepeaterPlaceholder | RepeaterNumber;
+export interface Token {
+    type: string;
+    /** Location of token start in source */
+    start?: number;
+    /** Location of token end in source */
+    end?: number;
+}
+export interface Repeater extends Token {
+    type: 'Repeater';
+    /** How many times context element should be repeated */
+    count: number;
+    /** Position of context element in its repeating sequence */
+    value: number;
+    /** Repeater is implicit, e.g. repeated by the amount of text lines selected by user */
+    implicit: boolean;
+}
+export interface RepeaterNumber extends Token {
+    type: 'RepeaterNumber';
+    /** Size of repeater content, e.g. the amount consequent numbering characters */
+    size: number;
+    /** Should output numbering in reverse order? */
+    reverse: boolean;
+    /** Base value to start numbering from */
+    base: number;
+    /** Parent offset from which numbering should be used */
+    parent: number;
+}
+export interface RepeaterPlaceholder extends Token {
+    type: 'RepeaterPlaceholder';
+    /** Value to insert instead of placeholder */
+    value?: string;
+}
+export interface Field extends Token {
+    type: 'Field';
+    index?: number;
+    name: string;
+}
+export interface Operator extends Token {
+    type: 'Operator';
+    operator: OperatorType;
+}
+export interface Bracket extends Token {
+    type: 'Bracket';
+    open: boolean;
+    context: BracketType;
+}
+export interface Quote extends Token {
+    type: 'Quote';
+    single: boolean;
+}
+export interface Literal extends Token {
+    type: 'Literal';
+    value: string;
+}
+export interface WhiteSpace extends Token {
+    type: 'WhiteSpace';
+    value: string;
+}

node_modules/@emmetio/abbreviation/dist/tokenizer/utils.d.ts

@@ -0,0 +1,53 @@
+import type Scanner from '@emmetio/scanner';
+export declare const enum Chars {
+    /** `{` character */
+    CurlyBracketOpen = 123,
+    /** `}` character */
+    CurlyBracketClose = 125,
+    /** `\\` character */
+    Escape = 92,
+    /** `=` character */
+    Equals = 61,
+    /** `[` character */
+    SquareBracketOpen = 91,
+    /** `]` character */
+    SquareBracketClose = 93,
+    /** `*` character */
+    Asterisk = 42,
+    /** `#` character */
+    Hash = 35,
+    /** `$` character */
+    Dollar = 36,
+    /** `-` character */
+    Dash = 45,
+    /** `.` character */
+    Dot = 46,
+    /** `/` character */
+    Slash = 47,
+    /** `:` character */
+    Colon = 58,
+    /** `!` character */
+    Excl = 33,
+    /** `@` character */
+    At = 64,
+    /** `_` character */
+    Underscore = 95,
+    /** `(` character */
+    RoundBracketOpen = 40,
+    /** `)` character */
+    RoundBracketClose = 41,
+    /** `+` character */
+    Sibling = 43,
+    /** `>` character */
+    Child = 62,
+    /** `^` character */
+    Climb = 94,
+    /** `'` character */
+    SingleQuote = 39,
+    /** `""` character */
+    DoubleQuote = 34
+}
+/**
+ * If consumes escape character, sets current stream range to escaped value
+ */
+export declare function escaped(scanner: Scanner): boolean;

node_modules/@emmetio/abbreviation/dist/types.d.ts

@@ -0,0 +1,56 @@
+import { Field, Repeater } from './tokenizer/index.js';
+export interface ParserOptions {
+    /** Text strings to insert into implicitly repeated elements */
+    text?: string | string[];
+    /** Variable values for `${var}` tokens */
+    variables?: {
+        [name: string]: string;
+    };
+    /** Max amount of repeated elements in abbreviation */
+    maxRepeat?: number;
+    /** Enabled JSX parsing mode */
+    jsx?: boolean;
+    /** Enable inserting text into href attribute of links */
+    href?: boolean;
+}
+export interface ConvertState {
+    inserted: boolean;
+    text?: string | string[];
+    cleanText?: string | string[];
+    repeatGuard: number;
+    /** Context repeaters, e.g. all actual repeaters from parent */
+    repeaters: Repeater[];
+    getText(pos?: number): string;
+    getVariable(name: string): string;
+}
+export type Value = string | Field;
+export type AttributeType = 'raw' | 'singleQuote' | 'doubleQuote' | 'expression';
+export interface Abbreviation {
+    type: 'Abbreviation';
+    children: AbbreviationNode[];
+}
+export interface AbbreviationNode {
+    type: 'AbbreviationNode';
+    name?: string;
+    value?: Value[];
+    repeat?: Repeater;
+    attributes?: AbbreviationAttribute[];
+    children: AbbreviationNode[];
+    /**  Indicates current element is self-closing, e.g. should not contain closing pair */
+    selfClosing?: boolean;
+}
+export interface AbbreviationAttribute {
+    name?: string;
+    value?: Value[];
+    /** Indicates type of value stored in `.value` property */
+    valueType: AttributeType;
+    /** Attribute is boolean (e.g.name equals value) */
+    boolean?: boolean;
+    /** Attribute is implied (e.g.must be outputted only if contains non-null value) */
+    implied?: boolean;
+    /**
+     * Internal property that indicates that given attribute was specified
+     * more than once as a shorthand. E.g. `..` is a multiple `class` attribute
+     */
+    multiple?: boolean;
+}