├── .gitignore
├── .npmrc
├── LICENSE
├── README.md
├── bin
    └── index.js
├── lib
    ├── generate.js
    ├── handler.js
    ├── message.js
    ├── parse.js
    ├── preview
    │   ├── client.html
    │   ├── index.js
    │   └── server.js
    ├── read.js
    ├── render
    │   ├── index.js
    │   ├── screencast.js
    │   └── screenshot.js
    └── static.js
├── package-lock.json
├── package.json
└── screenshot
    └── preview.png


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | .DS_Store
3 | 


--------------------------------------------------------------------------------
/.npmrc:
--------------------------------------------------------------------------------
1 | engine-strict=true
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | (The MIT License)
 2 | 
 3 | Copyright (c) 2024 Yuan Chuan <yuanchuan23@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining
 6 | a copy of this software and associated documentation files (the
 7 | 'Software'), to deal in the Software without restriction, including
 8 | without limitation the rights to use, copy, modify, merge, publish,
 9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # @css-doodle/cli
  2 | 
  3 | Command-line tool for css-doodle to preview and generate images/videos.
  4 | 
  5 | <img src="screenshot/preview.png" width="480px" alt="screenshot" />
  6 | 
  7 | ## Installation
  8 | 
  9 | ```bash
 10 | npm install -g @css-doodle/cli
 11 | ```
 12 | 
 13 | >[!NOTE]
 14 | > After installation, you can use `cssd` or `css-doodle` command in the terminal.
 15 | 
 16 | ## Usage
 17 | 
 18 | ```console
 19 | Usage: cssd [options] [command] [source]
 20 | 
 21 | Arguments:
 22 |   source         css-doodle source file to preview (same as run command)
 23 | 
 24 | Options:
 25 |   -V, --version  output the version number
 26 |   -h, --help     display help for command
 27 | 
 28 | Commands:
 29 |   run            Open a window to preview the css|cssd file
 30 |   render         Generate an image from a css|cssd|html file or a CodePen link
 31 |   generate       Generate code using css-doodle generators
 32 |   config         Display/set configurations
 33 |   use            Shorthand to fetch and use a custom version of css-doodle
 34 |   parse          Print the parsed tokens, help to debug in development
 35 |   upgrade        Upgrade CLI to latest version
 36 | ```
 37 | 
 38 | ## Commands
 39 | 
 40 | ### run
 41 | Open a window to preview the css-doodle source file. The source file can be either `.css` or `.cssd`.
 42 | 
 43 | * `--fullscreen`: Open in fullscreen mode.
 44 | 
 45 | ```bash
 46 | cssd run code.css
 47 | cssd run code.css --fullscreen
 48 | ```
 49 | 
 50 | The `run` can be omitted if you just want to preview.
 51 | 
 52 | ```bash
 53 | cssd somefile.css
 54 | ```
 55 | 
 56 | ### render
 57 | Generate an image/video from the css-doodle source file. The source file can be a `.css`, `.cssd`, `.html` file or CodePen link.
 58 | 
 59 | * `-o, --output <output>`:      Custom output filename of the generated result
 60 | * `-x, --scale <scale>`:        Scale factor of the generated result, defaults to `2` for images, `1` for videos
 61 | * `-s, --selector <selector>`:  CSS selector to target the rendered node, defaults to `css-doodle`
 62 | * `-d, --delay <delay>`:        Delay time before taking screenshot/screencast, e.g, `2s`
 63 | * `-t, --time <time>`:          Record screen for a specific time, e.g, `10s`
 64 | * `-q, --quiet`:                Quiet mode, suppresses non-error output
 65 | * `-w, --window <size>`:        The size of the rendered window, defaults to `1600x1200` for images, `1200x900` for videos
 66 | * `--mp4`:                      Use `mp4` as the generated video format
 67 | 
 68 | 
 69 | ```bash
 70 | cssd render
 71 | cssd render code.css
 72 | cssd render code.css -o result.png
 73 | cssd render code.css -x 4
 74 | cssd render https://codepen.io/yuanchuan/pen/MQEeJo
 75 | ```
 76 | 
 77 | Screen recording:
 78 | 
 79 | ```bash
 80 | cssd render -t 10s
 81 | ```
 82 | 
 83 | By default the generated video is in `webm` format,
 84 | you can transform it automatically into `mp4` by adding `--mp4` option,
 85 | or use an output filename with `.mp4` extension.
 86 | 
 87 | ```bash
 88 | cssd render -t 10s --mp4
 89 | cssd render -o result.mp4
 90 | ```
 91 | 
 92 | ### generate
 93 | 
 94 | Generate code using css-doodle generators.
 95 | 
 96 | * `svg`: Generate SVG code using svg() function.
 97 | * `polygon`: Generate CSS polygon() using shape() function.
 98 | 
 99 | ```bash
100 | cssd generate svg code.css
101 | cssd generate polygon code.css
102 | 
103 | # read from STDIN
104 | cssd generate polygon
105 | ```
106 | 
107 | ### config
108 | 
109 | Display/set the configurations in key/value pairs.
110 | 
111 | * `set <field> <value>`: Set a configuration with key/value pair.
112 | * `get <field>`: Get a configuration value by key.
113 | * `unset <field>`: Unset a configuration field.
114 | * `list`: List all configurations.
115 | 
116 | Recognizable `field` configurations:
117 | 
118 | * `browserPath`: The path to the browser executable.
119 | * `css-doodle`: The path to the css-doodle to use.
120 | 
121 | ```bash
122 | # show all configurations
123 | cssd config list
124 | 
125 | # use a custom browser
126 | cssd config set browserPath /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome
127 | 
128 | # unset
129 | cssd config unset browserPath
130 | 
131 | # get the value
132 | cssd config get browserPath
133 | 
134 | # download and use a custom version of css-doodle
135 | cssd config set css-doodle 0.40.6
136 | ```
137 | 
138 | ### use
139 | Shorthand of `cssd config set css-doodle <version>`.
140 | 
141 | * `<version>`: The version of css-doodle to use. It can be a specific version or `latest`.
142 | 
143 | ```bash
144 | cssd use css-doodle@0.40.6
145 | 
146 | # or just version
147 | cssd use 0.40.6
148 | cssd use latest
149 | ```
150 | 
151 | ### upgrade
152 | Upgrade CLI to latest version.
153 | 
154 | ```bash
155 | cssd upgrade
156 | ```
157 | 


--------------------------------------------------------------------------------
/bin/index.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | 
  3 | import process from 'node:process';
  4 | import { styleText } from 'node:util';
  5 | import { Command } from 'commander';
  6 | import { pkg } from '../lib/static.js';
  7 | import { msgError, msgCommand } from '../lib/message.js';
  8 | 
  9 | import {
 10 |     handleRender,
 11 |     handleParse,
 12 |     handlePreview,
 13 |     handleGenerateSVG,
 14 |     handleGenerateShape,
 15 |     handleSetConfig,
 16 |     handleUnsetConfig,
 17 |     handleDisplayConfig,
 18 |     handleDisplayConfigList,
 19 |     handleUseAction,
 20 |     handleUpgrade,
 21 | } from '../lib/handler.js';
 22 | 
 23 | const program = new Command();
 24 | 
 25 | program
 26 |     .name(pkg.programName)
 27 |     .version(pkg.version)
 28 |     .addHelpCommand(false)
 29 |     .addHelpText('beforeAll', program => {
 30 |         if (!program.command.parent) {
 31 |             return `${pkg.description}. (${pkg.version})\n`;
 32 |         }
 33 |     })
 34 |     .addHelpText('afterAll', program => {
 35 |         if (!program.command.parent) {
 36 |             return `\nLearn more: https://css-doodle.com`;
 37 |         }
 38 |     })
 39 |     .configureHelp({
 40 |         subcommandTerm(cmd) {
 41 |             return cmd.name();
 42 |         },
 43 |         styleTitle(str) {
 44 |             return styleText('bold', str);
 45 |         },
 46 |         styleCommandText(str) {
 47 |             return styleText('bold', str);
 48 |         },
 49 |         styleArgumentText(str) {
 50 |             return styleText('bold', styleText('magenta', str));
 51 |         },
 52 |         styleArgumentTerm(str) {
 53 |             return styleText('bold', styleText('magenta', str));
 54 |         },
 55 |         styleSubcommandText(str) {
 56 |             return styleText('bold', styleText('blue', str));
 57 |         },
 58 |         styleSubcommandTerm(str) {
 59 |             return styleText('bold', styleText('blue', str));
 60 |         },
 61 |         styleOptionTerm(str) {
 62 |             return styleText('bold', styleText('cyan', str));
 63 |         },
 64 |         styleOptionText(str) {
 65 |             return styleText('bold', styleText('cyan', str));
 66 |         },
 67 |     })
 68 |     .configureOutput({
 69 |         outputError(str, write) {
 70 |             write(msgError(String(str).replace(/^error: /, '')));
 71 |         }
 72 |     });
 73 | 
 74 | program
 75 |     .argument('[source]', `css-doodle source file to preview (same as ${msgCommand('run')} command)`)
 76 |     .action(handlePreview);
 77 | 
 78 | 
 79 | program
 80 |     .command('run')
 81 |     .alias('preview')
 82 |     .description('Open a window to preview the css|cssd file')
 83 |     .argument('[source]', 'css-doodle source file to preview')
 84 |     .option('--fullscreen', 'open in fullscreen mode')
 85 |     .action(handlePreview);
 86 | 
 87 | program
 88 |     .command('render')
 89 |     .description('Generate an image from a css|cssd|html file or a CodePen link')
 90 |     .argument('[source]', 'css-doolde source file used to generate the image/video')
 91 |     .option('-o, --output <output>', 'Custom output filename of the generated result')
 92 |     .option('-x, --scale <scale>', 'Scale factor of the generated result, defaults to `2` for images, `1` for videos')
 93 |     .option('-s, --selector <selector>', 'CSS selector to target the rendered node, defaults to `css-doodle`')
 94 |     .option('-d, --delay <delay>', 'Delay time before taking screenshot/screencast, e.g, `2s`')
 95 |     .option('-t, --time <time>', 'Record screen for a specific time, e.g, `10s`')
 96 |     .option('-q, --quiet', 'Quiet mode, suppresses non-error output')
 97 |     .option('-w, --window <size>', 'The size of the rendered window, defaults to `1600x1200` for images, `1200x900` for videos')
 98 |     .option('--mp4', 'Use `mp4` as the generated video format')
 99 |     .action(handleRender);
100 | 
101 | const generate =
102 | program
103 |     .command('generate')
104 |     .description('Generate code using css-doodle generators')
105 |     .action((_, cmd) => cmd.help());
106 | 
107 |     generate
108 |         .command('svg [source]')
109 |         .description('Generate SVG code with svg() function')
110 |         .action(handleGenerateSVG);
111 | 
112 |     generate
113 |         .command('polygon [source]')
114 |         .description('Generate CSS polygon() with shape() function')
115 |         .action(handleGenerateShape);
116 | 
117 | const config =
118 | program
119 |     .command('config')
120 |     .description('Display/set configurations')
121 |     .action((_, cmd) => cmd.help());
122 | 
123 |     config
124 |         .command('set <field> <value>')
125 |         .description('Set a configuration with key/value pair')
126 |         .action(handleSetConfig);
127 | 
128 |     config
129 |         .command('get <field>')
130 |         .description('Get a configuration value by key')
131 |         .action(handleDisplayConfig);
132 | 
133 |     config
134 |         .command('unset <field>')
135 |         .description('Unset a configuration field')
136 |         .action(handleUnsetConfig);
137 | 
138 |     config
139 |         .command('list')
140 |         .description('List all configurations')
141 |         .action(handleDisplayConfigList);
142 | 
143 | program
144 |     .command('use')
145 |     .description('Shorthand to fetch and use a custom version of css-doodle')
146 |     .argument('<version>', 'Custom version of css-doodle to use. E.g. css-doodle@latest')
147 |     .action(handleUseAction);
148 | 
149 | program
150 |     .command('parse')
151 |     .description('Print the parsed tokens, help to debug in development')
152 |     .argument('[source]', 'css-doodle source file to parse')
153 |     .action(handleParse);
154 | 
155 | program
156 |     .command('upgrade')
157 |     .description('Upgrade CLI to latest version')
158 |     .action(handleUpgrade);
159 | 
160 | if (process.argv.length <= 2) {
161 |     program.help();
162 | } else {
163 |     program.parse();
164 | }
165 | 


