devbrain-cli 0.1.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/to-regex-range/index.js

@@ -0,0 +1,288 @@
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+const isNumber = require('is-number');
+
+const toRegexRange = (min, max, options) => {
+  if (isNumber(min) === false) {
+    throw new TypeError('toRegexRange: expected the first argument to be a number');
+  }
+
+  if (max === void 0 || min === max) {
+    return String(min);
+  }
+
+  if (isNumber(max) === false) {
+    throw new TypeError('toRegexRange: expected the second argument to be a number.');
+  }
+
+  let opts = { relaxZeros: true, ...options };
+  if (typeof opts.strictZeros === 'boolean') {
+    opts.relaxZeros = opts.strictZeros === false;
+  }
+
+  let relax = String(opts.relaxZeros);
+  let shorthand = String(opts.shorthand);
+  let capture = String(opts.capture);
+  let wrap = String(opts.wrap);
+  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+
+  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+    return toRegexRange.cache[cacheKey].result;
+  }
+
+  let a = Math.min(min, max);
+  let b = Math.max(min, max);
+
+  if (Math.abs(a - b) === 1) {
+    let result = min + '|' + max;
+    if (opts.capture) {
+      return `(${result})`;
+    }
+    if (opts.wrap === false) {
+      return result;
+    }
+    return `(?:${result})`;
+  }
+
+  let isPadded = hasPadding(min) || hasPadding(max);
+  let state = { min, max, a, b };
+  let positives = [];
+  let negatives = [];
+
+  if (isPadded) {
+    state.isPadded = isPadded;
+    state.maxLen = String(state.max).length;
+  }
+
+  if (a < 0) {
+    let newMin = b < 0 ? Math.abs(b) : 1;
+    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+    a = state.a = 0;
+  }
+
+  if (b >= 0) {
+    positives = splitToPatterns(a, b, state, opts);
+  }
+
+  state.negatives = negatives;
+  state.positives = positives;
+  state.result = collatePatterns(negatives, positives, opts);
+
+  if (opts.capture === true) {
+    state.result = `(${state.result})`;
+  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+    state.result = `(?:${state.result})`;
+  }
+
+  toRegexRange.cache[cacheKey] = state;
+  return state.result;
+};
+
+function collatePatterns(neg, pos, options) {
+  let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];
+  let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];
+  let intersected = filterPatterns(neg, pos, '-?', true, options) || [];
+  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+  return subpatterns.join('|');
+}
+
+function splitToRanges(min, max) {
+  let nines = 1;
+  let zeros = 1;
+
+  let stop = countNines(min, nines);
+  let stops = new Set([max]);
+
+  while (min <= stop && stop <= max) {
+    stops.add(stop);
+    nines += 1;
+    stop = countNines(min, nines);
+  }
+
+  stop = countZeros(max + 1, zeros) - 1;
+
+  while (min < stop && stop <= max) {
+    stops.add(stop);
+    zeros += 1;
+    stop = countZeros(max + 1, zeros) - 1;
+  }
+
+  stops = [...stops];
+  stops.sort(compare);
+  return stops;
+}
+
+/**
+ * Convert a range to a regex pattern
+ * @param {Number} `start`
+ * @param {Number} `stop`
+ * @return {String}
+ */
+
+function rangeToPattern(start, stop, options) {
+  if (start === stop) {
+    return { pattern: start, count: [], digits: 0 };
+  }
+
+  let zipped = zip(start, stop);
+  let digits = zipped.length;
+  let pattern = '';
+  let count = 0;
+
+  for (let i = 0; i < digits; i++) {
+    let [startDigit, stopDigit] = zipped[i];
+
+    if (startDigit === stopDigit) {
+      pattern += startDigit;
+
+    } else if (startDigit !== '0' || stopDigit !== '9') {
+      pattern += toCharacterClass(startDigit, stopDigit, options);
+
+    } else {
+      count++;
+    }
+  }
+
+  if (count) {
+    pattern += options.shorthand === true ? '\\d' : '[0-9]';
+  }
+
+  return { pattern, count: [count], digits };
+}
+
+function splitToPatterns(min, max, tok, options) {
+  let ranges = splitToRanges(min, max);
+  let tokens = [];
+  let start = min;
+  let prev;
+
+  for (let i = 0; i < ranges.length; i++) {
+    let max = ranges[i];
+    let obj = rangeToPattern(String(start), String(max), options);
+    let zeros = '';
+
+    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+      if (prev.count.length > 1) {
+        prev.count.pop();
+      }
+
+      prev.count.push(obj.count[0]);
+      prev.string = prev.pattern + toQuantifier(prev.count);
+      start = max + 1;
+      continue;
+    }
+
+    if (tok.isPadded) {
+      zeros = padZeros(max, tok, options);
+    }
+
+    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+    tokens.push(obj);
+    start = max + 1;
+    prev = obj;
+  }
+
+  return tokens;
+}
+
+function filterPatterns(arr, comparison, prefix, intersection, options) {
+  let result = [];
+
+  for (let ele of arr) {
+    let { string } = ele;
+
+    // only push if _both_ are negative...
+    if (!intersection && !contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
+
+    // or _both_ are positive
+    if (intersection && contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
+  }
+  return result;
+}
+
+/**
+ * Zip strings
+ */
+
+function zip(a, b) {
+  let arr = [];
+  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+  return arr;
+}
+
+function compare(a, b) {
+  return a > b ? 1 : b > a ? -1 : 0;
+}
+
+function contains(arr, key, val) {
+  return arr.some(ele => ele[key] === val);
+}
+
+function countNines(min, len) {
+  return Number(String(min).slice(0, -len) + '9'.repeat(len));
+}
+
+function countZeros(integer, zeros) {
+  return integer - (integer % Math.pow(10, zeros));
+}
+
+function toQuantifier(digits) {
+  let [start = 0, stop = ''] = digits;
+  if (stop || start > 1) {
+    return `{${start + (stop ? ',' + stop : '')}}`;
+  }
+  return '';
+}
+
+function toCharacterClass(a, b, options) {
+  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+}
+
+function hasPadding(str) {
+  return /^-?(0+)\d/.test(str);
+}
+
+function padZeros(value, tok, options) {
+  if (!tok.isPadded) {
+    return value;
+  }
+
+  let diff = Math.abs(tok.maxLen - String(value).length);
+  let relax = options.relaxZeros !== false;
+
+  switch (diff) {
+    case 0:
+      return '';
+    case 1:
+      return relax ? '0?' : '0';
+    case 2:
+      return relax ? '0{0,2}' : '00';
+    default: {
+      return relax ? `0{0,${diff}}` : `0{${diff}}`;
+    }
+  }
+}
+
+/**
+ * Cache
+ */
+
+toRegexRange.cache = {};
+toRegexRange.clearCache = () => (toRegexRange.cache = {});
+
+/**
+ * Expose `toRegexRange`
+ */
+
+module.exports = toRegexRange;

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/to-regex-range/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "to-regex-range",
+  "description": "Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.78 million test assertions.",
+  "version": "5.0.1",
+  "homepage": "https://github.com/micromatch/to-regex-range",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "contributors": [
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Rouven Weßling (www.rouvenwessling.de)"
+  ],
+  "repository": "micromatch/to-regex-range",
+  "bugs": {
+    "url": "https://github.com/micromatch/to-regex-range/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=8.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "is-number": "^7.0.0"
+  },
+  "devDependencies": {
+    "fill-range": "^6.0.0",
+    "gulp-format-md": "^2.0.0",
+    "mocha": "^6.0.2",
+    "text-table": "^0.2.0",
+    "time-diff": "^0.3.1"
+  },
+  "keywords": [
+    "bash",
+    "date",
+    "expand",
+    "expansion",
+    "expression",
+    "glob",
+    "match",
+    "match date",
+    "match number",
+    "match numbers",
+    "match year",
+    "matches",
+    "matching",
+    "number",
+    "numbers",
+    "numerical",
+    "range",
+    "ranges",
+    "regex",
+    "regexp",
+    "regular",
+    "regular expression",
+    "sequence"
+  ],
+  "verb": {
+    "layout": "default",
+    "toc": false,
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "lint": {
+      "reflinks": true
+    },
+    "helpers": {
+      "examples": {
+        "displayName": "examples"
+      }
+    },
+    "related": {
+      "list": [
+        "expand-range",
+        "fill-range",
+        "micromatch",
+        "repeat-element",
+        "repeat-string"
+      ]
+    }
+  }
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/xml-naming/README.md

@@ -0,0 +1,189 @@
+# xml-naming
+
+Validates XML name productions as defined in the [XML 1.0](https://www.w3.org/TR/xml/) and [XML 1.1](https://www.w3.org/TR/xml11/) specifications.
+
+Covers all five productions:
+
+| Production | Description | Colon | Digit/hyphen start |
+|---|---|---|---|
+| `Name` | General XML name | ✅ | ❌ |
+| `NCName` | Non-Colonized name | ❌ | ❌ |
+| `QName` | Namespace-qualified name (`prefix:local`) | ✅ (one only) | ❌ |
+| `NMToken` | Name token (relaxed start) | ✅ | ✅ |
+| `NMTokens` | Whitespace-separated NMToken list | ✅ | ✅ |
+
+Used internally by [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser), [fast-xml-validator](https://github.com/NaturalIntelligence/fast-xml-validator), [@nodable\flexible-xml-parser](https://github.com/nodable/flexible-xml-parser)  and [fast-svg-parser](https://github.com/amitguptagwl/fast-svg-parser).
+
+---
+
+## Install
+
+```bash
+npm install xml-naming
+```
+
+---
+
+## Usage
+
+### Boolean validators
+
+```js
+import { name, ncName, qName, nmToken, nmTokens } from 'xml-naming';
+
+// Name — colon allowed anywhere, used for DOCTYPE entity names
+name('foo')          // true
+name('a:b:c')        // true  ← multiple colons fine for Name
+name('1foo')         // false ← digit start invalid
+
+// NCName — no colon, used for SVG id attributes, namespace prefixes
+ncName('my-id')      // true
+ncName('xlink:href') // false ← colon not allowed
+
+// QName — exactly one colon as prefix separator, used for element/attribute names
+qName('svg:circle')  // true
+qName('foo')         // true  ← unprefixed QName is valid
+qName('a:b:c')       // false ← only one colon allowed
+qName(':foo')        // false ← cannot start with colon
+
+// NMToken — any NameChar at start, used for DTD NMTOKEN attributes
+nmToken('123')       // true  ← digit start is fine
+nmToken('-bar')      // true
+nmToken('foo bar')   // false ← space not allowed
+
+// NMTokens — whitespace-separated NMToken list
+nmTokens('tok1 tok2 -foo 123')  // true
+```
+
+### XML version option
+
+All validators accept an optional `{ xmlVersion }` option:
+
+```js
+import { name } from 'xml-naming';
+
+name('\u0085', { xmlVersion: '1.0' })  // false — NEL (Next Line), not in 1.0 ranges
+name('\u0085', { xmlVersion: '1.1' })  // true  — explicitly allowed in 1.1
+
+name('\uD800\uDC00', { xmlVersion: '1.0' })  // false
+name('\uD800\uDC00', { xmlVersion: '1.1' })  // true
+```
+
+---
+
+### Diagnostic validation
+
+```js
+import { validate } from 'xml-naming';
+
+validate('svg:circle', 'qName')
+// { valid: true, production: 'qName', input: 'svg:circle' }
+
+validate('1foo', 'ncName')
+// {
+//   valid: false,
+//   production: 'ncName',
+//   input: '1foo',
+//   reason: 'First character "1" is not a valid NameStartChar',
+//   position: 0
+// }
+
+validate('foo:bar', 'ncName')
+// {
+//   valid: false,
+//   production: 'ncName',
+//   input: 'foo:bar',
+//   reason: 'Colon is not allowed in NCName',
+//   position: 3
+// }
+
+validate('a:b:c', 'qName')
+// {
+//   valid: false,
+//   production: 'qName',
+//   input: 'a:b:c',
+//   reason: 'QName can have at most one colon',
+//   position: 3
+// }
+```
+
+---
+
+### Batch validation
+
+```js
+import { validateAll } from 'xml-naming';
+
+validateAll(['svg', 'circle', '123bad', 'xlink:href'], 'ncName')
+// [
+//   { valid: true,  production: 'ncName', input: 'svg' },
+//   { valid: true,  production: 'ncName', input: 'circle' },
+//   { valid: false, production: 'ncName', input: '123bad',    reason: '...', position: 0 },
+//   { valid: false, production: 'ncName', input: 'xlink:href',reason: '...', position: 5 }
+// ]
+```
+
+---
+
+### Sanitize / auto-fix
+
+Useful when generating XML/SVG programmatically from user-supplied strings:
+
+```js
+import { sanitize } from 'xml-naming';
+
+sanitize('123abc',    'ncName')  // '_123abc'   ← digit start fixed
+sanitize('my element','name')   // 'my_element' ← space replaced
+sanitize('foo:bar',   'ncName') // 'foobar'     ← colon stripped
+sanitize('hello!',    'name')   // 'hello_'     ← illegal char replaced
+
+// Custom replacement character
+sanitize('my element', 'name', { replacement: '-' })  // 'my-element'
+```
+
+---
+
+## Which production should I use?
+
+| Context | Production |
+|---|---|
+| XML element/attribute names (namespace-aware) | `qName` |
+| SVG `id` attribute values | `ncName` |
+| Namespace prefix alone | `ncName` |
+| DOCTYPE `<!ENTITY name ...>` | `name` |
+| DOCTYPE `<!NOTATION name ...>` | `name` |
+| DTD `NMTOKEN` attribute values | `nmToken` |
+| DTD `NMTOKENS` attribute values | `nmTokens` |
+
+> **Note:** DOCTYPE entity and notation names must use `Name`, not `QName`. Colons carry no namespace meaning in the DTD subset.
+
+---
+
+## API
+
+### `name(str, opts?)` → `boolean`
+### `ncName(str, opts?)` → `boolean`
+### `qName(str, opts?)` → `boolean`
+### `nmToken(str, opts?)` → `boolean`
+### `nmTokens(str, opts?)` → `boolean`
+
+`opts`:
+- `xmlVersion`: `'1.0'` (default) | `'1.1'`
+
+### `validate(str, production, opts?)` → `ValidationResult`
+
+`production`: `'name'` | `'ncName'` | `'qName'` | `'nmToken'` | `'nmTokens'`
+
+### `validateAll(strings[], production, opts?)` → `ValidationResult[]`
+
+### `sanitize(str, production?, opts?)` → `string`
+
+`opts`:
+- `xmlVersion`: `'1.0'` | `'1.1'`
+- `replacement`: string (default `'_'`)
+
+---
+
+## License
+
+MIT

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/xml-naming/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "xml-naming",
+  "version": "0.1.0",
+  "description": "Validates XML name productions — Name, NCName, QName, NMToken, NMTokens — for XML 1.0 and 1.1",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    }
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jasmine specs/*spec.js"
+  },
+  "keywords": [
+    "xml",
+    "xml-name",
+    "ncname",
+    "qname",
+    "nmtoken",
+    "xml-validation",
+    "xml-namespace",
+    "name-validator",
+    "xml-1.0",
+    "xml-1.1"
+  ],
+  "author": "Amit Gupta (https://solothought.com)",
+  "license": "MIT",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/NaturalIntelligence"
+    }
+  ],
+  "devDependencies": {
+    "jasmine": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NaturalIntelligence/xml-naming"
+  },
+  "bugs": {
+    "url": "https://github.com/NaturalIntelligence/xml-naming/issues"
+  }
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/xml-naming/src/index.d.ts

@@ -0,0 +1,74 @@
+export interface ValidationOptions {
+  /** XML specification version to validate against. Defaults to '1.0'. */
+  xmlVersion?: '1.0' | '1.1';
+}
+
+export interface SanitizeOptions extends ValidationOptions {
+  /** Character used to replace invalid characters. Defaults to '_'. */
+  replacement?: string;
+}
+
+export type Production = 'name' | 'ncName' | 'qName' | 'nmToken' | 'nmTokens';
+
+export interface ValidationResult {
+  valid: boolean;
+  production: Production;
+  input: string;
+  /** Present only when valid is false. */
+  reason?: string;
+  /** Index of the first offending character. Present only when valid is false. */
+  position?: number;
+}
+
+/**
+ * Returns true if the string is a valid XML Name.
+ * Colons are permitted anywhere (Name production).
+ * Used for: DOCTYPE entity names, notation names, DTD element declarations.
+ */
+export function name(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NCName (Non-Colonized Name).
+ * Colons are not permitted.
+ * Used for: namespace prefixes, local names, SVG id attributes.
+ */
+export function ncName(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid QName (Qualified Name).
+ * Allows exactly one colon as a prefix separator: prefix:localName.
+ * Used for: element and attribute names in namespace-aware XML/SVG.
+ */
+export function qName(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NMToken.
+ * Same character set as Name but no restriction on the first character.
+ * Used for: DTD NMTOKEN attribute values.
+ */
+export function nmToken(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NMTokens value.
+ * A whitespace-separated list of NMToken values.
+ * Used for: DTD NMTOKENS attribute values.
+ */
+export function nmTokens(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Validates a string against a named XML production and returns a detailed result.
+ */
+export function validate(str: string, production: Production, opts?: ValidationOptions): ValidationResult;
+
+/**
+ * Validates an array of strings against a named XML production.
+ */
+export function validateAll(strings: string[], production: Production, opts?: ValidationOptions): ValidationResult[];
+
+/**
+ * Transforms an invalid string into the nearest valid XML name for the given production.
+ * - Strips or replaces illegal characters
+ * - Fixes invalid start characters by prepending the replacement character
+ * - Removes colons for NCName production
+ */
+export function sanitize(str: string, production?: Production, opts?: SanitizeOptions): string;