npm - @occultist/occultist - Versions diffs - 0.0.1 - Mend

@occultist/occultist 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (165) hide show

package/LICENSE +21 -0
package/README.md +144 -0
package/dist/accept.d.ts +41 -0
package/dist/accept.js +110 -0
package/dist/accept.test.d.ts +1 -0
package/dist/accept.test.js +44 -0
package/dist/action.test.d.ts +1 -0
package/dist/action.test.js +1 -0
package/dist/actions/actionSets.d.ts +23 -0
package/dist/actions/actionSets.js +49 -0
package/dist/actions/actions.d.ts +163 -0
package/dist/actions/actions.js +436 -0
package/dist/actions/context.d.ts +78 -0
package/dist/actions/context.js +112 -0
package/dist/actions/meta.d.ts +49 -0
package/dist/actions/meta.js +177 -0
package/dist/actions/path.d.ts +21 -0
package/dist/actions/path.js +83 -0
package/dist/actions/path.test.d.ts +1 -0
package/dist/actions/path.test.js +9 -0
package/dist/actions/spec.d.ts +214 -0
package/dist/actions/spec.js +1 -0
package/dist/actions/types.d.ts +112 -0
package/dist/actions/types.js +2 -0
package/dist/actions/writer.d.ts +27 -0
package/dist/actions/writer.js +140 -0
package/dist/actions/writer.test.d.ts +1 -0
package/dist/actions/writer.test.js +42 -0
package/dist/auth/types.d.ts +14 -0
package/dist/auth/types.js +1 -0
package/dist/cache/cache.d.ts +30 -0
package/dist/cache/cache.js +220 -0
package/dist/cache/etag.d.ts +17 -0
package/dist/cache/etag.js +83 -0
package/dist/cache/etag.test.d.ts +1 -0
package/dist/cache/etag.test.js +91 -0
package/dist/cache/memory.d.ts +12 -0
package/dist/cache/memory.js +36 -0
package/dist/cache/types.d.ts +175 -0
package/dist/cache/types.js +4 -0
package/dist/errors.d.ts +11 -0
package/dist/errors.js +54 -0
package/dist/jsonld.d.ts +43 -0
package/dist/jsonld.js +1 -0
package/dist/makeTypeDefs.d.ts +27 -0
package/dist/makeTypeDefs.js +70 -0
package/dist/merge.d.ts +61 -0
package/dist/merge.js +1 -0
package/dist/mod.d.ts +14 -0
package/dist/mod.js +14 -0
package/dist/processAction.d.ts +15 -0
package/dist/processAction.js +512 -0
package/dist/registry.d.ts +88 -0
package/dist/registry.js +314 -0
package/dist/registry.test.d.ts +1 -0
package/dist/registry.test.js +133 -0
package/dist/request.d.ts +29 -0
package/dist/request.js +118 -0
package/dist/scopes.d.ts +35 -0
package/dist/scopes.js +121 -0
package/dist/scopes.test.d.ts +1 -0
package/dist/scopes.test.js +55 -0
package/dist/transformers/fileTransformer.d.ts +1 -0
package/dist/transformers/fileTransformer.js +8 -0
package/dist/types.d.ts +12 -0
package/dist/types.js +1 -0
package/dist/utils/alwaysArray.d.ts +1 -0
package/dist/utils/alwaysArray.js +9 -0
package/dist/utils/contextBuilder.d.ts +9 -0
package/dist/utils/contextBuilder.js +82 -0
package/dist/utils/getActionContext.d.ts +7 -0
package/dist/utils/getActionContext.js +48 -0
package/dist/utils/getInternalName.d.ts +6 -0
package/dist/utils/getInternalName.js +7 -0
package/dist/utils/getParamLocation.d.ts +2 -0
package/dist/utils/getParamLocation.js +6 -0
package/dist/utils/getPropertyValueSpecifications.d.ts +2 -0
package/dist/utils/getPropertyValueSpecifications.js +49 -0
package/dist/utils/getRequestBodyValues.d.ts +11 -0
package/dist/utils/getRequestBodyValues.js +122 -0
package/dist/utils/getRequestIRIValues.d.ts +14 -0
package/dist/utils/getRequestIRIValues.js +133 -0
package/dist/utils/isBodyInit.d.ts +1 -0
package/dist/utils/isBodyInit.js +21 -0
package/dist/utils/isNil.d.ts +1 -0
package/dist/utils/isNil.js +4 -0
package/dist/utils/isObject.d.ts +6 -0
package/dist/utils/isObject.js +6 -0
package/dist/utils/isPopulatedObject.d.ts +5 -0
package/dist/utils/isPopulatedObject.js +8 -0
package/dist/utils/isPopulatedString.d.ts +1 -0
package/dist/utils/isPopulatedString.js +4 -0
package/dist/utils/joinPaths.d.ts +1 -0
package/dist/utils/joinPaths.js +31 -0
package/dist/utils/makeAppendProblemDetails.d.ts +14 -0
package/dist/utils/makeAppendProblemDetails.js +26 -0
package/dist/utils/makeURLPattern.d.ts +5 -0
package/dist/utils/makeURLPattern.js +12 -0
package/dist/utils/normalizeURL.d.ts +4 -0
package/dist/utils/normalizeURL.js +11 -0
package/dist/utils/parseSearchParams.d.ts +3 -0
package/dist/utils/parseSearchParams.js +24 -0
package/dist/utils/preferredMediaTypes.d.ts +42 -0
package/dist/utils/preferredMediaTypes.js +149 -0
package/dist/utils/urlToIRI.d.ts +1 -0
package/dist/utils/urlToIRI.js +8 -0
package/dist/utils/validateSpecValue.d.ts +1 -0
package/dist/utils/validateSpecValue.js +1 -0
package/dist/validators.d.ts +16 -0
package/dist/validators.js +134 -0
package/lib/accept.test.ts +55 -0
package/lib/accept.ts +147 -0
package/lib/action.test.ts +2 -0
package/lib/actions/actionSets.ts +88 -0
package/lib/actions/actions.ts +795 -0
package/lib/actions/context.ts +170 -0
package/lib/actions/meta.ts +251 -0
package/lib/actions/path.test.ts +15 -0
package/lib/actions/path.ts +99 -0
package/lib/actions/spec.ts +545 -0
package/lib/actions/types.ts +146 -0
package/lib/actions/writer.test.ts +57 -0
package/lib/actions/writer.ts +176 -0
package/lib/auth/types.ts +22 -0
package/lib/cache/cache.ts +291 -0
package/lib/cache/etag.test.ts +122 -0
package/lib/cache/etag.ts +106 -0
package/lib/cache/memory.ts +52 -0
package/lib/cache/types.ts +240 -0
package/lib/errors.ts +66 -0
package/lib/jsonld.ts +67 -0
package/lib/makeTypeDefs.ts +138 -0
package/lib/merge.ts +86 -0
package/lib/mod.ts +14 -0
package/lib/processAction.ts +690 -0
package/lib/registry.test.ts +174 -0
package/lib/registry.ts +455 -0
package/lib/request.ts +153 -0
package/lib/scopes.test.ts +70 -0
package/lib/scopes.ts +178 -0
package/lib/transformers/fileTransformer.ts +10 -0
package/lib/types.ts +13 -0
package/lib/utils/alwaysArray.ts +10 -0
package/lib/utils/contextBuilder.ts +111 -0
package/lib/utils/getActionContext.ts +76 -0
package/lib/utils/getInternalName.ts +15 -0
package/lib/utils/getParamLocation.ts +14 -0
package/lib/utils/getPropertyValueSpecifications.ts +76 -0
package/lib/utils/getRequestBodyValues.ts +155 -0
package/lib/utils/getRequestIRIValues.ts +201 -0
package/lib/utils/isBodyInit.ts +22 -0
package/lib/utils/isNil.ts +4 -0
package/lib/utils/isObject.ts +8 -0
package/lib/utils/isPopulatedObject.ts +9 -0
package/lib/utils/isPopulatedString.ts +4 -0
package/lib/utils/joinPaths.ts +36 -0
package/lib/utils/makeAppendProblemDetails.ts +57 -0
package/lib/utils/makeURLPattern.ts +18 -0
package/lib/utils/normalizeURL.ts +15 -0
package/lib/utils/parseSearchParams.ts +36 -0
package/lib/utils/preferredMediaTypes.ts +220 -0
package/lib/utils/urlToIRI.ts +11 -0
package/lib/utils/validateSpecValue.ts +0 -0
package/lib/validators.ts +186 -0
package/package.json +41 -0