--------------------------------------------------------------------------------
/lib/generate.js:
--------------------------------------------------------------------------------
 1 | import { svg, shape } from 'css-doodle/generator';
 2 | 
 3 | export function generateSVG(...args) {
 4 |     return svg(...args);
 5 | }
 6 | 
 7 | export function generateShape(...args) {
 8 |     return shape(...args);
 9 | }
10 | 


--------------------------------------------------------------------------------
/lib/handler.js:
--------------------------------------------------------------------------------
  1 | import fs from 'node:fs/promises';
  2 | import path from 'node:path';
  3 | import { Buffer } from 'node:buffer';
  4 | import process from 'node:process';
  5 | import { execSync } from 'node:child_process';
  6 | 
  7 | import { config, configPath, configDownloadPath } from './static.js';
  8 | import { generateSVG, generateShape } from './generate.js';
  9 | import { parse } from './parse.js';
 10 | import { preview } from './preview/index.js';
 11 | import { render } from './render/index.js';
 12 | import { read } from './read.js';
 13 | import { msgError, msgTip, msgSuccess } from './message.js';
 14 | 
 15 | export async function handleRender(source, options) {
 16 |     const { content, error, type } = await read(source);
 17 |     if (error) {
 18 |         console.error(msgError(error.message));
 19 |         process.exit(1);
 20 |     }
 21 |     options.type = type;
 22 |     options.delay = readTime(options.delay, { max: 30 * 1000 }) || 0;
 23 |     options.time = readTime(options.time, { max: 60 * 1000 }) || 0;
 24 |     options.selector ??= 'css-doodle';
 25 | 
 26 |     if (options.windowSize) {
 27 |         const [w, h = w] = options.windowSize.split(/[,x]/);
 28 |         options.windowWidth = Number(w);
 29 |         options.windowHeight = Number(h);
 30 |     }
 31 | 
 32 |     if (options.scale) {
 33 |         options.scale = Number(options.scale);
 34 |     }
 35 | 
 36 |     if (/\.(mp4|webm)$/.test(options.output) && !options.time) {
 37 |         options.time = 5 * 1000;
 38 |     }
 39 | 
 40 |     let title = options.time ? 'record' : 'image';
 41 |     if (source) {
 42 |         const basename = path.basename(source);
 43 |         const extname = path.extname(basename);
 44 |         title = extname ? basename.split(extname)[0] : basename;
 45 |     }
 46 |     options.title = title;
 47 | 
 48 |     try {
 49 |         const start = Date.now();
 50 |         const output = await render(content, options);
 51 |         const time = (Date.now() - start) / 1000;
 52 |         if (output && !options.quiet) {
 53 |             const outputTime = `(${time}s)`;
 54 |             console.log(`${msgSuccess('Saved')} to ${output} ${msgTip(outputTime)}`);
 55 |         }
 56 |     } catch (e) {
 57 |         console.error(msgError(e.message));
 58 |         process.exit(1);
 59 |     }
 60 | }
 61 | 
 62 | export async function handleParse(source) {
 63 |     const { content, error } = await read(source);
 64 |     if (error) {
 65 |         return console.error(error.message);
 66 |     }
 67 |     try {
 68 |         console.log(JSON.stringify(parse(content), null, 2));
 69 |     } catch (e) {
 70 |         console.error(msgError(e.message));
 71 |         process.exit(1);
 72 |     }
 73 | }
 74 | 
 75 | export async function handlePreview(source, options) {
 76 |     const { content, error, type } = await read(source);
 77 |     if (error) {
 78 |         if (!(type === 'css' && /empty/.test(error.message))) {
 79 |             return console.error(msgError(error.message));
 80 |         }
 81 |     }
 82 |     if (type === 'codepen' || type === 'html') {
 83 |         return console.error(msgError('only .css and .cssd files are supported for preview'));
 84 |     }
 85 |     if (source === undefined) {
 86 |         options.fromStdin = true;
 87 |         preview(content, 'css-doodle', options);
 88 |     } else {
 89 |         const title = path.basename(source);
 90 |         preview(source, title, options);
 91 |     }
 92 | }
 93 | 
 94 | export async function handleGenerateSVG(source) {
 95 |     let { content, error } = await read(source);
 96 |     if (error) {
 97 |         return console.error(error.message);
 98 |     }
 99 |     content = content.trim();
100 |     if (/^svg\s*\{/i.test(content) || !content.length) {
101 |         console.log(generateSVG(content));
102 |     } else {
103 |         console.error(msgError('invalid SVG format'));
104 |     }
105 | }
106 | 
107 | export async function handleGenerateShape(source) {
108 |     const { content, error } = await read(source);
109 |     if (error) {
110 |         return console.error(msgError(error.message));
111 |     }
112 |     console.log(generateShape(content));
113 | }
114 | 
115 | export async function handleSetConfig(field, value) {
116 |     if (field === 'css-doodle') {
117 |         try {
118 |             await fs.access(value, fs.constants.F_OK);
119 |             if (await isValidCssDoodleFile(value)) {
120 |                 config[field] = path.resolve(value);
121 |             } else {
122 |                 return console.error(msgError(`invalid css-doodle package file '${value}'`));
123 |             }
124 |         } catch (_e) {
125 |             if (!isPackageVersion(value)) {
126 |                 return console.error(msgError(`invalid package version '${value}'`));
127 |             }
128 |             const { result, error } = await fetchCssDoodleSource(value);
129 |             if (error) {
130 |                 return console.error(error.message);
131 |             }
132 |             try {
133 |                 const libPath = path.join(configDownloadPath, `css-doodle-${value}.js`);
134 |                 await fs.writeFile(libPath, result);
135 |                 config[field] = libPath;
136 |             } catch (_e) {
137 |                 return console.error(msgError(`failed to fetch css-doodle@${value}`));
138 |             }
139 |         }
140 |     } else {
141 |         config[field] = value;
142 |     }
143 | 
144 |     if (value === '') {
145 |         delete config[field];
146 |     }
147 | 
148 |     try {
149 |         await fs.writeFile(configPath, JSON.stringify(config, null, 2));
150 |         console.log(msgSuccess('Done'));
151 |     } catch (_e) {
152 |         console.error(msgError('failed to write config file'));
153 |     }
154 | }
155 | 
156 | export async function handleUnsetConfig(field) {
157 |     delete config[field];
158 |     try {
159 |         await fs.writeFile(configPath, JSON.stringify(config, null, 2));
160 |         console.log(msgSuccess('Done'));
161 |     } catch (_e) {
162 |         console.error(msgError('failed to write config file'));
163 |     }
164 | }
165 | 
166 | export function handleUseAction(version) {
167 |     handleSetConfig('css-doodle', version);
168 | }
169 | 
170 | export function handleDisplayConfig(field) {
171 |     console.log(config[field]);
172 | }
173 | 
174 | export function handleDisplayConfigList() {
175 |     console.log(JSON.stringify(config, null, 2));
176 | }
177 | 
178 | export function handleUpgrade() {
179 |     console.log(msgTip('Upgrading CLI'));
180 |     execSync('npm update -g @css-doodle/cli', { stdio: 'inherit' });
181 | }
182 | 
183 | async function fetchCssDoodleSource(version) {
184 |     let result = '', error;
185 | 
186 |     if (/^css\-doodle@/.test(version)) {
187 |         version = version.split('@')[1];
188 |     }
189 | 
190 |     const messageInvalid = msgError(`invalid package version '${version}'`);
191 |     const messageFailed = msgError(`failed to fetch css-doodle@${version}`);
192 | 
193 |     if (!(version === 'latest' || /^\d+\.\d+\.\d+$/.test(version))) {
194 |         return {
195 |             result,
196 |             error: new Error(messageInvalid),
197 |         }
198 |     }
199 | 
200 |     try {
201 |         console.log(msgTip(`Fetching css-doodle@${version} from esm.sh`));
202 |         result = await fetchResource(`https://esm.sh/css-doodle@${version}/css-doodle.min.js?raw`);
203 |     } catch (_e) {
204 |         try {
205 |             console.log(msgTip(`Fetch failed. Try jsdelivr instead`));
206 |             result = await fetchResource(`https://cdn.jsdelivr.net/npm/css-doodle@${version}/css-doodle.min.js`);
207 |         } catch (_e) {
208 |             error = new Error(messageFailed);
209 |         }
210 |     }
211 | 
212 |     if (/^invalid|ERR_PNPM_NO_MATCHING_VERSION/i.test(result)) {
213 |         error = new Error(messageInvalid);
214 |     }
215 | 
216 |     return {
217 |         result,
218 |         error,
219 |     }
220 | }
221 | 
222 | async function fetchResource(url) {
223 |     const res = await fetch(url, { redirect: 'follow' });
224 |     if (res.status !== 200) {
225 |         throw new Error(`failed to fetch ${url}`);
226 |     }
227 |     return Buffer.from(await res.arrayBuffer()).toString();
228 | }
229 | 
230 | function readTime(number, options = {}) {
231 |     let result = 0;
232 |     if (/^(\d+)(ms)?$/.test(number)) {
233 |         result = Number(number.replace('ms', ''));
234 |     }
235 |     if (/^(\d+)s$/.test(number)) {
236 |         result = Number(number.replace('s', '')) * 1000;
237 |     }
238 |     if (/^(\d+)m$/.test(number)) {
239 |         result = Number(number.replace('m', '')) * 60 * 1000;
240 |     }
241 |     return Math.min(result, options.max ?? Infinity);
242 | }
243 | 
244 | function isPackageVersion(value) {
245 |     return value === 'latest' || /^(css\-doodle@)?\d+\.\d+\.\d+$/.test(value);
246 | }
247 | 
248 | async function isValidCssDoodleFile(file) {
249 |     try {
250 |         const content = await fs.readFile(file, 'utf8');
251 |         return content.startsWith('/*! css-doodle');
252 |     } catch (_e) {
253 |         return false;
254 |     }
255 | }
256 | 


--------------------------------------------------------------------------------
/lib/message.js:
--------------------------------------------------------------------------------
 1 | import { styleText } from 'node:util';
 2 | 
 3 | export function msgTip(message) {
 4 |     return styleText('dim', message);
 5 | }
 6 | 
 7 | export function msgKey(message) {
 8 |     return bold(yellow(message));
 9 | }
10 | 
11 | export function msgWarning(message) {
12 |     return `${yellow('warn')}: ${message}`;
13 | }
14 | 
15 | export function msgError(message) {
16 |     return `${red('error')}: ${message}`;
17 | }
18 | 
19 | export function msgSuccess(message) {
20 |     return styleText('green', message);
21 | }
22 | 
23 | export function msgCommand(message) {
24 |     return styleText('blue', message);
25 | }
26 | 
27 | function red(message) {
28 |     return styleText('red', message);
29 | }
30 | 
31 | function yellow(message) {
32 |     return styleText('yellow', message);
33 | }
34 | 
35 | function bold(message) {
36 |     return styleText('bold', message);
37 | }
38 | 


--------------------------------------------------------------------------------
/lib/parse.js:
--------------------------------------------------------------------------------
1 | import { parse_css } from 'css-doodle/parser';
2 | 
3 | export function parse(code) {
4 |     return parse_css(code);
5 | }
6 | 


--------------------------------------------------------------------------------
/lib/preview/client.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 | <head>
  4 |     <meta charset="utf-8">
  5 |     <title>css-doodle</title>
  6 |     <style>
  7 |         html, body, #container {
  8 |             margin: 0;
  9 |             padding: 0;
 10 |             width: 100%;
 11 |             height: 100%;
 12 |         }
 13 |         body, #container {
 14 |             display: grid;
 15 |             place-items: center;
 16 |             background: #282828;
 17 |         }
 18 |     </style>
 19 | </head>
 20 | <body>
 21 |     <div id="container"></div>
 22 | 
 23 |     <script type="module">
 24 |         import('/css-doodle');
 25 | 
 26 |         const MIN_SIZE = 400;
 27 |         const MAX_SIZE = 800;
 28 | 
 29 |         let doodle;
 30 |         let autoResize = true;
 31 |         const query = new URLSearchParams(location.search);
 32 | 
 33 |         if (query.get('fullscreen')) {
 34 |             autoResize = false;
 35 |         }
 36 | 
 37 |         const title = query.get('title');
 38 |         if (title) {
 39 |             document.title = title;
 40 |         }
 41 | 
 42 |         const instance = query.get('instance');
 43 |         const ws = new WebSocket(`ws://${location.host}?instance=${instance}`);
 44 |         ws.addEventListener('message', handleMessages);
 45 | 
 46 |         ws.addEventListener('open', () => {
 47 |             ws.send(JSON.stringify({ type: 'ping' }));
 48 |         });
 49 | 
 50 |         function handleMessages(e) {
 51 |             let input = {};
 52 |             try {
 53 |                 input = JSON.parse(e.data);
 54 |             } catch(e) {
 55 |                 console.error(e.message);
 56 |             }
 57 |             let { data, type } = input;
 58 |             switch (type) {
 59 |                 case 'update': {
 60 |                     if (doodle && doodle.update) {
 61 |                         doodle.update(data);
 62 |                     } else {
 63 |                         doodle = document.createElement('css-doodle');
 64 | 
 65 |                         doodle.addEventListener('render', () => {
 66 |                             updateWindow();
 67 |                         });
 68 | 
 69 |                         doodle.innerHTML = `<template>${data}</template>`;
 70 |                         doodle.setAttribute('click-to-update', '');
 71 |                         doodle.setAttribute('experimental', '');
 72 |                         container.appendChild(doodle);
 73 |                     }
 74 |                 }
 75 |             }
 76 |         }
 77 | 
 78 |         function clamp(value, min, max) {
 79 |             return Math.min(Math.max(value, min), max);
 80 |         }
 81 | 
 82 |         function updateWindow() {
 83 |             let { width, height }  = doodle.getBoundingClientRect();
 84 |             document.title = title + ` (${Math.round(width)}x${Math.round(height)})`;
 85 | 
 86 |             if (autoResize) {
 87 |                 autoResize = false;
 88 |                 width = clamp(width, MIN_SIZE, MAX_SIZE);
 89 |                 height = clamp(height, MIN_SIZE, MAX_SIZE);
 90 |                 window.resizeTo(width, height + 28);
 91 |             }
 92 |         }
 93 | 
 94 |         if (!query.get('fullscreen')) {
 95 |             window.addEventListener('resize', updateWindow);
 96 |         }
 97 |     </script>
 98 | </body>
 99 | <html>
