@teammy/server 0.1.5 → 0.1.7

package/node_modules/minimatch/README.md

@@ -1,60 +1,62 @@
 # minimatch
 
-A minimal matching utility.
+A glob matching utility.
 
-This is the matching library used internally by npm.
+This is the matching library used internally by
+[node-glob](https://npm.im/node-glob).
 
-It works by converting glob expressions into JavaScript `RegExp`
-objects.
+It works by splitting glob expressions on `/`, and testing each
+path portion with a `Matcher` from
+[@isaacs/nonrecursive-glob-match](http://npm.im/@isaacs/nonrecursive-glob-match).
 
-## Important Security Consideration!
+## Why Not Regular Expressions?
 
-> [!WARNING]  
-> This library uses JavaScript regular expressions. Please read
-> the following warning carefully, and be thoughtful about what
-> you provide to this library in production systems.
+Regular Expressions are very powerful, and for many applications,
+extremely fast.
 
-_Any_ library in JavaScript that deals with matching string
-patterns using regular expressions will be subject to
+However, in JavaScript, they are subject to
 [ReDoS](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS)
-if the pattern is generated using untrusted input.
+in certain cases. Libraries that assemble Regular Expressions
+from arbitrary input are thus vulnerable to patterns that cause
+pathological behavior. For example, patterns like
+`a*a*a*a*a*a*a*a*a*a*a` when matched against a string like
+`'a'.repeat(50) + 'b'` would have to repeatedly backtrack through
+every failure.
+
+Most other glob matchers in JavaScript (including versions up
+through v10 of this library) convert the glob pattern to Regular
+Expressions, and then use that to test the string. This is fine
+for trusted input, but can fall over badly in cases that cause
+recursive backtracking.
+
+## Important Security Consideration!
 
-Efforts have been made to mitigate risk as much as is feasible in
-such a library, providing maximum recursion depths and so forth,
-but these measures can only ultimately protect against accidents,
-not malice. A dedicated attacker can _always_ find patterns that
-cannot be defended against by a bash-compatible glob pattern
-matching system that uses JavaScript regular expressions.
+Though this library is _not_ vulnerable to ReDOS, _any_ library
+that performs pattern matching based on arbitrary input will
+potentially have edge cases where it performs suboptimally.
 
 To be extremely clear:
 
 > [!WARNING]  
 > **If you create a system where you take user input, and use
-> that input as the source of a Regular Expression pattern, in
-> this or any extant glob matcher in JavaScript, you will be
-> pwned.**
-
-A future version of this library _may_ use a different matching
-algorithm which does not exhibit backtracking problems. If and
-when that happens, it will likely be a sweeping change, and those
-improvements will **not** be backported to legacy versions.
+> that input as the source of a pattern matcher, in this or any
+> extant glob matcher in JavaScript, you may be pwned.**
 
-In the near term, it is not reasonable to continue to play
-whack-a-mole with security advisories, and so any future ReDoS
-reports will be considered "working as intended", and resolved
-entirely by this warning.
+The pattern matching library that Minimatch uses in v11 and above
+will not be backported to earlier versions. It is a much too deep
+of a change to do so.
 
 ## Usage
 
-```js
+```ts
 // hybrid module, load with require() or import
 import { minimatch } from 'minimatch'
 // or:
-const { minimatch } = require('minimatch')
+// const { minimatch } = require('minimatch')
 
 minimatch('bar.foo', '*.foo') // true!
 minimatch('bar.foo', '*.bar') // false!
-minimatch('bar.foo', '*.+(bar|foo)', { debug: true }) // true, and noisy!
+minimatch('bar.foo', '*.+(bar|foo)') // true!
 ```
 
 ## Features
@@ -112,6 +114,14 @@ On Windows, UNC paths like `//?/c:/...` or
   present when the drive letters are a case-insensitive match to
   one another. The remaining portions of the path/pattern are
   compared case sensitively, unless `nocase:true` is set.
+- The host and share of a pattern starting with
+  `//<host>/<share>/...` are compared case-insensitively with
+  those of the file path, if neither has magic. For example,
+  `//host/share/*` matches `//HOST/SHARE/x`.
+- Patterns starting with `//?/UNC/<host>/<share>/...` will match
+  file paths starting with `//<host>/<share>/...`, and vice
+  versa, the same as `//?/<drive letter>:`. The `?` is not a
+  wildcard character.
 
 Note that specifying a UNC path using `\` characters as path
 separators is always allowed in the file path argument, but only
@@ -123,15 +133,15 @@ is set in the options.
 Create a minimatch object by instantiating the `minimatch.Minimatch` class.
 
 ```javascript
-var Minimatch = require('minimatch').Minimatch
-var mm = new Minimatch(pattern, options)
+import { Minimatch } from 'minimatch'
+const mm = new Minimatch(pattern, options)
 ```
 
 ### Properties
 
 - `pattern` The original pattern the minimatch object represents.
 - `options` The options supplied to the constructor.
-- `set` A 2-dimensional array of regexp or string expressions.
+- `set` A 2-dimensional array of `Matcher` or string expressions.
   Each row in the
   array corresponds to a brace-expanded pattern. Each item in the row
   corresponds to a single path-part. For example, the pattern
@@ -142,26 +152,16 @@ var mm = new Minimatch(pattern, options)
 
   If a portion of the pattern doesn't have any "magic" in it
   (that is, it's something like `"foo"` rather than `fo*o?`), then it
-  will be left as a string rather than converted to a regular
-  expression.
+  will be left as a string rather than converted to a `Matcher`.
 
-- `regexp` Created by the `makeRe` method. A single regular expression
-  expressing the entire pattern. This is useful in cases where you wish
-  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
 - `negate` True if the pattern is negated.
 - `comment` True if the pattern is a comment.
 - `empty` True if the pattern is `""`.
 
 ### Methods
 
-- `makeRe()` Generate the `regexp` member if necessary, and return it.
-  Will return `false` if the pattern is invalid.
 - `match(fname)` Return true if the filename matches the pattern, or
   false otherwise.
-- `matchOne(fileArray, patternArray, partial)` Take a `/`-split
-  filename, and match it against a single row in the `regExpSet`. This
-  method is mainly for internal use, but is exposed so that it can be
-  used by a glob-walker that needs to avoid excessive filesystem calls.
 - `hasMagic()` Returns true if the parsed pattern contains any
   magic characters. Returns false if all comparator parts are
   string literals. If the `magicalBraces` option is set on the
@@ -185,16 +185,21 @@ All other methods are internal, and will be called as necessary.
 Main export. Tests a path against the pattern using the options.
 
 ```javascript
-var isJS = minimatch(file, '*.js', { matchBase: true })
+const isJS = minimatch(file, '*.js', { matchBase: true })
 ```
 
+It keeps the 256 `Minimatch` objects that it used most recently,
+so a pattern that it tests again with the same options is not
+compiled again. To test many paths against one pattern, a
+`Minimatch` object or `minimatch.filter()` is still a bit faster.
+
 ### minimatch.filter(pattern, options)
 
 Returns a function that tests its
 supplied argument, suitable for use with `Array.filter`. Example:
 
 ```javascript
-var javascripts = fileList.filter(
+const javascripts = fileList.filter(
   minimatch.filter('*.js', { matchBase: true }),
 )
 ```
@@ -234,21 +239,13 @@ files, in the style of fnmatch or glob. If nothing is matched, and
 options.nonull is set, then return a list containing the pattern itself.
 
 ```javascript
-var javascripts = minimatch.match(fileList, '*.js', { matchBase: true })
+const javascripts = minimatch.match(fileList, '*.js', { matchBase: true })
 ```
 
-### minimatch.makeRe(pattern, options)
-
-Make a regular expression object from the pattern.
-
 ## Options
 
 All options are `false` by default.
 
-### debug
-
-Dump a ton of stuff to stderr.
-
 ### nobrace
 
 Do not expand `{a,b}` and `{1..3}` brace sets.
@@ -271,11 +268,14 @@ Disable "extglob" style patterns like `+(a|b)`.
 
 ### nocase
 
-Perform a case-insensitive match.
+Perform a case-insensitive match. Case is folded one code point at
+a time, with Unicode simple case folding. See [Comparisons to other
+fnmatch/glob
+implementations](#comparisons-to-other-fnmatchglob-implementations).
 
 ### nocaseMagicOnly
 
-When used with `{nocase: true}`, create regular expressions that
+When used with `{nocase: true}`, create matchers that
 are case-insensitive, but leave string match portions untouched.
 Has no effect when used without `{nocase: true}`.
 
@@ -283,6 +283,28 @@ Useful when some other form of case-insensitive matching is used,
 or if the original string representation is useful in some other
 way.
 
+### normalize
+
+Normalize unicode in the pattern, and in each portion of the tested
+path, with this form: `'NFC'`, `'NFD'`, `'NFKC'`, or `'NFKD'`. `true`
+means `'NFC'`.
+
+A char such as `é` can be one code point, or `e` followed by a
+combining accent. Some file systems, such as on macOS, can give file
+names in the second form. Without this option, the two forms do not
+match.
+
+- The path is split on `/` before it is normalized. So with NFKC, a
+  full width `／` normalizes to `/`, but it does not split the path.
+  It is a char in its portion.
+- The syntax of the pattern is parsed before it is normalized. So
+  with NFKC, a full width `＊` is a literal, which matches `*`, and
+  not a wildcard.
+- With `nocase`, the strings are normalized, and then case is folded.
+
+See [@isaacs/nonrecursive-glob-match](http://npm.im/@isaacs/nonrecursive-glob-match#unicode-normalization)
+for how classes and combining marks after wildcards are normalized.
+
 ### nonull
 
 When a match is not found by `minimatch.match`, return a list containing
@@ -354,7 +376,7 @@ For legacy reasons, this is also set if
 
 When a pattern starts with a UNC path or drive letter, and in
 `nocase:true` mode, do not convert the root portions of the
-pattern into a case-insensitive regular expression, and instead
+pattern into a case-insensitive matchers, and instead
 leave them as strings.
 
 This is the default when the platform is `win32` and
@@ -390,11 +412,15 @@ is equivalent in all cases).
   example, the pattern `./a/b/../*` is converted to `./a/*`, and
   so it will match the path string `./a/c`, but not the path
   string `./a/b/../c`. Dots and empty path portions in the
-  pattern are preserved.
+  pattern are preserved. On Windows, a `..` never removes the
+  drive letter or the UNC host and share at the start of a
+  pattern, the same as it never removes the `/` at the start of
+  a posix pattern. So `C:/a/../../x` is converted to `C:/../x`.
 - `2` (or higher) - Much more aggressive optimizations, suitable
   for use with file-walking cases:
   - Remove cases where a double-dot `..` follows a pattern
-    portion that is not `**`, `.`, or empty `''`. Remove empty
+    portion that is not `**`, `.`, or empty `''`, or a Windows
+    root as above. Remove empty
     and `.` portions of the pattern, where safe to do so (ie,
     anywhere other than the last position, the first position, or
     the second position in a pattern starting with `/`, as this
@@ -402,7 +428,8 @@ is equivalent in all cases).
   - Convert patterns containing `<pre>/**/../<p>/<rest>` into the
     equivalent `<pre>/{..,**}/<p>/<rest>`, where `<p>` is a
     a pattern portion other than `.`, `..`, `**`, or empty
-    `''`.
+    `''`. This stops when there are `braceExpandMax`
+    patterns.
   - Dedupe patterns where a `**` portion is present in one and
     omitted in another, and it is not the final path portion, and
     they are otherwise equivalent. So `{a/**/b,a/b}` becomes
@@ -411,6 +438,8 @@ is equivalent in all cases).
     non-dot pattern other than `**`, `.`, `..`, or `''` is in the
     same position in the other. So `a/{*,x}/b` becomes `a/*/b`,
     because `*` can match against `x`.
+  - Dedupe only sets of 1000 patterns or fewer, because each
+    pattern is compared to each other one.
 
   While these optimizations improve the performance of
   file-walking use cases such as [glob](http://npm.im/glob) (ie,
@@ -418,13 +447,6 @@ is equivalent in all cases).
   fail to match a literal string that would have been matched in
   optimization level 1 or 0.
 
-  Specifically, while the `Minimatch.match()` method will
-  optimize the file path string in the same ways, resulting in
-  the same matches, it will fail when tested with the regular
-  expression provided by `Minimatch.makeRe()`, unless the path
-  string is first processed with
-  `minimatch.levelTwoFileOptimize()` or similar.
-
 ### platform
 
 When set to `win32`, this will trigger all windows-specific
@@ -449,26 +471,6 @@ match the pattern provided.
 That is, this is an intentional false negative, deemed an
 acceptable break in correctness for security and performance.
 
-### maxExtglobRecursion
-
-Max depth to traverse for nested extglobs like `*(a|b|c)`
-
-Default is 2, which is quite low, but any higher value swiftly
-results in punishing performance impacts. Note that this is _not_
-relevant when the globstar types can be safely coalesced into a
-single set.
-
-For example, `*(a|@(b|c)|d)` would be flattened into
-`*(a|b|c|d)`. Thus, many common extglobs will retain good
-performance and never hit this limit, even if they are
-excessively deep and complicated.
-
-If the limit is hit, then the extglob characters are simply not
-parsed, and the pattern effectively switches into `noextglob:
-true` mode for the contents of that nested sub-pattern. This will
-typically _not_ result in a match, but is considered a valid
-trade-off for security and performance.
-
 ## Comparisons to other fnmatch/glob implementations
 
 While strict compliance with the existing standards is a
@@ -497,8 +499,8 @@ If an escaped pattern has no matches, and the `nonull` flag is set,
 then minimatch.match returns the pattern as-provided, rather than
 interpreting the character escapes. For example,
 `minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
-`"*a?"`. This is akin to setting the `nullglob` option in bash, except
-that it does not resolve escaped pattern characters.
+`"*a?"`. This is like bash with the `nullglob` option off (the
+default), except that bash also removes the escapes.
 
 If brace expansion is not disabled, then it is performed before any
 other interpretation of the glob pattern. Thus, a pattern like
@@ -506,20 +508,36 @@ other interpretation of the glob pattern. Thus, a pattern like
 **first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
 checked for validity. Since those two are valid, matching proceeds.
 
-Negated extglob patterns are handled as closely as possible to
-Bash semantics, but there are some cases with negative extglobs
-which are exceedingly difficult to express in a JavaScript
-regular expression. In particular the negated pattern
-`<start>!(<pattern>*|)*` will in bash match anything that does
-not start with `<start><pattern>`. However,
-`<start>!(<pattern>*)*` _will_ match paths starting with
-`<start><pattern>`, because the empty string can match against
-the negated portion. In this library, `<start>!(<pattern>*|)*`
-will _not_ match any pattern starting with `<start>`, due to a
-difference in precisely which patterns are considered "greedy" in
-Regular Expressions vs bash path expansion. This may be fixable,
-but not without incurring some complexity and performance costs,
-and the trade-off seems to not be worth pursuing.
+Each portion of a pattern between `/` characters is matched with
+[@isaacs/nonrecursive-glob-match](http://npm.im/@isaacs/nonrecursive-glob-match),
+which uses Bash 5 as its reference, and does not use regular
+expressions. So negated extglobs such as `<start>!(<pattern>*|)*`
+match the same strings as in Bash. These are the known
+differences:
+
+- If `dot` is not set, a portion that starts with `.` only matches
+  if a literal `.` in the pattern matches that first character.
+  Extglobs before that `.` can match the empty string, so the
+  pattern can still match. For example, with `nonegate`,
+  `!(.a|js)@(.*)` matches `.a`, `.a.js`, and `.js`, because
+  `!(.a|js)` matches the empty string. Bash does not match these
+  dotfiles.
+- If an extglob such as `?(a` is not closed, Bash matches the
+  whole pattern as a literal string. In this library, only the
+  `?(` is literal, and the rest of the pattern is still matched
+  as a glob. So `a?(b*` matches `a?(bcc` here, but not in Bash.
+- A pattern is split into portions on every `/`, including a `/`
+  inside an extglob. So `@(a|b/c)/*` becomes the portions
+  `@(a|b`, `c)`, and `*`, and its extglob is not closed. Bash
+  keeps the extglob whole, and drops each alternative with a `/`
+  in it, as no portion can contain a `/`. So in Bash, `@(a|b/c)/*`
+  is the same as `@(a)/*`. Leave out the alternatives with a `/`
+  to get the same result here.
+- With `nocase`, case is folded one code point at a time with
+  Unicode simple case folding, the same as a JavaScript RegExp
+  with the `iu` flags. Bash uses the case functions of the C
+  library for the current locale, so its results can change with
+  the locale.
 
 Note that `fnmatch(3)` in libc is an extremely naive string comparison
 matcher, which does not do anything special for slashes. This library is

package/node_modules/minimatch/dist/commonjs/index.d.ts

@@ -1,4 +1,4 @@
-import { AST } from './ast.js';
+import { Matcher, type Form } from '@isaacs/nonrecursive-glob-match';
 export type Platform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'haiku' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin' | 'netbsd';
 export interface MinimatchOptions {
     /** do not expand `{x,y}` style braces */
@@ -7,8 +7,6 @@ export interface MinimatchOptions {
     nocomment?: boolean;
     /** do not treat patterns starting with `!` as a negation */
     nonegate?: boolean;
-    /** print LOTS of debugging output */
-    debug?: boolean;
     /** treat `**` the same as `*` */
     noglobstar?: boolean;
     /** do not expand extglobs like `+(a|b)` */
@@ -37,6 +35,11 @@ export interface MinimatchOptions {
     nocase?: boolean;
     /** ignore case only in wildcard patterns */
     nocaseMagicOnly?: boolean;
+    /**
+     * Normalize unicode in the pattern and in each portion of the
+     * tested paths, with this form. `true` means `'NFC'`.
+     */
+    normalize?: boolean | Form;
     /** consider braces to be "magic" for the purpose of `hasMagic` */
     magicalBraces?: boolean;
     /**
@@ -69,6 +72,9 @@ export interface MinimatchOptions {
     windowsNoMagicRoot?: boolean;
     /**
      * max number of `{...}` patterns to expand. Default 100_000.
+     *
+     * At `optimizationLevel` 2 or higher, this also limits the
+     * patterns made when `**` is followed by `..`.
      */
     braceExpandMax?: number;
     /**
@@ -78,27 +84,6 @@ export interface MinimatchOptions {
      * and can handle absurdly excessive patterns.
      */
     maxGlobstarRecursion?: number;
-    /**
-     * Max depth to traverse for nested extglobs like `*(a|b|c)`
-     *
-     * Default is 2, which is quite low, but any higher value
-     * swiftly results in punishing performance impacts. Note
-     * that this is *not*  relevant when the globstar types can
-     * be safely coalesced into a single set.
-     *
-     * For example, `*(a|@(b|c)|d)` would be flattened into
-     * `*(a|b|c|d)`. Thus, many common extglobs will retain good
-     * performance and  never hit this limit, even if they are
-     * excessively deep and complicated.
-     *
-     * If the limit is hit, then the extglob characters are simply
-     * not parsed, and the pattern effectively switches into
-     * `noextglob: true` mode for the contents of that nested
-     * sub-pattern. This will typically _not_ result in a match,
-     * but is considered a valid trade-off for security and
-     * performance.
-     */
-    maxExtglobRecursion?: number;
 }
 export declare const minimatch: {
     (p: string, pattern: string, options?: MinimatchOptions): boolean;
@@ -107,9 +92,7 @@ export declare const minimatch: {
     filter: (pattern: string, options?: MinimatchOptions) => (p: string) => boolean;
     defaults: (def: MinimatchOptions) => typeof minimatch;
     braceExpand: (pattern: string, options?: MinimatchOptions) => string[];
-    makeRe: (pattern: string, options?: MinimatchOptions) => false | MMRegExp;
     match: (list: string[], pattern: string, options?: MinimatchOptions) => string[];
-    AST: typeof AST;
     Minimatch: typeof Minimatch;
     escape: (s: string, { windowsPathsNoEscape, magicalBraces, }?: Pick<MinimatchOptions, "windowsPathsNoEscape" | "magicalBraces">) => string;
     unescape: (s: string, { windowsPathsNoEscape, magicalBraces, }?: Pick<MinimatchOptions, "windowsPathsNoEscape" | "magicalBraces">) => string;
@@ -120,13 +103,46 @@ export declare const GLOBSTAR: unique symbol;
 export declare const filter: (pattern: string, options?: MinimatchOptions) => (p: string) => boolean;
 export declare const defaults: (def: MinimatchOptions) => typeof minimatch;
 export declare const braceExpand: (pattern: string, options?: MinimatchOptions) => string[];
-export declare const makeRe: (pattern: string, options?: MinimatchOptions) => false | MMRegExp;
 export declare const match: (list: string[], pattern: string, options?: MinimatchOptions) => string[];
-export type MMRegExp = RegExp & {
-    _src?: string;
-    _glob?: string;
+/**
+ * A path that Minimatch#match split, with the settings that the split
+ * depends on. `resolved` is the parts after optimizationLevel 2 has
+ * resolved `.` and `..` in them, which only depends on the same
+ * settings, once a level 2 Minimatch has needed them.
+ */
+export type SplitPath = {
+    f: string;
+    isWindows: boolean;
+    preserveMultipleSlashes: boolean;
+    normalize: Form | undefined;
+    parts: string[];
+    resolved?: string[];
+};
+export type ParseReturnFiltered = string | Matcher | typeof GLOBSTAR;
+/**
+ * The rows that Minimatch#match can match without splitting the path:
+ * `**` and one more portion (`tail`), a portion with `**` on each side
+ * of it (`mid`), a portion and then `**` (`head`), or one portion that
+ * matches the basename of the path, with matchBase (`base`).
+ */
+export type RowShape = 'tail' | 'mid' | 'head' | 'base';
+/**
+ * The separators that a path has: only `/`, only `\` (a Windows path
+ * with no `/`), or both. Scanning for the ones it has is faster.
+ */
+export type PathSeps = '/' | '\\' | 'both';
+/**
+ * A pattern row split on its first and last `**`, from a start
+ * index. Each body segment has the number of path portions that it
+ * and the ones after it need, to find the last index where it can
+ * start in a path.
+ */
+export type GlobstarParts = {
+    head: ParseReturn[];
+    body: ParseReturn[];
+    tail: ParseReturn[];
+    segments: [segment: ParseReturn[], need: number][];
 };
-export type ParseReturnFiltered = string | MMRegExp | typeof GLOBSTAR;
 export type ParseReturn = ParseReturnFiltered | false;
 export declare class Minimatch {
     #private;
@@ -147,28 +163,23 @@ export declare class Minimatch {
     platform: Platform;
     windowsNoMagicRoot: boolean;
     maxGlobstarRecursion: number;
-    regexp: false | null | MMRegExp;
     constructor(pattern: string, options?: MinimatchOptions);
     hasMagic(): boolean;
-    debug(..._: unknown[]): void;
     make(): void;
+    mergeRows(): void;
     preprocess(globParts: string[][]): string[][];
     adjascentGlobstarOptimize(globParts: string[][]): string[][];
     levelOneOptimize(globParts: string[][]): string[][];
-    levelTwoFileOptimize(parts: string | string[]): string[];
     firstPhasePreProcess(globParts: string[][]): string[][];
     secondPhasePreProcess(globParts: string[][]): string[][];
     partsMatch(a: string[], b: string[], emptyGSMatch?: boolean): false | string[];
     parseNegate(): void;
-    matchOne(file: string[], pattern: ParseReturn[], partial?: boolean): boolean;
     braceExpand(): string[];
     parse(pattern: string): ParseReturn;
-    makeRe(): false | MMRegExp;
-    slashSplit(p: string): string[];
     match(f: string, partial?: boolean): boolean;
     static defaults(def: MinimatchOptions): typeof Minimatch;
 }
-export { AST } from './ast.js';
 export { escape } from './escape.js';
 export { unescape } from './unescape.js';
+export type { Form };
 //# sourceMappingURL=index.d.ts.map

package/node_modules/minimatch/dist/commonjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}