package/lib/registry.test.ts ADDED Viewed

@@ -0,0 +1,174 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { Registry } from './registry.js';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+const registry = new Registry({
+  rootIRI: 'https://example.com',
+});
+ registry.http.get('get-index', '/')
+   .public()
+   .hint({
+     link: {
+       href: 'http://example.com/messages.json',
+       type: 'application/json',
+       preload: true,
+     },
+   })
+   .handle('text/plain', (ctx) => {
+     ctx.body = `Hello, world!`;
+   })
+   .handle('application/json', (ctx) => {
+     ctx.body = JSON.stringify({
+       foo: 'bar',
+     });
+   });
+registry.http.post('post-things', '/posty/post')
+  .public()
+  .handle('text/html', async (ctx) => {
+    ctx.body = await Promise.resolve(`
+      <!doctype html>
+      <html>
+        <body>Got it</body>
+      </html>
+    `);
+  });
+function checkPayloadTypesMap(args: {
+  foo: string;
+  fee: number;
+  foe: Array<{ bar: boolean }>;
+  baz: string[],
+}) {
+  return args;
+}
+registry.http.post('post-me', '/foo/{fee}/bar{?baz}')
+  .public()
+  .define({
+    spec: {
+      foo: {
+        dataType: 'string',
+      },
+      fee: {
+        dataType: 'number',
+        valueName: 'fee',
+      },
+      foe: {
+        multipleValues: true,
+        properties: {
+          bar: {
+            dataType: 'boolean',
+            valueRequired: true,
+          },
+        },
+      },
+      baz: {
+        dataType: 'string',
+        multipleValues: true,
+        valueName: 'baz',
+      },
+    },
+  })
+  .handle('application/json', (ctx) => {
+    ctx.body = JSON.stringify(checkPayloadTypesMap(ctx.payload))
+  });
+registry.finalize();
+test('It responds to request objects', async () => {
+  const res = await registry.handleRequest(
+    new Request('https://example.com'),
+  );
+  assert(await res.text() === 'Hello, world!');
+});
+test('It responds to node incoming messages', async () => {
+  const res = await new Promise<Response>((resolve, reject) => {
+    const server = createServer();
+    server.on('request', async (req, res) => {
+      await registry.handleRequest(req, res);
+    });
+    server.on('error', (err) => {
+      reject(err);
+    });
+    server.listen(0, '127.0.0.1', async () => {
+      const { port, address } = server.address() as AddressInfo;
+      const res = await fetch(`http://${address}:${port}`);
+      server.close();
+      resolve(res);
+    });
+  });
+  assert(await res.text() === 'Hello, world!');
+});
+test('It uses the correct handler for the accepted content type', async () => {
+  const res = await registry.handleRequest(
+    new Request('https://example.com', {
+      headers: { 'Accept': 'application/*' }
+    }),
+  );
+  assert((await res.json()).foo === 'bar');
+});
+test('It responds to other HTTP methods', async () => {
+  const res = await registry.handleRequest(
+    new Request('https://example.com/posty/post', {
+      method: 'POST',
+      headers: { 'Accept': 'text/html' },
+    })
+  );
+  assert((await res.text()).includes('<body>Got it</body>'))
+});
+test('It handles request payloads for application/json requests', async () => {
+  const res = await registry.handleRequest(
+    new Request('https://example.com/foo/1234/bar?baz=foo&baz=bar&baz=baz', {
+      method: 'POST',
+      body: JSON.stringify({
+        foo: 'bar',
+        foe: [
+          { bar: true }, { bar: false },
+        ],
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    }),
+  );
+  const body = await res.json();
+  assert(body.fee === 1234);
+  assert(body.foo === 'bar');
+  assert(body.foe[0].bar);
+  assert(!body.foe[1].bar);
+  assert(body.baz[0] === 'foo');
+});
+test('It fires beforefinalize and after finalize events', { only: true }, () => {
+  const called: string[] = [];
+  const registry = new Registry({ rootIRI: 'https://example.com' });
+  registry.addEventListener('beforefinalize', () => called.push('beforefinalize'));
+  registry.addEventListener('afterfinalize', () => called.push('afterfinalize'))
+  registry.finalize();
+  assert(called[0] === 'beforefinalize');
+  assert(called[1] === 'afterfinalize');
+});

package/lib/registry.ts ADDED Viewed

@@ -0,0 +1,455 @@
+import { Accept } from "./accept.js";
+import { ActionAuth, HandlerDefinition } from "./actions/actions.js";
+import { type ActionMatchResult, ActionSet } from "./actions/actionSets.js";
+import { ActionMeta } from "./actions/meta.js";
+import type { ImplementedAction } from "./actions/types.js";
+import { ResponseWriter } from "./actions/writer.js";
+import { Scope } from './scopes.js';
+import { IncomingMessage, type ServerResponse } from "node:http";
+import type { Merge } from "./actions/spec.js";
+import type { ContextState, Middleware } from "./actions/spec.js";
+import {ProblemDetailsError} from "./errors.js"
+import {WrappedRequest} from "./request.js";
+export interface Callable<
+  State extends ContextState = ContextState,
+> {
+  method(method: string, name: string, path: string): ActionAuth<State>;
+}
+export class HTTP<
+  State extends ContextState = ContextState,
+> {
+  #callable: Callable<State>;
+  constructor(callable: Callable<State>) {
+    this.#callable = callable;
+  }
+  trace(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('trace', name, path);
+  }
+  options(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('options', name, path);
+  }
+  head(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('head', name, path);
+  }
+  get(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('get', name, path);
+  }
+  put(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('put', name, path);
+  }
+  patch(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('patch', name, path);
+  }
+  post(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('post', name, path);
+  }
+  delete(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('delete', name, path);
+  }
+}
+export type IndexMatchArgs = {
+  debug?: boolean;
+};
+export class IndexEntry {
+  #actionSets: ActionSet[];
+  constructor(actionSets: ActionSet[]) {
+    this.#actionSets = actionSets;
+  }
+  match(method: string, path: string, accept: Accept): null | ActionMatchResult {
+    for (let index = 0; index < this.#actionSets.length; index++) {
+      const actionSet = this.#actionSets[index];
+      const match = actionSet.matches(method, path, accept);
+      if (match != null) {
+        return match;
+      }
+    }
+    return null;
+  }
+}
+export type RegistryEvents =
+  | 'beforefinalize'
+  | 'afterfinalize'
+;
+export type RegistryArgs = {
+  rootIRI: string;
+  serverTiming?: boolean;
+};
+export class Registry<
+  State extends ContextState = ContextState,
+> implements Callable<State> {
+  #finalized: boolean = false;
+  #path: string;
+  #rootIRI: string;
+  #serverTiming: boolean;
+  #http: HTTP<State>;
+  #scopes: Scope[] = [];
+  #children: ActionMeta[] = [];
+  #index?: IndexEntry;
+  #writer = new ResponseWriter();
+  #eventTarget = new EventTarget();
+  #middleware: Middleware[] = [];
+  #actions: ImplementedAction[] | null = null;
+  #handlers: HandlerDefinition[] | null = null;
+  constructor(args: RegistryArgs) {
+    const url = new URL(args.rootIRI);
+    this.#rootIRI = args.rootIRI;
+    this.#path = url.pathname;
+    this.#serverTiming = args.serverTiming ?? false;
+    this.#http = new HTTP<State>(this);
+  }
+  scope(path: string): Scope<State> {
+    const scope = new Scope<State>({
+      path,
+      serverTiming: this.#serverTiming,
+      registry: this,
+      writer: this.#writer,
+      propergateMeta: (meta) => this.#children.push(meta),
+    });
+    this.#scopes.push(scope);
+    return scope;
+  }
+  get rootIRI(): string {
+    return this.#rootIRI;
+  }
+  get path(): string {
+    return this.#path;
+  }
+  get http(): HTTP<State> {
+    return this.#http;
+  }
+  get actions(): Array<ImplementedAction> {
+    if (this.#finalized && this.#actions != null) {
+      return this.#actions;
+    }
+    const actions: ImplementedAction[] = [];
+    for (let i = 0; i < this.#children.length; i++) {
+      if (this.#children[i].action == null) continue;
+      actions.push(this.#children[i].action);
+    }
+    for (let i = 0; i < this.#scopes.length; i++) {
+      for (let j = 0; j < this.#scopes[i].actions.length; j++) {
+        actions.push(this.#scopes[i].actions[j]);
+      }
+    }
+    if (this.#finalized) this.#actions = actions;
+    return actions;
+  }
+  /**
+   * Returns the first action using the given action name. A content type
+   * can be provided to select another action going by the same name
+   * and returning a different content type.
+   *
+   * @param name        - The name of the action.
+   * @param contentType - The action's content type.
+   */
+  get(name: string, contentType?: string): ImplementedAction | undefined {
+    const actions = this.actions;
+    for (let i = 0; i < actions.length; i++) {
+      if (actions[i].name !== name) {
+        continue;
+      } else if (contentType == null && !this.actions[i].contentTypes.includes(contentType)) {
+        continue;
+      }
+      return actions[i];
+    }
+  }
+  /**
+   * Returns a list of all action handler definitions.
+   */
+  get handlers(): HandlerDefinition[] {
+    if (this.#finalized && this.#handlers != null) {
+      return this.#handlers;
+    }
+    const actions = this.actions;
+    const handlers: HandlerDefinition[] = [];
+    for (let i = 0; i < actions.length; i++) {
+      for (let j = 0; j < actions[i].handlers.length; j++) {
+        handlers.push(actions[i].handlers[j]);
+      }
+    }
+    if (this.#finalized) this.#handlers = handlers;
+    return handlers;
+  }
+  /**
+   * Queries all handler definitions.
+   *
+   * @param args.method      The HTTP method the action should handle.
+   * @param args.contentType A content type, or list of content types the action
+   *                         should handle. If a list is given the action
+   *                         will be included if it matches one content type
+   *                         in the list.
+   * @param args.meta        A meta value, such as a unique symbol, which the action
+   *                         should have in its meta object.
+   */
+  query({
+    method,
+    contentType,
+    meta,
+  }: {
+    method?: string | string[];
+    contentType?: string | string[]
+    meta?: string | symbol;
+  } = {}): HandlerDefinition[] {
+    const source = this.handlers;
+    const handlers: HandlerDefinition[] = [];
+    let handler: HandlerDefinition;
+    if (method == null &&
+        contentType == null &&
+        meta == null) {
+      return source;
+    }
+    for (let i = 0; i < source.length; i++) {
+      handler = source[i];
+      if (Array.isArray(contentType)) {
+        if (!contentType.includes(handler.contentType)) {
+          continue;
+        }
+      } else if (contentType != null && contentType !== handler.contentType) {
+        continue;
+      }
+      if (Array.isArray(method)) {
+        if (!method.includes(handler.action.method)) {
+          continue;
+        }
+      } else if (method != null && method !== handler.action.method) {
+        continue;
+      }
+      if (meta != null) {
+        if (!Reflect.has(handler.meta, meta)) {
+          continue;
+        }
+      }
+      handlers.push(handler);
+    }
+    return handlers;
+  }
+  /**
+   * Creates an action for any HTTP method.
+   *
+   * @param method The HTTP method name.
+   * @param name   Name for the action being produced.
+   * @param path   Path the action responds to.
+   */
+  public method(method: string, name: string, path: string): ActionAuth<State> {
+    const meta = new ActionMeta<State>(
+      this.#rootIRI,
+      method.toUpperCase(),
+      name,
+      path,
+      this,
+      this.#writer,
+    );
+    meta.serverTiming = this.#serverTiming;
+    this.#children.push(meta);
+    return new ActionAuth<State>(meta);
+  }
+  public use<
+    const MiddlewareState extends ContextState = ContextState,
+  >(
+    middleware: Middleware<MiddlewareState>,
+  ): Registry<Merge<State, MiddlewareState>> {
+    this.#middleware.push(middleware);
+    return this as unknown as Registry<Merge<State, MiddlewareState>>;
+  }
+  finalize() {
+    if (this.#finalized)
+      throw new Error('Registry has already been finalized');
+    const actionSets: ActionSet[] = [];
+    const groupedMeta = new Map<string, Map<string, ActionMeta[]>>();
+    this.#eventTarget.dispatchEvent(
+      new Event('beforefinalize', { bubbles: true, cancelable: false })
+    );
+    for (let index = 0; index < this.#scopes.length; index++) {
+      const scope = this.#scopes[index];
+      scope.finalize();
+    }
+    for (let index = 0; index < this.#children.length; index++) {
+      const meta = this.#children[index];
+      const method = meta.method;
+      const normalized = meta.path.normalized;
+      meta.finalize();
+      const group = groupedMeta.get(normalized);
+      const methodSet = group?.get(method);
+      if (methodSet != null) {
+        methodSet.push(meta);
+      } else if (group != null) {
+        group.set(method, [meta]);
+      } else {
+        groupedMeta.set(normalized, new Map([[method, [meta]]]));
+      }
+    }
+    for (const [normalized, methodSet] of groupedMeta.entries()) {
+      for (const [method, meta] of methodSet.entries()) {
+        const actionSet = new ActionSet(
+          this.#rootIRI,
+          method,
+          normalized,
+          meta,
+        );
+        actionSets.push(actionSet);
+      }
+    }
+    this.#finalized = true;
+    this.#index = new IndexEntry(actionSets);
+    this.#eventTarget.dispatchEvent(
+      new Event('afterfinalize', { bubbles: true, cancelable: false })
+    );
+    // force actions and handlers to cache.
+    this.handlers;
+    // freeze all scopes.
+    for (let i = 0; i < this.#scopes.length; i++) {
+      Object.freeze(this.#scopes[i]);
+    }
+    // freeze the registry.
+    Object.freeze(this);
+  }
+  handleRequest(
+    req: Request,
+  ): Promise<Response>;
+  handleRequest(
+    req: IncomingMessage,
+    res: ServerResponse,
+  ): Promise<ServerResponse>;
+  async handleRequest(
+    req: Request | IncomingMessage,
+    res?: ServerResponse,
+  ): Promise<Response | ServerResponse> {
+    const startTime = performance.now();
+    const wrapped = new WrappedRequest(this.#rootIRI, req);
+    const writer = new ResponseWriter(res);
+    const accept = Accept.from(wrapped);
+    const match = this.#index?.match(
+      req.method ?? 'GET',
+      wrapped.url.toString(),
+      accept,
+    );
+    let err: ProblemDetailsError;
+    try {
+      if (match?.type === 'match') {
+        return await match.action.handleRequest({
+          url: wrapped.url,
+          contentType: match.contentType,
+          req: wrapped,
+          writer,
+          startTime,
+        });
+      }
+    } catch (err2) {
+      if (err2 instanceof ProblemDetailsError) {
+        err = err2;
+      } else {
+        err = new ProblemDetailsError(500, 'Internal server error');
+      }
+    }
+    if (err == null) {
+      err = new ProblemDetailsError(404, 'Not found');
+    }
+    if (err instanceof ProblemDetailsError && req instanceof Request) {
+      return new Response(err.toContent('application/problem+json'), {
+        status: err.status,
+        headers: {
+          'Content-Type': 'application/problem+json',
+        },
+      });
+    } else if (err instanceof ProblemDetailsError && res != null) {
+      res.writeHead(err.status, {
+        'Content-Type': 'application/problem+json',
+      });
+      res.end(err.toContent('application/problem+json'));
+      return res;
+    }
+  }
+  addEventListener(type: RegistryEvents, callback: EventListener) {
+    this.#eventTarget.addEventListener(type, callback);
+  };
+  removeEventListener(type: RegistryEvents, callback: EventListener) {
+    this.#eventTarget.removeEventListener(type, callback)
+  }
+}