100 | 


--------------------------------------------------------------------------------
/lib/preview/index.js:
--------------------------------------------------------------------------------
 1 | import fs from 'node:fs/promises';
 2 | import crypto from 'node:crypto';
 3 | import { tmpdir } from 'node:os';
 4 | import { join } from 'node:path';
 5 | import process from 'node:process';
 6 | import { spawn } from 'node:child_process';
 7 | 
 8 | import puppeteer from 'puppeteer';
 9 | 
10 | import { previewServerPath, getBrowserPath, defaultAppArgs } from '../static.js';
11 | import { msgError } from '../message.js';
12 | 
13 | const SIZE = '600,628';
14 | 
15 | export async function preview(sourceFile, title, options = {}) {
16 |     const source = sourceFile;
17 |     if (options.fromStdin) {
18 |         sourceFile = join(tmpdir(), crypto.randomUUID());
19 |         try {
20 |             await fs.writeFile(sourceFile, source);
21 |         } catch (_e) {
22 |             console.error(msgError('failed to create a temporary file for preview'));
23 |             process.exit(1);
24 |         }
25 |     }
26 | 
27 |     const serverProcess = spawn('node', [previewServerPath, sourceFile], {
28 |         detached: true,
29 |         stdio: ['pipe', 'pipe', 'pipe', 'ipc']
30 |     });
31 | 
32 |     serverProcess.unref();
33 | 
34 |     serverProcess.on('message', async (message) => {
35 |         if (message.info) {
36 |             console.log(message.info);
37 |         }
38 |         if (message.url) {
39 |             const params = new URLSearchParams();
40 |             params.set('title', title);
41 |             params.set('instance', crypto.randomUUID());
42 | 
43 |             if (options.fullscreen) {
44 |                 params.set('fullscreen', '1');
45 |             }
46 | 
47 |             const args = [
48 |                 `--window-size=${SIZE}`,
49 |                 `--app=${message.url}?${params.toString()}`,
50 |             ];
51 | 
52 |             if (options.fullscreen) {
53 |                 args.push('--start-fullscreen');
54 |             }
55 | 
56 |             const settings = {
57 |                 headless: false,
58 |                 waitForInitialPage: false,
59 |                 ignoreDefaultArgs: ['--enable-automation'],
60 |                 args: [
61 |                     ...args,
62 |                     ...defaultAppArgs,
63 |                 ],
64 |             };
65 | 
66 |             const browserPath = await getBrowserPath();
67 |             if (browserPath) {
68 |                 settings.executablePath = browserPath;
69 |             }
70 | 
71 |             puppeteer.launch(settings)
72 |                 .catch(e => {
73 |                     console.error(e.message);
74 |                     serverProcess.kill();
75 |                     process.exit(1);
76 |                 });
77 |         }
78 | 
79 |         if (message.exit) {
80 |             serverProcess.kill();
81 |             process.exit(0);
82 |         }
83 |     });
84 | }
85 | 


--------------------------------------------------------------------------------
/lib/preview/server.js:
--------------------------------------------------------------------------------
  1 | import fs from 'node:fs/promises';
  2 | import { createServer } from 'node:http';
  3 | import process from 'node:process';
  4 | 
  5 | import { WebSocketServer } from 'ws';
  6 | import watch from 'node-watch';
  7 | 
  8 | import { previewClient, getCssDoodleLib } from '../static.js';
  9 | 
 10 | const sourceFile = process.argv[2];
 11 | const timers = {};
 12 | 
 13 | if (!sourceFile) {
 14 |     console.error('Usage: node server.js <source-file>');
 15 |     process.exit(1);
 16 | }
 17 | 
 18 | const httpServer = createServer(async (req, res) => {
 19 |     const route = req.url.split('?')[0];
 20 |     switch (route) {
 21 |         case '/':
 22 |             res.writeHead(200, { 'Content-Type': 'text/html' });
 23 |             res.end(previewClient);
 24 |             break;
 25 |         case '/css-doodle':
 26 |             res.writeHead(200, {
 27 |                 'Content-Type': 'application/javascript',
 28 |                 'Access-Control-Allow-Origin': '*',
 29 |                 'Access-Control-Allow-Methods': '*',
 30 |             });
 31 |             res.end(await getCssDoodleLib());
 32 |             break;
 33 |         case '/favicon.ico':
 34 |             res.writeHead(204);
 35 |             res.end();
 36 |             break;
 37 |         default:
 38 |             res.writeHead(404, { 'Content-Type': 'text/plain' });
 39 |             res.end('Not Found');
 40 |     }
 41 | });
 42 | 
 43 | const wsServer = new WebSocketServer({
 44 |     server: httpServer
 45 | });
 46 | 
 47 | function pendingClose(instance, fn, timeout = 1000) {
 48 |     timers[instance] = setTimeout(fn, timeout);
 49 | }
 50 | 
 51 | wsServer.on('connection', async (ws, req) => {
 52 |     const query = new URLSearchParams(req.url.split('?')[1]);
 53 |     const watcher = watch(sourceFile);
 54 | 
 55 |     ws.send(JSON.stringify({
 56 |         type: 'update',
 57 |         data: await fs.readFile(sourceFile, 'utf-8')
 58 |     }));
 59 | 
 60 |     ws.on('error', e => {
 61 |         console.error(e.message);
 62 |     });
 63 | 
 64 |     ws.on('message', (e) => {
 65 |         let input = {};
 66 |         try {
 67 |             input = JSON.parse(e);
 68 |         } catch (e) {
 69 |             console.error(e.message);
 70 |         }
 71 |         if (input.type === 'ping') {
 72 |             clearTimeout(timers[query.get('instance')]);
 73 |         }
 74 |     });
 75 | 
 76 |     ws.on('close', () => {
 77 |         pendingClose(query.get('instance'), () => {
 78 |             watcher.close();
 79 |             httpServer.close();
 80 |             wsServer.close();
 81 |             if (process.send) {
 82 |                 process.send({ exit: true });
 83 |             }
 84 |         });
 85 |     });
 86 | 
 87 |     watcher.on('change', async (event) => {
 88 |         if (event === 'update') {
 89 |             ws.send(JSON.stringify({
 90 |                 type: 'update',
 91 |                 data: await fs.readFile(sourceFile, 'utf-8')
 92 |             }));
 93 |         }
 94 |     });
 95 | });
 96 | 
 97 | httpServer.listen(0, () => {
 98 |     const port = httpServer.address().port;
 99 |     if (process.send) {
100 |         process.send({ url: 'http://localhost:' + port });
101 |     }
102 | });
103 | 


--------------------------------------------------------------------------------
/lib/read.js:
--------------------------------------------------------------------------------
 1 | import os from 'node:os';
 2 | import fs from 'node:fs/promises';
 3 | import { stdin } from 'node:process';
 4 | import { msgTip, msgKey } from './message.js';
 5 | 
 6 | export async function read(path) {
 7 |     let result = { content: '', type: '', error: null };
 8 | 
 9 |     if (path === undefined) {
10 |         result.type = 'stdin';
11 |         const key = os.platform() === 'win32' ? 'CTRL+Z' : 'CTRL+D';
12 |         console.log(
13 |             msgTip('Reading from stdin — press ') + msgKey(key) + msgTip(' to end input.\n')
14 |         );
15 |         try {
16 |             result.content = await readFromStdin();
17 |             console.log('\n');
18 |         } catch (e) {
19 |             result.error = e;
20 |         }
21 |     }
22 |     else if (/^(https:\/\/)?codepen\.io/.test(path)) {
23 |         result.type = 'codepen';
24 |         const match = path.match(/^(https:\/\/)?codepen\.io\/([^\/]+)\/(pen|details|full)\/([^\/]+)$/) || [];
25 |         const [user, id] = [match[2], match[4]];
26 |         if (user && id) {
27 |             result.content = `https://cdpn.io/${user}/fullpage/${id}?nocache=true&view=fullpage`;
28 |         } else {
29 |             result.error = new Error('unsupported CodePen url, should be like https://codepen.io/:user/pen/:id');
30 |         }
31 |     }
32 |     else if (/\.html$/.test(path)) {
33 |         const { content, error } = await readFile(path);
34 |         result = { type: 'html', content, error };
35 |     }
36 |     else if (/\.cssd?$/.test(path)) {
37 |         const { content, error } = await readFile(path);
38 |         result = { type: 'css', content, error };
39 |     }
40 |     else {
41 |         result.error = new Error('invalid input, accept .html, .css, .cssd, and CodePen link');
42 |     }
43 | 
44 |     if (result.content) {
45 |         result.content = result.content.trim();
46 |     }
47 | 
48 |     if (!result.error && !result.content) {
49 |         result.error = new Error('empty input');
50 |     }
51 | 
52 |     return result;
53 | }
54 | 
55 | function readFromStdin() {
56 |     return new Promise((resolve, reject) => {
57 |         let content = '';
58 |         stdin.setEncoding('utf8');
59 |         stdin.on('data', c => content += c);
60 |         stdin.on('end', () => resolve(content));
61 |         stdin.on('error', reject);
62 |     });
63 | }
64 | 
65 | async function readFile(path) {
66 |     let content = '', error;
67 |     try {
68 |         content = await fs.readFile(path, 'utf8');
69 |     } catch (e) {
70 |         error = e;
71 |     }
72 |     return { content, error };
73 | }
74 | 


--------------------------------------------------------------------------------
/lib/render/index.js:
--------------------------------------------------------------------------------
  1 | import { setTimeout } from 'node:timers/promises';
  2 | 
  3 | import puppeteer from 'puppeteer';
  4 | 
  5 | import { getCssDoodleLib, getBrowserPath, defaultAppArgs } from '../static.js';
  6 | import { screenshot } from './screenshot.js';
  7 | import { screencast } from './screencast.js';
  8 | import { msgTip } from '../message.js';
  9 | 
 10 | export async function render(code, options = {}) {
 11 |     const args = [
 12 |         ...defaultAppArgs,
 13 |         '--start-maximized',
 14 |     ];
 15 | 
 16 |     if (options.type === 'codepen') {
 17 |         args.push('--ignore-certificate-errors');
 18 |     }
 19 | 
 20 |     const settings = {
 21 |         defaultViewport: null,
 22 |         args,
 23 |     };
 24 | 
 25 |     const browserPath = await getBrowserPath();
 26 |     if (browserPath) {
 27 |         settings.executablePath = browserPath;
 28 |     }
 29 | 
 30 |     const browser = await puppeteer.launch(settings);
 31 |     const page = await browser.newPage();
 32 | 
 33 |     switch (options.type) {
 34 |         case 'css': case 'cssd': case 'stdin': {
 35 |             await page.setContent(buildHTML(code, await getCssDoodleLib()));
 36 |             break;
 37 |         }
 38 |         case 'html': {
 39 |             await page.setContent(code);
 40 |             break;
 41 |         }
 42 |         case 'codepen': {
 43 |             if (!options.quiet) {
 44 |                 console.log(msgTip('Fetching from CodePen'));
 45 |             }
 46 |             await page.goto(code);
 47 |             const iframe = await page.$('iframe#result');
 48 |             if (iframe) {
 49 |                 const code = await page.evaluate(el => el.getAttribute('srcdoc'), iframe);
 50 |                 await page.setContent(code, { waitUntil: 'networkidle0' });
 51 |             } else {
 52 |                 throw new Error('read CodePen failed');
 53 |             }
 54 |             break;
 55 |         }
 56 |         default: {
 57 |             throw new Error('invalid type `${options.type}`');
 58 |         }
 59 |     }
 60 | 
 61 |     if (!options.output) {
 62 |         let tag = Date.now();
 63 |         if (/^(css|cssd|stdin)$/.test(options.type)) {
 64 |             tag = await page.$eval('css-doodle', el => el.seed);
 65 |         }
 66 |         let ext = options.time ? 'webm' : 'png';
 67 |         if (ext === 'webm' && options.mp4) {
 68 |             ext = 'mp4';
 69 |         }
 70 |         options.output = `${options.title}-${tag}.${ext}`;
 71 |     }
 72 | 
 73 |     if (/\.(mp4|webm)$/.test(options.output) && !options.time) {
 74 |         options.time = 5 * 1000;
 75 |     }
 76 | 
 77 |     if (options.output.endsWith('.mp4')) {
 78 |         options.mp4 = true;
 79 |     }
 80 | 
 81 |     if (options.delay) {
 82 |         await setTimeout(options.delay);
 83 |     }
 84 | 
 85 |     const output = options.time
 86 |         ? await screencast(page, options)
 87 |         : await screenshot(page, options);
 88 | 
 89 |     await browser.close();
 90 |     return output;
 91 | }
 92 | 
 93 | function buildHTML(code, cssDoodleLib) {
 94 |     return `<!doctype html>
 95 |     <html>
 96 |     <head>
 97 |         <meta charset="utf-8">
 98 |         <style>
 99 |             html, body, #container { margin: 0; padding: 0; width: 100%; height: 100% }
100 |             body, #container { display: grid; place-items: center; }
101 |         </style>
102 |         <script>${cssDoodleLib}</script>
103 |     </head>
104 |     <body>
105 |         <div id="container">
106 |             <css-doodle><template>${code}</template></css-doodle>
107 |         </div>
108 |     </body>
109 |     </html>`;
110 | }
111 | 


--------------------------------------------------------------------------------
/lib/render/screencast.js:
--------------------------------------------------------------------------------
 1 | import { setTimeout } from 'node:timers/promises';
 2 | import { spawn } from 'node:child_process';
 3 | import { randomUUID } from 'node:crypto';
 4 | import { tmpdir } from 'node:os';
 5 | import { join } from 'node:path';
 6 | 
 7 | import { msgTip } from '../message.js';
 8 | 
 9 | const defaultWindowWidth = 1200;
10 | const defaultWindowHeight = 900;
11 | const defaultScale = 1;
12 | 
13 | export async function screencast(page, options) {
14 |     const { scale, output, selector, windowWidth, windowHeight } = options;
15 |     const WIDTH = windowWidth || defaultWindowWidth;
16 |     const HEIGHT = windowHeight || defaultWindowHeight;
17 |     const SCALE = scale || defaultScale;
18 | 
19 |     await page.setViewport({
20 |         width: WIDTH,
21 |         height: HEIGHT,
22 |         defaultScaleFactor: SCALE
23 |     });
24 | 
25 |     const castOption = {
26 |         path: options.mp4
27 |             ? join(tmpdir(), randomUUID() + '.webm')
28 |             : output
29 |     };
30 | 
31 |     const crop = await page.evaluate(async selector => {
32 |         const element = document.querySelector(selector);
33 |         if (element) {
34 |             const rect = element.getBoundingClientRect();
35 |             if (rect.width === 0 || rect.height === 0) {
36 |                 await setTimeout(1000);
37 |             }
38 |             const { width, height, x, y } = element.getBoundingClientRect();
39 |             return {
40 |                 x,
41 |                 y,
42 |                 width,
43 |                 height: height || width,
44 |             };
45 |         }
46 |     }, selector);
47 | 
48 |     if (crop) {
49 |         crop.x = Math.max(crop.x, 0) || 0;
50 |         crop.y = Math.max(crop.y, 0) || 0;
51 |         crop.width = Math.min(crop.width, WIDTH) || WIDTH;
52 |         crop.height = Math.min(crop.height, HEIGHT) || HEIGHT;
53 |         castOption.crop = crop;
54 |     }
55 | 
56 |     if (!options.quiet) {
57 |         console.log(msgTip('Recording'));
58 |     }
59 |     const recorder = await page.screencast(castOption);
60 | 
61 |     await setTimeout(options.time);
62 |     await recorder.stop();
63 | 
64 |     if (options.mp4) {
65 |         try {
66 |             return await webmToMp4(castOption.path, output);
67 |         } catch (e) {
68 |             throw e;
69 |         }
70 |     }
71 | 
72 |     return output;
73 | }
74 | 
75 | function webmToMp4(input, output) {
76 |     return new Promise((resolve, reject) => {
77 |         const ffmpeg = spawn('ffmpeg', ['-i', input, '-c:v', 'copy', output]);
78 |         ffmpeg.stdin.write('y\n');
79 |         ffmpeg.stdin.end();
80 |         ffmpeg.on('close', code => {
81 |             if (code === 0) {
82 |                 resolve(output);
83 |             } else {
84 |                 reject(new Error(`record failed, ffmpeg exited with code ${code}`));
85 |             }
86 |         });
87 |     });
88 | }
89 | 


--------------------------------------------------------------------------------
/lib/render/screenshot.js:
--------------------------------------------------------------------------------
 1 | const defaultWindowWidth = 1600;
 2 | const defaultWindowHeight = 1200;
 3 | const defaultScale = 2;
 4 | 
 5 | export async function screenshot(page, options = {}) {
 6 |     const { scale, output, selector, windowWidth, windowHeight } = options;
 7 |     const WIDTH = windowWidth || defaultWindowWidth;
 8 |     const HEIGHT = windowHeight || defaultWindowHeight;
 9 |     const SCALE = scale || defaultScale;
10 | 
11 |     await page.setViewport({
12 |         width: WIDTH,
13 |         height: HEIGHT,
14 |         deviceScaleFactor: SCALE
15 |     });
16 | 
17 |     const info = await page.evaluate(selector => {
18 |         const element = document.querySelector(selector);
19 |         if (element) {
20 |             const { width, height } = element.getBoundingClientRect();
21 |             return {
22 |                 width,
23 |                 height: height || width,
24 |                 node: true
25 |             };
26 |         } else {
27 |             const doc = document.documentElement;
28 |             return {
29 |                 width: doc.scrollWidth,
30 |                 height: doc.scrollHeight,
31 |                 node: false
32 |             };
33 |         }
34 |     }, selector);
35 | 
36 |     await page.setViewport({
37 |         width: Math.ceil(info.width) || WIDTH,
38 |         height: Math.ceil(info.height) || HEIGHT,
39 |         deviceScaleFactor: SCALE
40 |     });
41 | 
42 |     if (info.node) {
43 |         const element = await page.$(selector);
44 |         await element.screenshot({
45 |             path: output,
46 |             omitBackground: true
47 |         });
48 |     } else {
49 |         await page.screenshot({
50 |             path: output,
51 |             fullPage: true
52 |         });
53 |     }
54 | 
55 |     return output;
56 | }
57 | 


--------------------------------------------------------------------------------
/lib/static.js:
--------------------------------------------------------------------------------
  1 | import fs from 'node:fs/promises';
  2 | import os from 'node:os';
  3 | import process from 'node:process';
  4 | import { join, basename } from 'node:path';
  5 | 
  6 | import { msgError, msgWarning } from './message.js';
  7 | import pkgInfo from '../package.json' with { type: 'json' }
  8 | 
  9 | const isLinux = os.platform() === 'linux';
 10 | const configRoot = join(os.homedir(), '.config');
 11 | const configDir = join(configRoot, 'css-doodle');
 12 | const configFilePath = join(configDir, 'config.json');
 13 | const configDownloadDir = join(configDir, 'download');
 14 | 
 15 | if (!await checkExists(configRoot)) {
 16 |     await fs.mkdir(configRoot);
 17 | }
 18 | 
 19 | const configOldDir = join(os.homedir(), '.css-doodle');
 20 | 
 21 | if (await checkExists(configOldDir)) {
 22 |     console.warn(msgWarning(`Config directory ${configOldDir} is deprecated.\nMoving to ${configDir}.\n`));
 23 |     try {
 24 |         await fs.rename(configOldDir, configDir);
 25 |     } catch (e) {
 26 |         console.error(msgError(`Failed to move config directory: ${e.message}`));
 27 |     }
 28 | }
 29 | 
 30 | if (!await checkExists(configDir)) {
 31 |     await fs.mkdir(configDir);
 32 | }
 33 | 
 34 | if (!await checkExists(configDownloadDir)) {
 35 |     await fs.mkdir(configDownloadDir);
 36 | }
 37 | 
 38 | if (!await checkExists(configFilePath)) {
 39 |     await fs.writeFile(configFilePath, '{}');
 40 | }
 41 | 
 42 | function getDefaultAppArgs() {
 43 |     const args = [
 44 |         '--disable-infobars',
 45 |         '--enable-experimental-web-platform-features',
 46 |         '--diable-extensions',
 47 |         '--enable-gpu-rasterization',
 48 |         '--enable-oop-rasterization',
 49 |         '--enable-webgl-draft-extensions',
 50 |         '--enable-composited-animations',
 51 |         '--enable-optimized-css',
 52 |         '--enable-accelerated-2d-canvas',
 53 |         '--enable-gpu',
 54 |         '--use-angle',
 55 |     ];
 56 | 
 57 |     if (isLinux) {
 58 |         args.push('--no-sandbox', '--disable-setuid-sandbox');
 59 |     }
 60 | 
 61 |     return args;
 62 | }
 63 | 
 64 | function getPackageInfo() {
 65 |     const name = basename(process.argv[1]);
 66 |     const programName = pkgInfo.bin?.[name] ? name : 'cssd';
 67 |     return Object.assign(pkgInfo, { programName });
 68 | }
 69 | 
 70 | export async function getCssDoodleLib() {
 71 |     const libPath = config['css-doodle'];
 72 |     if (libPath) {
 73 |         if (await checkExists(libPath)) {
 74 |             return await fs.readFile(libPath, 'utf8');
 75 |         } else {
 76 |             console.warn(msgWarning(`css-doodle in config not found: ${libPath}.\nUsed default css-doodle instead.\n`));
 77 |         }
 78 |     }
 79 |     return fs.readFile(join(import.meta.dirname, '../node_modules/css-doodle/css-doodle.min.js'));
 80 | }
 81 | 
 82 | export async function getBrowserPath() {
 83 |     const browserPath = config['browserPath']
 84 |         || config['browser-path']
 85 |         || config['executablePath']
 86 |         || config['executable-path'];
 87 |     if (browserPath) {
 88 |         if (await checkExists(browserPath)) {
 89 |             return browserPath;
 90 |         } else {
 91 |             console.warn(msgWarning(`browser in config not found: ${browserPath}.\nUsed default browser instead.\n`));
 92 |         }
 93 |     }
 94 |     return '';
 95 | }
 96 | 
 97 | function checkExists(filePath) {
 98 |     return fs.access(filePath, fs.constants.F_OK).then(() => true).catch(() => false);
 99 | }
100 | 
101 | async function getConfigContent(configFilePath) {
102 |     try {
103 |         return JSON.parse(await fs.readFile(configFilePath), 'utf8');
104 |     } catch (e) {
105 |         console.error(msgError(`Failed to access config file: ${e.message}`));
106 |         return {};
107 |     }
108 | }
109 | 
110 | export const config = await getConfigContent(configFilePath);
111 | export const configPath = configFilePath;
112 | export const configDownloadPath = configDownloadDir;
113 | 
114 | export const previewClient = await fs.readFile(join(import.meta.dirname, './preview/client.html'));
115 | export const previewServerPath = join(import.meta.dirname, './preview/server.js');
116 | export const defaultAppArgs = getDefaultAppArgs();
117 | export const pkg = getPackageInfo();
118 | 


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
   1 | {
   2 |   "name": "@css-doodle/cli",
   3 |   "version": "1.6.1",
   4 |   "lockfileVersion": 3,
   5 |   "requires": true,
   6 |   "packages": {
   7 |     "": {
   8 |       "name": "@css-doodle/cli",
   9 |       "version": "1.6.1",
  10 |       "license": "MIT",
  11 |       "dependencies": {
  12 |         "commander": "^13.1.0",
  13 |         "css-doodle": "^0.42.2",
  14 |         "node-watch": "^0.7.4",
  15 |         "puppeteer": "^v24.6.1",
  16 |         "ws": "^8.18.1"
  17 |       },
  18 |       "bin": {
  19 |         "css-doodle": "bin/index.js",
  20 |         "cssd": "bin/index.js"
  21 |       },
  22 |       "devDependencies": {},
  23 |       "funding": {
  24 |         "type": "opencollective",
  25 |         "url": "https://opencollective.com/css-doodle"
  26 |       }
  27 |     },
  28 |     "node_modules/@babel/code-frame": {
  29 |       "version": "7.24.7",
  30 |       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.24.7.tgz",
  31 |       "integrity": "sha512-BcYH1CVJBO9tvyIZ2jVeXgSIMvGZ2FDRvDdOIVQyuklNKSsx+eppDEBq/g47Ayw+RqNFE+URvOShmf+f/qwAlA==",
  32 |       "license": "MIT",
  33 |       "dependencies": {
  34 |         "@babel/highlight": "^7.24.7",
  35 |         "picocolors": "^1.0.0"
  36 |       },
  37 |       "engines": {
  38 |         "node": ">=6.9.0"
  39 |       }
  40 |     },
  41 |     "node_modules/@babel/helper-validator-identifier": {
  42 |       "version": "7.24.7",
  43 |       "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.7.tgz",
  44 |       "integrity": "sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w==",
  45 |       "license": "MIT",
  46 |       "engines": {
  47 |         "node": ">=6.9.0"
  48 |       }
  49 |     },
  50 |     "node_modules/@babel/highlight": {
  51 |       "version": "7.24.7",
  52 |       "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.24.7.tgz",
  53 |       "integrity": "sha512-EStJpq4OuY8xYfhGVXngigBJRWxftKX9ksiGDnmlY3o7B/V7KIAc9X4oiK87uPJSc/vs5L869bem5fhZa8caZw==",
  54 |       "license": "MIT",
  55 |       "dependencies": {
  56 |         "@babel/helper-validator-identifier": "^7.24.7",
  57 |         "chalk": "^2.4.2",
  58 |         "js-tokens": "^4.0.0",
  59 |         "picocolors": "^1.0.0"
  60 |       },
  61 |       "engines": {
  62 |         "node": ">=6.9.0"
  63 |       }
  64 |     },
  65 |     "node_modules/@puppeteer/browsers": {
  66 |       "version": "2.10.0",
  67 |       "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.10.0.tgz",
  68 |       "integrity": "sha512-HdHF4rny4JCvIcm7V1dpvpctIGqM3/Me255CB44vW7hDG1zYMmcBMjpNqZEDxdCfXGLkx5kP0+Jz5DUS+ukqtA==",
  69 |       "license": "Apache-2.0",
  70 |       "dependencies": {
  71 |         "debug": "^4.4.0",
  72 |         "extract-zip": "^2.0.1",
  73 |         "progress": "^2.0.3",
  74 |         "proxy-agent": "^6.5.0",
  75 |         "semver": "^7.7.1",
  76 |         "tar-fs": "^3.0.8",
  77 |         "yargs": "^17.7.2"
  78 |       },
  79 |       "bin": {
  80 |         "browsers": "lib/cjs/main-cli.js"
  81 |       },
  82 |       "engines": {
  83 |         "node": ">=18"
  84 |       }
  85 |     },
  86 |     "node_modules/@tootallnate/quickjs-emscripten": {
  87 |       "version": "0.23.0",
  88 |       "resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
  89 |       "integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
  90 |       "license": "MIT"
  91 |     },
  92 |     "node_modules/@types/node": {
  93 |       "version": "22.14.1",
  94 |       "resolved": "https://registry.npmjs.org/@types/node/-/node-22.14.1.tgz",
  95 |       "integrity": "sha512-u0HuPQwe/dHrItgHHpmw3N2fYCR6x4ivMNbPHRkBVP4CvN+kiRrKHWk3i8tXiO/joPwXLMYvF9TTF0eqgHIuOw==",
  96 |       "license": "MIT",
  97 |       "optional": true,
  98 |       "dependencies": {
  99 |         "undici-types": "~6.21.0"
 100 |       }
 101 |     },
 102 |     "node_modules/@types/yauzl": {
 103 |       "version": "2.10.3",
 104 |       "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
 105 |       "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
 106 |       "license": "MIT",
 107 |       "optional": true,
 108 |       "dependencies": {
 109 |         "@types/node": "*"
 110 |       }
 111 |     },
 112 |     "node_modules/agent-base": {
 113 |       "version": "7.1.3",
 114 |       "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
 115 |       "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
 116 |       "license": "MIT",
 117 |       "engines": {
 118 |         "node": ">= 14"
 119 |       }
 120 |     },
 121 |     "node_modules/ansi-regex": {
 122 |       "version": "5.0.1",
 123 |       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
 124 |       "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
 125 |       "license": "MIT",
 126 |       "engines": {
 127 |         "node": ">=8"
 128 |       }
 129 |     },
 130 |     "node_modules/ansi-styles": {
 131 |       "version": "4.3.0",
 132 |       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
 133 |       "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
 134 |       "license": "MIT",
 135 |       "dependencies": {
 136 |         "color-convert": "^2.0.1"
 137 |       },
 138 |       "engines": {
 139 |         "node": ">=8"
 140 |       },
 141 |       "funding": {
 142 |         "url": "https://github.com/chalk/ansi-styles?sponsor=1"
 143 |       }
 144 |     },
 145 |     "node_modules/argparse": {
 146 |       "version": "2.0.1",
 147 |       "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
 148 |       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
 149 |       "license": "Python-2.0"
 150 |     },
 151 |     "node_modules/ast-types": {
 152 |       "version": "0.13.4",
 153 |       "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
 154 |       "integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
 155 |       "license": "MIT",
 156 |       "dependencies": {
 157 |         "tslib": "^2.0.1"
 158 |       },
 159 |       "engines": {
 160 |         "node": ">=4"
 161 |       }
 162 |     },
 163 |     "node_modules/b4a": {
 164 |       "version": "1.6.7",
 165 |       "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz",
 166 |       "integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==",
 167 |       "license": "Apache-2.0"
 168 |     },
 169 |     "node_modules/bare-events": {
 170 |       "version": "2.5.4",
 171 |       "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.5.4.tgz",
 172 |       "integrity": "sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==",
 173 |       "license": "Apache-2.0",
 174 |       "optional": true
 175 |     },
 176 |     "node_modules/bare-fs": {
 177 |       "version": "4.1.2",
 178 |       "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.1.2.tgz",
 179 |       "integrity": "sha512-8wSeOia5B7LwD4+h465y73KOdj5QHsbbuoUfPBi+pXgFJIPuG7SsiOdJuijWMyfid49eD+WivpfY7KT8gbAzBA==",
 180 |       "license": "Apache-2.0",
 181 |       "optional": true,
 182 |       "dependencies": {
 183 |         "bare-events": "^2.5.4",
 184 |         "bare-path": "^3.0.0",
 185 |         "bare-stream": "^2.6.4"
 186 |       },
 187 |       "engines": {
 188 |         "bare": ">=1.16.0"
 189 |       },
 190 |       "peerDependencies": {
 191 |         "bare-buffer": "*"
 192 |       },
 193 |       "peerDependenciesMeta": {
 194 |         "bare-buffer": {
 195 |           "optional": true
 196 |         }
 197 |       }
 198 |     },
 199 |     "node_modules/bare-os": {
 200 |       "version": "3.6.1",
 201 |       "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.1.tgz",
 202 |       "integrity": "sha512-uaIjxokhFidJP+bmmvKSgiMzj2sV5GPHaZVAIktcxcpCyBFFWO+YlikVAdhmUo2vYFvFhOXIAlldqV29L8126g==",
 203 |       "license": "Apache-2.0",
 204 |       "optional": true,
 205 |       "engines": {
 206 |         "bare": ">=1.14.0"
 207 |       }
 208 |     },
 209 |     "node_modules/bare-path": {
 210 |       "version": "3.0.0",
 211 |       "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
 212 |       "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
 213 |       "license": "Apache-2.0",
 214 |       "optional": true,
 215 |       "dependencies": {
 216 |         "bare-os": "^3.0.1"
 217 |       }
 218 |     },
 219 |     "node_modules/bare-stream": {
 220 |       "version": "2.6.5",
 221 |       "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.6.5.tgz",
 222 |       "integrity": "sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==",
 223 |       "license": "Apache-2.0",
 224 |       "optional": true,
 225 |       "dependencies": {
 226 |         "streamx": "^2.21.0"
 227 |       },
 228 |       "peerDependencies": {
 229 |         "bare-buffer": "*",
 230 |         "bare-events": "*"
 231 |       },
 232 |       "peerDependenciesMeta": {
 233 |         "bare-buffer": {
 234 |           "optional": true
 235 |         },
 236 |         "bare-events": {
 237 |           "optional": true
 238 |         }
 239 |       }
 240 |     },
 241 |     "node_modules/basic-ftp": {
 242 |       "version": "5.0.5",
 243 |       "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.0.5.tgz",
 244 |       "integrity": "sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==",
 245 |       "license": "MIT",
 246 |       "engines": {
 247 |         "node": ">=10.0.0"
 248 |       }
 249 |     },
 250 |     "node_modules/buffer-crc32": {
 251 |       "version": "0.2.13",
 252 |       "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
 253 |       "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
 254 |       "license": "MIT",
 255 |       "engines": {
 256 |         "node": "*"
 257 |       }
 258 |     },
 259 |     "node_modules/callsites": {
 260 |       "version": "3.1.0",
 261 |       "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
 262 |       "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
 263 |       "license": "MIT",
 264 |       "engines": {
 265 |         "node": ">=6"
 266 |       }
 267 |     },
 268 |     "node_modules/chalk": {
 269 |       "version": "2.4.2",
 270 |       "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
 271 |       "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
 272 |       "license": "MIT",
 273 |       "dependencies": {
 274 |         "ansi-styles": "^3.2.1",
 275 |         "escape-string-regexp": "^1.0.5",
 276 |         "supports-color": "^5.3.0"
 277 |       },
 278 |       "engines": {
 279 |         "node": ">=4"
 280 |       }
 281 |     },
 282 |     "node_modules/chalk/node_modules/ansi-styles": {
 283 |       "version": "3.2.1",
 284 |       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
 285 |       "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
 286 |       "license": "MIT",
 287 |       "dependencies": {
 288 |         "color-convert": "^1.9.0"
 289 |       },
 290 |       "engines": {
 291 |         "node": ">=4"
 292 |       }
 293 |     },
 294 |     "node_modules/chalk/node_modules/color-convert": {
 295 |       "version": "1.9.3",
 296 |       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
 297 |       "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
 298 |       "license": "MIT",
 299 |       "dependencies": {
 300 |         "color-name": "1.1.3"
 301 |       }
 302 |     },
 303 |     "node_modules/chalk/node_modules/color-name": {
 304 |       "version": "1.1.3",
 305 |       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
 306 |       "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
 307 |       "license": "MIT"
 308 |     },
 309 |     "node_modules/chromium-bidi": {
 310 |       "version": "3.0.0",
 311 |       "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-3.0.0.tgz",
 312 |       "integrity": "sha512-ZOGRDAhBMX1uxL2Cm2TDuhImbrsEz5A/tTcVU6RpXEWaTNUNwsHW6njUXizh51Ir6iqHbKAfhA2XK33uBcLo5A==",
 313 |       "license": "Apache-2.0",
 314 |       "dependencies": {
 315 |         "mitt": "^3.0.1",
 316 |         "zod": "^3.24.1"
 317 |       },
 318 |       "peerDependencies": {
 319 |         "devtools-protocol": "*"
 320 |       }
 321 |     },
 322 |     "node_modules/cliui": {
 323 |       "version": "8.0.1",
 324 |       "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
 325 |       "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
 326 |       "license": "ISC",
 327 |       "dependencies": {
 328 |         "string-width": "^4.2.0",
 329 |         "strip-ansi": "^6.0.1",
 330 |         "wrap-ansi": "^7.0.0"
 331 |       },
 332 |       "engines": {
 333 |         "node": ">=12"
 334 |       }
 335 |     },
 336 |     "node_modules/color-convert": {
 337 |       "version": "2.0.1",
 338 |       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
 339 |       "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
 340 |       "license": "MIT",
 341 |       "dependencies": {
 342 |         "color-name": "~1.1.4"
 343 |       },
 344 |       "engines": {
 345 |         "node": ">=7.0.0"
 346 |       }
 347 |     },
 348 |     "node_modules/color-name": {
 349 |       "version": "1.1.4",
 350 |       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
 351 |       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
 352 |       "license": "MIT"
 353 |     },
 354 |     "node_modules/commander": {
 355 |       "version": "13.1.0",
 356 |       "resolved": "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz",
 357 |       "integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==",
 358 |       "license": "MIT",
 359 |       "engines": {
 360 |         "node": ">=18"
 361 |       }
 362 |     },
 363 |     "node_modules/cosmiconfig": {
 364 |       "version": "9.0.0",
 365 |       "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-9.0.0.tgz",
 366 |       "integrity": "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==",
 367 |       "license": "MIT",
 368 |       "dependencies": {
 369 |         "env-paths": "^2.2.1",
 370 |         "import-fresh": "^3.3.0",
 371 |         "js-yaml": "^4.1.0",
 372 |         "parse-json": "^5.2.0"
 373 |       },
 374 |       "engines": {
 375 |         "node": ">=14"
 376 |       },
 377 |       "funding": {
 378 |         "url": "https://github.com/sponsors/d-fischer"
 379 |       },
 380 |       "peerDependencies": {
 381 |         "typescript": ">=4.9.5"
 382 |       },
 383 |       "peerDependenciesMeta": {
 384 |         "typescript": {
 385 |           "optional": true
 386 |         }
 387 |       }
 388 |     },
 389 |     "node_modules/css-doodle": {
 390 |       "version": "0.42.2",
 391 |       "resolved": "https://registry.npmjs.org/css-doodle/-/css-doodle-0.42.2.tgz",
 392 |       "integrity": "sha512-EYsqWYaboQRlsy3X+5P3jLCE2ekR4U6jNTPnzSYqaHCkOY0scBHUefyaIOG8Rfc9rVgQLorn2TNIZLBAVng3Vg==",
 393 |       "license": "MIT",
 394 |       "funding": {
 395 |         "type": "opencollective",
 396 |         "url": "https://opencollective.com/css-doodle"
 397 |       }
 398 |     },
 399 |     "node_modules/data-uri-to-buffer": {
 400 |       "version": "6.0.2",
 401 |       "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
 402 |       "integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
 403 |       "license": "MIT",
 404 |       "engines": {
 405 |         "node": ">= 14"
 406 |       }
 407 |     },
 408 |     "node_modules/debug": {
 409 |       "version": "4.4.0",
 410 |       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
 411 |       "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
 412 |       "license": "MIT",
 413 |       "dependencies": {
 414 |         "ms": "^2.1.3"
 415 |       },
 416 |       "engines": {
 417 |         "node": ">=6.0"
 418 |       },
 419 |       "peerDependenciesMeta": {
 420 |         "supports-color": {
 421 |           "optional": true
 422 |         }
 423 |       }
 424 |     },
 425 |     "node_modules/degenerator": {
 426 |       "version": "5.0.1",
 427 |       "resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
 428 |       "integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
 429 |       "license": "MIT",
 430 |       "dependencies": {
 431 |         "ast-types": "^0.13.4",
 432 |         "escodegen": "^2.1.0",
 433 |         "esprima": "^4.0.1"
 434 |       },
 435 |       "engines": {
 436 |         "node": ">= 14"
 437 |       }
 438 |     },
 439 |     "node_modules/devtools-protocol": {
 440 |       "version": "0.0.1425554",
 441 |       "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1425554.tgz",
 442 |       "integrity": "sha512-uRfxR6Nlzdzt0ihVIkV+sLztKgs7rgquY/Mhcv1YNCWDh5IZgl5mnn2aeEnW5stYTE0wwiF4RYVz8eMEpV1SEw==",
 443 |       "license": "BSD-3-Clause"
 444 |     },
 445 |     "node_modules/emoji-regex": {
 446 |       "version": "8.0.0",
 447 |       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
 448 |       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
 449 |       "license": "MIT"
 450 |     },
 451 |     "node_modules/end-of-stream": {
 452 |       "version": "1.4.4",
 453 |       "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
 454 |       "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
 455 |       "license": "MIT",
 456 |       "dependencies": {
 457 |         "once": "^1.4.0"
 458 |       }
 459 |     },
 460 |     "node_modules/env-paths": {
 461 |       "version": "2.2.1",
 462 |       "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
 463 |       "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
 464 |       "license": "MIT",
 465 |       "engines": {
 466 |         "node": ">=6"
 467 |       }
 468 |     },
 469 |     "node_modules/error-ex": {
 470 |       "version": "1.3.2",
 471 |       "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
 472 |       "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
 473 |       "license": "MIT",
 474 |       "dependencies": {
 475 |         "is-arrayish": "^0.2.1"
 476 |       }
 477 |     },
 478 |     "node_modules/escalade": {
 479 |       "version": "3.2.0",
 480 |       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
 481 |       "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
 482 |       "license": "MIT",
 483 |       "engines": {
 484 |         "node": ">=6"
 485 |       }
 486 |     },
 487 |     "node_modules/escape-string-regexp": {
 488 |       "version": "1.0.5",
 489 |       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
 490 |       "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
 491 |       "license": "MIT",
 492 |       "engines": {
 493 |         "node": ">=0.8.0"
 494 |       }
 495 |     },
 496 |     "node_modules/escodegen": {
 497 |       "version": "2.1.0",
 498 |       "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
 499 |       "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
 500 |       "license": "BSD-2-Clause",
 501 |       "dependencies": {
 502 |         "esprima": "^4.0.1",
 503 |         "estraverse": "^5.2.0",
 504 |         "esutils": "^2.0.2"
 505 |       },
 506 |       "bin": {
 507 |         "escodegen": "bin/escodegen.js",
 508 |         "esgenerate": "bin/esgenerate.js"
 509 |       },
 510 |       "engines": {
 511 |         "node": ">=6.0"
 512 |       },
 513 |       "optionalDependencies": {
 514 |         "source-map": "~0.6.1"
 515 |       }
 516 |     },
 517 |     "node_modules/esprima": {
 518 |       "version": "4.0.1",
 519 |       "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
 520 |       "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
 521 |       "license": "BSD-2-Clause",
 522 |       "bin": {
 523 |         "esparse": "bin/esparse.js",
 524 |         "esvalidate": "bin/esvalidate.js"
 525 |       },
 526 |       "engines": {
 527 |         "node": ">=4"
 528 |       }
 529 |     },
 530 |     "node_modules/estraverse": {
 531 |       "version": "5.3.0",
 532 |       "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
 533 |       "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
 534 |       "license": "BSD-2-Clause",
 535 |       "engines": {
 536 |         "node": ">=4.0"
 537 |       }
 538 |     },
 539 |     "node_modules/esutils": {
 540 |       "version": "2.0.3",
 541 |       "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
 542 |       "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
 543 |       "license": "BSD-2-Clause",
 544 |       "engines": {
 545 |         "node": ">=0.10.0"
 546 |       }
 547 |     },
 548 |     "node_modules/extract-zip": {
 549 |       "version": "2.0.1",
 550 |       "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
 551 |       "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
 552 |       "license": "BSD-2-Clause",
 553 |       "dependencies": {
 554 |         "debug": "^4.1.1",
 555 |         "get-stream": "^5.1.0",
 556 |         "yauzl": "^2.10.0"
 557 |       },
 558 |       "bin": {
 559 |         "extract-zip": "cli.js"
 560 |       },
 561 |       "engines": {
 562 |         "node": ">= 10.17.0"
 563 |       },
 564 |       "optionalDependencies": {
 565 |         "@types/yauzl": "^2.9.1"
 566 |       }
 567 |     },
 568 |     "node_modules/fast-fifo": {
 569 |       "version": "1.3.2",
 570 |       "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
 571 |       "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
 572 |       "license": "MIT"
 573 |     },
 574 |     "node_modules/fd-slicer": {
 575 |       "version": "1.1.0",
 576 |       "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
 577 |       "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
 578 |       "license": "MIT",
 579 |       "dependencies": {
 580 |         "pend": "~1.2.0"
 581 |       }
 582 |     },
 583 |     "node_modules/get-caller-file": {
 584 |       "version": "2.0.5",
 585 |       "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
 586 |       "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
 587 |       "license": "ISC",
 588 |       "engines": {
 589 |         "node": "6.* || 8.* || >= 10.*"
 590 |       }
 591 |     },
 592 |     "node_modules/get-stream": {
 593 |       "version": "5.2.0",
 594 |       "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
 595 |       "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
 596 |       "license": "MIT",
 597 |       "dependencies": {
 598 |         "pump": "^3.0.0"
 599 |       },
 600 |       "engines": {
 601 |         "node": ">=8"
 602 |       },
 603 |       "funding": {
 604 |         "url": "https://github.com/sponsors/sindresorhus"
 605 |       }
 606 |     },
 607 |     "node_modules/get-uri": {
 608 |       "version": "6.0.4",
 609 |       "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.4.tgz",
 610 |       "integrity": "sha512-E1b1lFFLvLgak2whF2xDBcOy6NLVGZBqqjJjsIhvopKfWWEi64pLVTWWehV8KlLerZkfNTA95sTe2OdJKm1OzQ==",
 611 |       "license": "MIT",
 612 |       "dependencies": {
 613 |         "basic-ftp": "^5.0.2",
 614 |         "data-uri-to-buffer": "^6.0.2",
 615 |         "debug": "^4.3.4"
 616 |       },
 617 |       "engines": {
 618 |         "node": ">= 14"
 619 |       }
 620 |     },
 621 |     "node_modules/has-flag": {
 622 |       "version": "3.0.0",
 623 |       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
 624 |       "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
 625 |       "license": "MIT",
 626 |       "engines": {
 627 |         "node": ">=4"
 628 |       }
 629 |     },
 630 |     "node_modules/http-proxy-agent": {
 631 |       "version": "7.0.2",
 632 |       "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
 633 |       "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
 634 |       "license": "MIT",
 635 |       "dependencies": {
 636 |         "agent-base": "^7.1.0",
 637 |         "debug": "^4.3.4"
 638 |       },
 639 |       "engines": {
 640 |         "node": ">= 14"
 641 |       }
 642 |     },
 643 |     "node_modules/https-proxy-agent": {
 644 |       "version": "7.0.6",
 645 |       "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
 646 |       "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
 647 |       "license": "MIT",
 648 |       "dependencies": {
 649 |         "agent-base": "^7.1.2",
 650 |         "debug": "4"
 651 |       },
 652 |       "engines": {
 653 |         "node": ">= 14"
 654 |       }
 655 |     },
 656 |     "node_modules/import-fresh": {
 657 |       "version": "3.3.0",
 658 |       "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",
 659 |       "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==",
 660 |       "license": "MIT",
 661 |       "dependencies": {
 662 |         "parent-module": "^1.0.0",
 663 |         "resolve-from": "^4.0.0"
 664 |       },
 665 |       "engines": {
 666 |         "node": ">=6"
 667 |       },
 668 |       "funding": {
 669 |         "url": "https://github.com/sponsors/sindresorhus"
 670 |       }
 671 |     },
 672 |     "node_modules/ip-address": {
 673 |       "version": "9.0.5",
 674 |       "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz",
 675 |       "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==",
 676 |       "license": "MIT",
 677 |       "dependencies": {
 678 |         "jsbn": "1.1.0",
 679 |         "sprintf-js": "^1.1.3"
 680 |       },
 681 |       "engines": {
 682 |         "node": ">= 12"
 683 |       }
 684 |     },
 685 |     "node_modules/is-arrayish": {
 686 |       "version": "0.2.1",
 687 |       "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
 688 |       "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
 689 |       "license": "MIT"
 690 |     },
 691 |     "node_modules/is-fullwidth-code-point": {
 692 |       "version": "3.0.0",
 693 |       "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
 694 |       "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
 695 |       "license": "MIT",
 696 |       "engines": {
 697 |         "node": ">=8"
 698 |       }
 699 |     },
 700 |     "node_modules/js-tokens": {
 701 |       "version": "4.0.0",
 702 |       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
 703 |       "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
 704 |       "license": "MIT"
 705 |     },
 706 |     "node_modules/js-yaml": {
 707 |       "version": "4.1.0",
 708 |       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
 709 |       "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
 710 |       "license": "MIT",
 711 |       "dependencies": {
 712 |         "argparse": "^2.0.1"
 713 |       },
 714 |       "bin": {
 715 |         "js-yaml": "bin/js-yaml.js"
 716 |       }
 717 |     },
 718 |     "node_modules/jsbn": {
 719 |       "version": "1.1.0",
 720 |       "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz",
 721 |       "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==",
 722 |       "license": "MIT"
 723 |     },
 724 |     "node_modules/json-parse-even-better-errors": {
 725 |       "version": "2.3.1",
 726 |       "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
 727 |       "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
 728 |       "license": "MIT"
 729 |     },
 730 |     "node_modules/lines-and-columns": {
 731 |       "version": "1.2.4",
 732 |       "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
 733 |       "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
 734 |       "license": "MIT"
 735 |     },
 736 |     "node_modules/lru-cache": {
 737 |       "version": "7.18.3",
 738 |       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
 739 |       "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
 740 |       "license": "ISC",
 741 |       "engines": {
 742 |         "node": ">=12"
 743 |       }
 744 |     },
 745 |     "node_modules/mitt": {
 746 |       "version": "3.0.1",
 747 |       "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
 748 |       "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
 749 |       "license": "MIT"
 750 |     },
 751 |     "node_modules/ms": {
 752 |       "version": "2.1.3",
 753 |       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
 754 |       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
 755 |       "license": "MIT"
 756 |     },
 757 |     "node_modules/netmask": {
 758 |       "version": "2.0.2",
 759 |       "resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz",
 760 |       "integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==",
 761 |       "license": "MIT",
 762 |       "engines": {
 763 |         "node": ">= 0.4.0"
 764 |       }
 765 |     },
 766 |     "node_modules/node-watch": {
 767 |       "version": "0.7.4",
 768 |       "resolved": "https://registry.npmjs.org/node-watch/-/node-watch-0.7.4.tgz",
 769 |       "integrity": "sha512-RinNxoz4W1cep1b928fuFhvAQ5ag/+1UlMDV7rbyGthBIgsiEouS4kvRayvvboxii4m8eolKOIBo3OjDqbc+uQ==",
 770 |       "license": "MIT",
 771 |       "engines": {
 772 |         "node": ">=6"
 773 |       }
 774 |     },
 775 |     "node_modules/once": {
 776 |       "version": "1.4.0",
 777 |       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
 778 |       "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
 779 |       "license": "ISC",
 780 |       "dependencies": {
 781 |         "wrappy": "1"
 782 |       }
 783 |     },
 784 |     "node_modules/pac-proxy-agent": {
 785 |       "version": "7.2.0",
 786 |       "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
 787 |       "integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
 788 |       "license": "MIT",
 789 |       "dependencies": {
 790 |         "@tootallnate/quickjs-emscripten": "^0.23.0",
 791 |         "agent-base": "^7.1.2",
 792 |         "debug": "^4.3.4",
 793 |         "get-uri": "^6.0.1",
 794 |         "http-proxy-agent": "^7.0.0",
 795 |         "https-proxy-agent": "^7.0.6",
 796 |         "pac-resolver": "^7.0.1",
 797 |         "socks-proxy-agent": "^8.0.5"
 798 |       },
 799 |       "engines": {
 800 |         "node": ">= 14"
 801 |       }
 802 |     },
 803 |     "node_modules/pac-resolver": {
 804 |       "version": "7.0.1",
 805 |       "resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
 806 |       "integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
 807 |       "license": "MIT",
 808 |       "dependencies": {
 809 |         "degenerator": "^5.0.0",
 810 |         "netmask": "^2.0.2"
 811 |       },
 812 |       "engines": {
 813 |         "node": ">= 14"
 814 |       }
 815 |     },
 816 |     "node_modules/parent-module": {
 817 |       "version": "1.0.1",
 818 |       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
 819 |       "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
 820 |       "license": "MIT",
 821 |       "dependencies": {
 822 |         "callsites": "^3.0.0"
 823 |       },
 824 |       "engines": {
 825 |         "node": ">=6"
 826 |       }
 827 |     },
 828 |     "node_modules/parse-json": {
 829 |       "version": "5.2.0",
 830 |       "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
 831 |       "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
 832 |       "license": "MIT",
 833 |       "dependencies": {
 834 |         "@babel/code-frame": "^7.0.0",
 835 |         "error-ex": "^1.3.1",
 836 |         "json-parse-even-better-errors": "^2.3.0",
 837 |         "lines-and-columns": "^1.1.6"
 838 |       },
 839 |       "engines": {
 840 |         "node": ">=8"
 841 |       },
 842 |       "funding": {
 843 |         "url": "https://github.com/sponsors/sindresorhus"
 844 |       }
 845 |     },
 846 |     "node_modules/pend": {
 847 |       "version": "1.2.0",
 848 |       "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
 849 |       "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
 850 |       "license": "MIT"
 851 |     },
 852 |     "node_modules/picocolors": {
 853 |       "version": "1.1.0",
 854 |       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
 855 |       "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
 856 |       "license": "ISC"
 857 |     },
 858 |     "node_modules/progress": {
 859 |       "version": "2.0.3",
 860 |       "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
 861 |       "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
 862 |       "license": "MIT",
 863 |       "engines": {
 864 |         "node": ">=0.4.0"
 865 |       }
 866 |     },
 867 |     "node_modules/proxy-agent": {
 868 |       "version": "6.5.0",
 869 |       "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
 870 |       "integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
 871 |       "license": "MIT",
 872 |       "dependencies": {
 873 |         "agent-base": "^7.1.2",
 874 |         "debug": "^4.3.4",
 875 |         "http-proxy-agent": "^7.0.1",
 876 |         "https-proxy-agent": "^7.0.6",
 877 |         "lru-cache": "^7.14.1",
 878 |         "pac-proxy-agent": "^7.1.0",
 879 |         "proxy-from-env": "^1.1.0",
 880 |         "socks-proxy-agent": "^8.0.5"
 881 |       },
 882 |       "engines": {
 883 |         "node": ">= 14"
 884 |       }
 885 |     },
 886 |     "node_modules/proxy-from-env": {
 887 |       "version": "1.1.0",
 888 |       "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
 889 |       "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
 890 |       "license": "MIT"
 891 |     },
 892 |     "node_modules/pump": {
 893 |       "version": "3.0.2",
 894 |       "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.2.tgz",
 895 |       "integrity": "sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==",
 896 |       "license": "MIT",
 897 |       "dependencies": {
 898 |         "end-of-stream": "^1.1.0",
 899 |         "once": "^1.3.1"
 900 |       }
 901 |     },
 902 |     "node_modules/puppeteer": {
 903 |       "version": "24.6.1",
 904 |       "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-24.6.1.tgz",
 905 |       "integrity": "sha512-/4ocGfu8LNvDbWUqJZV2VmwEWpbOdJa69y2Jivd213tV0ekAtUh/bgT1hhW63SDN/CtrEucOPwoomZ+9M+eBEg==",
 906 |       "hasInstallScript": true,
 907 |       "license": "Apache-2.0",
 908 |       "dependencies": {
 909 |         "@puppeteer/browsers": "2.10.0",
 910 |         "chromium-bidi": "3.0.0",
 911 |         "cosmiconfig": "^9.0.0",
 912 |         "devtools-protocol": "0.0.1425554",
 913 |         "puppeteer-core": "24.6.1",
 914 |         "typed-query-selector": "^2.12.0"
 915 |       },
 916 |       "bin": {
 917 |         "puppeteer": "lib/cjs/puppeteer/node/cli.js"
 918 |       },
 919 |       "engines": {
 920 |         "node": ">=18"
 921 |       }
 922 |     },
 923 |     "node_modules/puppeteer-core": {
 924 |       "version": "24.6.1",
 925 |       "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.6.1.tgz",
 926 |       "integrity": "sha512-sMCxsY+OPWO2fecBrhIeCeJbWWXJ6UaN997sTid6whY0YT9XM0RnxEwLeUibluIS5/fRmuxe1efjb5RMBsky7g==",
 927 |       "license": "Apache-2.0",
 928 |       "dependencies": {
 929 |         "@puppeteer/browsers": "2.10.0",
 930 |         "chromium-bidi": "3.0.0",
 931 |         "debug": "^4.4.0",
 932 |         "devtools-protocol": "0.0.1425554",
 933 |         "typed-query-selector": "^2.12.0",
 934 |         "ws": "^8.18.1"
 935 |       },
 936 |       "engines": {
 937 |         "node": ">=18"
 938 |       }
 939 |     },
 940 |     "node_modules/require-directory": {
 941 |       "version": "2.1.1",
 942 |       "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
 943 |       "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
 944 |       "license": "MIT",
 945 |       "engines": {
 946 |         "node": ">=0.10.0"
 947 |       }
 948 |     },
 949 |     "node_modules/resolve-from": {
 950 |       "version": "4.0.0",
 951 |       "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
 952 |       "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
 953 |       "license": "MIT",
 954 |       "engines": {
 955 |         "node": ">=4"
 956 |       }
 957 |     },
 958 |     "node_modules/semver": {
 959 |       "version": "7.7.1",
 960 |       "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz",
 961 |       "integrity": "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==",
 962 |       "license": "ISC",
 963 |       "bin": {
 964 |         "semver": "bin/semver.js"
 965 |       },
 966 |       "engines": {
 967 |         "node": ">=10"
 968 |       }
 969 |     },
 970 |     "node_modules/smart-buffer": {
 971 |       "version": "4.2.0",
 972 |       "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
 973 |       "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
 974 |       "license": "MIT",
 975 |       "engines": {
 976 |         "node": ">= 6.0.0",
 977 |         "npm": ">= 3.0.0"
 978 |       }
 979 |     },
 980 |     "node_modules/socks": {
 981 |       "version": "2.8.4",
 982 |       "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.4.tgz",
 983 |       "integrity": "sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==",
 984 |       "license": "MIT",
 985 |       "dependencies": {
 986 |         "ip-address": "^9.0.5",
 987 |         "smart-buffer": "^4.2.0"
 988 |       },
 989 |       "engines": {
 990 |         "node": ">= 10.0.0",
 991 |         "npm": ">= 3.0.0"
 992 |       }
 993 |     },
 994 |     "node_modules/socks-proxy-agent": {
 995 |       "version": "8.0.5",
 996 |       "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
 997 |       "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
 998 |       "license": "MIT",
 999 |       "dependencies": {
1000 |         "agent-base": "^7.1.2",
1001 |         "debug": "^4.3.4",
1002 |         "socks": "^2.8.3"
1003 |       },
1004 |       "engines": {
1005 |         "node": ">= 14"
1006 |       }
1007 |     },
1008 |     "node_modules/source-map": {
1009 |       "version": "0.6.1",
1010 |       "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
1011 |       "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
1012 |       "license": "BSD-3-Clause",
1013 |       "optional": true,
1014 |       "engines": {
1015 |         "node": ">=0.10.0"
1016 |       }
1017 |     },
1018 |     "node_modules/sprintf-js": {
1019 |       "version": "1.1.3",
1020 |       "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
1021 |       "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
1022 |       "license": "BSD-3-Clause"
1023 |     },
1024 |     "node_modules/streamx": {
1025 |       "version": "2.22.0",
1026 |       "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.22.0.tgz",
1027 |       "integrity": "sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw==",
1028 |       "license": "MIT",
1029 |       "dependencies": {
1030 |         "fast-fifo": "^1.3.2",
1031 |         "text-decoder": "^1.1.0"
1032 |       },
1033 |       "optionalDependencies": {
1034 |         "bare-events": "^2.2.0"
1035 |       }
1036 |     },
1037 |     "node_modules/string-width": {
1038 |       "version": "4.2.3",
1039 |       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
1040 |       "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
1041 |       "license": "MIT",
1042 |       "dependencies": {
1043 |         "emoji-regex": "^8.0.0",
1044 |         "is-fullwidth-code-point": "^3.0.0",
1045 |         "strip-ansi": "^6.0.1"
1046 |       },
1047 |       "engines": {
1048 |         "node": ">=8"
1049 |       }
1050 |     },
1051 |     "node_modules/strip-ansi": {
1052 |       "version": "6.0.1",
1053 |       "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
1054 |       "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
1055 |       "license": "MIT",
1056 |       "dependencies": {
1057 |         "ansi-regex": "^5.0.1"
1058 |       },
1059 |       "engines": {
1060 |         "node": ">=8"
1061 |       }
1062 |     },
1063 |     "node_modules/supports-color": {
1064 |       "version": "5.5.0",
1065 |       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
1066 |       "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
1067 |       "license": "MIT",
1068 |       "dependencies": {
1069 |         "has-flag": "^3.0.0"
1070 |       },
1071 |       "engines": {
1072 |         "node": ">=4"
1073 |       }
1074 |     },
1075 |     "node_modules/tar-fs": {
1076 |       "version": "3.0.8",
1077 |       "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.0.8.tgz",
1078 |       "integrity": "sha512-ZoROL70jptorGAlgAYiLoBLItEKw/fUxg9BSYK/dF/GAGYFJOJJJMvjPAKDJraCXFwadD456FCuvLWgfhMsPwg==",
1079 |       "license": "MIT",
1080 |       "dependencies": {
1081 |         "pump": "^3.0.0",
1082 |         "tar-stream": "^3.1.5"
1083 |       },
1084 |       "optionalDependencies": {
1085 |         "bare-fs": "^4.0.1",
1086 |         "bare-path": "^3.0.0"
1087 |       }
1088 |     },
1089 |     "node_modules/tar-stream": {
1090 |       "version": "3.1.7",
1091 |       "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
1092 |       "integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
1093 |       "license": "MIT",
1094 |       "dependencies": {
1095 |         "b4a": "^1.6.4",
1096 |         "fast-fifo": "^1.2.0",
1097 |         "streamx": "^2.15.0"
1098 |       }
1099 |     },
1100 |     "node_modules/text-decoder": {
1101 |       "version": "1.2.3",
1102 |       "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
1103 |       "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
1104 |       "license": "Apache-2.0",
1105 |       "dependencies": {
1106 |         "b4a": "^1.6.4"
1107 |       }
1108 |     },
1109 |     "node_modules/tslib": {
1110 |       "version": "2.8.1",
1111 |       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
1112 |       "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
1113 |       "license": "0BSD"
1114 |     },
1115 |     "node_modules/typed-query-selector": {
1116 |       "version": "2.12.0",
1117 |       "resolved": "https://registry.npmjs.org/typed-query-selector/-/typed-query-selector-2.12.0.tgz",
1118 |       "integrity": "sha512-SbklCd1F0EiZOyPiW192rrHZzZ5sBijB6xM+cpmrwDqObvdtunOHHIk9fCGsoK5JVIYXoyEp4iEdE3upFH3PAg==",
1119 |       "license": "MIT"
1120 |     },
1121 |     "node_modules/undici-types": {
1122 |       "version": "6.21.0",
1123 |       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
1124 |       "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
1125 |       "license": "MIT",
1126 |       "optional": true
1127 |     },
1128 |     "node_modules/wrap-ansi": {
1129 |       "version": "7.0.0",
1130 |       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
1131 |       "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
1132 |       "license": "MIT",
1133 |       "dependencies": {
1134 |         "ansi-styles": "^4.0.0",
1135 |         "string-width": "^4.1.0",
1136 |         "strip-ansi": "^6.0.0"
1137 |       },
1138 |       "engines": {
1139 |         "node": ">=10"
1140 |       },
1141 |       "funding": {
1142 |         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
1143 |       }
1144 |     },
1145 |     "node_modules/wrappy": {
1146 |       "version": "1.0.2",
1147 |       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
1148 |       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
1149 |       "license": "ISC"
1150 |     },
1151 |     "node_modules/ws": {
1152 |       "version": "8.18.1",
1153 |       "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz",
1154 |       "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==",
1155 |       "license": "MIT",
1156 |       "engines": {
1157 |         "node": ">=10.0.0"
1158 |       },
1159 |       "peerDependencies": {
1160 |         "bufferutil": "^4.0.1",
1161 |         "utf-8-validate": ">=5.0.2"
1162 |       },
1163 |       "peerDependenciesMeta": {
1164 |         "bufferutil": {
1165 |           "optional": true
1166 |         },
1167 |         "utf-8-validate": {
1168 |           "optional": true
1169 |         }
1170 |       }
1171 |     },
1172 |     "node_modules/y18n": {
1173 |       "version": "5.0.8",
1174 |       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
1175 |       "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
1176 |       "license": "ISC",
1177 |       "engines": {
1178 |         "node": ">=10"
1179 |       }
1180 |     },
1181 |     "node_modules/yargs": {
1182 |       "version": "17.7.2",
1183 |       "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
1184 |       "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
1185 |       "license": "MIT",
1186 |       "dependencies": {
1187 |         "cliui": "^8.0.1",
1188 |         "escalade": "^3.1.1",
1189 |         "get-caller-file": "^2.0.5",
1190 |         "require-directory": "^2.1.1",
1191 |         "string-width": "^4.2.3",
1192 |         "y18n": "^5.0.5",
1193 |         "yargs-parser": "^21.1.1"
1194 |       },
1195 |       "engines": {
1196 |         "node": ">=12"
1197 |       }
1198 |     },
1199 |     "node_modules/yargs-parser": {
1200 |       "version": "21.1.1",
1201 |       "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
1202 |       "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
1203 |       "license": "ISC",
1204 |       "engines": {
1205 |         "node": ">=12"
1206 |       }
1207 |     },
1208 |     "node_modules/yauzl": {
1209 |       "version": "2.10.0",
1210 |       "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
1211 |       "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
1212 |       "license": "MIT",
1213 |       "dependencies": {
1214 |         "buffer-crc32": "~0.2.3",
1215 |         "fd-slicer": "~1.1.0"
1216 |       }
1217 |     },
1218 |     "node_modules/zod": {
1219 |       "version": "3.24.2",
1220 |       "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz",
1221 |       "integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==",
1222 |       "license": "MIT",
1223 |       "funding": {
1224 |         "url": "https://github.com/sponsors/colinhacks"
1225 |       }
1226 |     }
1227 |   }
1228 | }
1229 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@css-doodle/cli",
 3 |   "version": "1.6.1",
 4 |   "description": "Command-line tool for css-doodle to preview and generate images/videos",
 5 |   "bin": {
 6 |     "css-doodle": "bin/index.js",
 7 |     "cssd": "bin/index.js"
 8 |   },
 9 |   "scripts": {
10 |     "test": "echo \"Error: no test specified\" && exit 1"
11 |   },
12 |   "repository": {
13 |     "type": "git",
14 |     "url": "git+https://github.com/css-doodle/cli.git"
15 |   },
16 |   "funding": {
17 |     "type": "opencollective",
18 |     "url": "https://opencollective.com/css-doodle"
19 |   },
20 |   "keywords": [
21 |     "css-doodle"
22 |   ],
23 |   "files": [
24 |     "bin",
25 |     "lib"
26 |   ],
27 |   "author": "yuanchuan",
28 |   "license": "MIT",
29 |   "bugs": {
30 |     "url": "https://github.com/css-doodle/cli/issues"
31 |   },
32 |   "publishConfig": {
33 |     "access": "public"
34 |   },
35 |   "homepage": "https://github.com/css-doodle/cli#readme",
36 |   "type": "module",
37 |   "engines": {
38 |     "node": ">= 20.11.0"
39 |   },
40 |   "dependencies": {
41 |     "commander": "^13.1.0",
42 |     "css-doodle": "^0.42.2",
43 |     "node-watch": "^0.7.4",
44 |     "puppeteer": "^v24.6.1",
45 |     "ws": "^8.18.1"
46 |   },
47 |   "devDependencies": {}
48 | }
49 | 


--------------------------------------------------------------------------------
/screenshot/preview.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/css-doodle/cli/2674f987ce245ee0a86ddcb59ed772d590349a16/screenshot/preview.png


--------------------------------------------------------------------------------