@defold-typescript/types 0.8.4 → 0.9.0

package/README.md

@@ -13,7 +13,7 @@ Most users get these wired in automatically by the
 (`bunx @defold-typescript/cli init`), which points `tsconfig.json` at the right surface.
 
 See the repository [README](https://github.com/defold-typescript/toolchain#readme)
-and [`docs/guide/`](https://github.com/defold-typescript/toolchain/tree/main/docs/guide)
+and [`packages/docs/guide/`](https://github.com/defold-typescript/toolchain/tree/main/packages/docs/guide)
 for the full workflow.
 
 ## License

package/api-targets.json

@@ -9,6 +9,11 @@
       "source": null,
       "modules": [
         { "namespace": "b2d", "fixture": "b2d_doc.json", "outFile": "b2d.d.ts" },
+        {
+          "namespace": "b2d.body",
+          "fixture": "b2d_body_doc.json",
+          "outFile": "b2d_body.d.ts"
+        },
         { "namespace": "buffer", "fixture": "buffer_doc.json", "outFile": "buffer.d.ts" },
         { "namespace": "camera", "fixture": "camera_doc.json", "outFile": "camera.d.ts" },
         {
@@ -23,6 +28,7 @@
         },
         { "namespace": "crash", "fixture": "crash_doc.json", "outFile": "crash.d.ts" },
         { "namespace": "factory", "fixture": "factory_doc.json", "outFile": "factory.d.ts" },
+        { "namespace": "font", "fixture": "font_doc.json", "outFile": "font.d.ts" },
         {
           "namespace": "go",
           "fixture": "go_doc.json",
@@ -71,6 +77,18 @@
         { "namespace": "webview", "fixture": "webview_doc.json", "outFile": "webview.d.ts" },
         { "namespace": "window", "fixture": "window_doc.json", "outFile": "window.d.ts" },
         { "namespace": "zlib", "fixture": "zlib_doc.json", "outFile": "zlib.d.ts" }
+      ],
+      "luaStdlib": [
+        { "namespace": "base", "fixture": "base_doc.json" },
+        { "namespace": "bit", "fixture": "bit_doc.json" },
+        { "namespace": "math", "fixture": "math_doc.json" },
+        { "namespace": "os", "fixture": "os_doc.json" },
+        { "namespace": "string", "fixture": "string_doc.json" },
+        { "namespace": "table", "fixture": "table_doc.json" },
+        { "namespace": "coroutine", "fixture": "coroutine_doc.json" },
+        { "namespace": "debug", "fixture": "debug_doc.json" },
+        { "namespace": "io", "fixture": "io_doc.json" },
+        { "namespace": "package", "fixture": "package_doc.json" }
       ]
     },
     {

package/generated/b2d_body.d.ts

@@ -0,0 +1,348 @@
+/** @noSelfInFile */
+import type { Opaque, Vector3 } from "../src/core-types";
+
+declare global {
+  /**
+   * Functions for interacting with Box2D bodies.
+   */
+  namespace b2d.body {
+    type b2Body = Opaque<"b2Body">;
+    type b2World = Opaque<"b2World">;
+    /**
+     * Dynamic body
+     */
+    const B2_DYNAMIC_BODY: number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" };
+    /**
+     * Kinematic body
+     */
+    const B2_KINEMATIC_BODY: number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" };
+    /**
+     * Static (immovable) body
+     */
+    const B2_STATIC_BODY: number & { readonly __brand: "b2d.body.B2_STATIC_BODY" };
+    /**
+     * Apply an angular impulse.
+     *
+     * @param body - body
+     * @param impulse - impulse the angular impulse in units of kg*m*m/s
+     */
+    function apply_angular_impulse(body: Opaque<"b2Body">, impulse: number): void;
+    /**
+     * Apply a force at a world point. If the force is not
+     * applied at the center of mass, it will generate a torque and
+     * affect the angular velocity. This wakes up the body.
+     *
+     * @param body - body
+     * @param force - the world force vector, usually in Newtons (N).
+     * @param point - the world position of the point of application.
+     */
+    function apply_force(body: Opaque<"b2Body">, force: Vector3, point: Vector3): void;
+    /**
+     * Apply a force to the center of mass. This wakes up the body.
+     *
+     * @param body - body
+     * @param force - the world force vector, usually in Newtons (N).
+     */
+    function apply_force_to_center(body: Opaque<"b2Body">, force: Vector3): void;
+    /**
+     * Apply an impulse at a point. This immediately modifies the velocity.
+     * It also modifies the angular velocity if the point of application
+     * is not at the center of mass. This wakes up the body.
+     *
+     * @param body - body
+     * @param impulse - the world impulse vector, usually in N-seconds or kg-m/s.
+     * @param point - the world position of the point of application.
+     */
+    function apply_linear_impulse(body: Opaque<"b2Body">, impulse: Vector3, point: Vector3): void;
+    /**
+     * Apply a torque. This affects the angular velocity
+     * without affecting the linear velocity of the center of mass.
+     * This wakes up the body.
+     *
+     * @param body - body
+     * @param torque - torque about the z-axis (out of the screen), usually in N-m.
+     */
+    function apply_torque(body: Opaque<"b2Body">, torque: number): void;
+    /**
+     * You can disable sleeping on this body. If you disable sleeping, the body will be woken.
+     *
+     * @param body - body
+     * @param enable - if false, the body will never sleep, and consume more CPU
+     */
+    function enable_sleep(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Get the angle in radians.
+     *
+     * @param body - body
+     * @returns the current world rotation angle in radians.
+     */
+    function get_angle(body: Opaque<"b2Body">): number;
+    /**
+     * Get the angular damping of the body.
+     *
+     * @param body - body
+     * @returns the damping
+     */
+    function get_angular_damping(body: Opaque<"b2Body">): number;
+    /**
+     * Get the angular velocity.
+     *
+     * @param body - body
+     * @returns the angular velocity in radians/second.
+     */
+    function get_angular_velocity(body: Opaque<"b2Body">): number;
+    /**
+     * Get the gravity scale of the body.
+     *
+     * @param body - body
+     * @returns the scale
+     */
+    function get_gravity_scale(body: Opaque<"b2Body">): number;
+    /**
+     * Get the linear damping of the body.
+     *
+     * @param body - body
+     * @returns the damping
+     */
+    function get_linear_damping(body: Opaque<"b2Body">): number;
+    /**
+     * Get the linear velocity of the center of mass.
+     *
+     * @param body - body
+     * @returns the linear velocity of the center of mass.
+     */
+    function get_linear_velocity(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the world velocity of a local point.
+     *
+     * @param body - body
+     * @param local_point - a point in local coordinates.
+     * @returns the world velocity of a point.
+     */
+    function get_linear_velocity_from_local_point(body: Opaque<"b2Body">, local_point: Vector3): Vector3;
+    /**
+     * Get the world linear velocity of a world point attached to this body.
+     *
+     * @param body - body
+     * @param world_point - a point in world coordinates.
+     * @returns the world velocity of a point.
+     */
+    function get_linear_velocity_from_world_point(body: Opaque<"b2Body">, world_point: Vector3): Vector3;
+    /**
+     * Get the local position of the center of mass.
+     *
+     * @param body - body
+     * @returns Get the local position of the center of mass.
+     */
+    function get_local_center_of_mass(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Gets a local point relative to the body's origin given a world point.
+     *
+     * @param body - body
+     * @param world_point - a point in world coordinates.
+     * @returns the corresponding local point relative to the body's origin.
+     */
+    function get_local_point(body: Opaque<"b2Body">, world_point: Vector3): Vector3;
+    /**
+     * Gets a local vector given a world vector.
+     *
+     * @param body - body
+     * @param world_vector - a vector in world coordinates.
+     * @returns the corresponding local vector.
+     */
+    function get_local_vector(body: Opaque<"b2Body">, world_vector: Vector3): Vector3;
+    /**
+     * Get the total mass of the body.
+     *
+     * @param body - body
+     * @returns the mass, usually in kilograms (kg).
+     */
+    function get_mass(body: Opaque<"b2Body">): number;
+    /**
+     * Get the world body origin position.
+     *
+     * @param body - body
+     * @returns the world position of the body's origin.
+     */
+    function get_position(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the rotational inertia of the body about the local origin.
+     *
+     * @param body - body
+     * @returns the rotational inertia, usually in kg-m^2.
+     */
+    function get_rotational_inertia(body: Opaque<"b2Body">): number;
+    /**
+     * Get the type of this body.
+     *
+     * @param body - body
+     * @returns the body type
+     */
+    function get_type(body: Opaque<"b2Body">): (number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_STATIC_BODY" });
+    /**
+     * Get the parent world of this body.
+     *
+     * @param body - body
+     */
+    function get_world(body: Opaque<"b2Body">): Opaque<"b2World">;
+    /**
+     * Get the world position of the center of mass.
+     *
+     * @param body - body
+     * @returns Get the world position of the center of mass.
+     */
+    function get_world_center_of_mass(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the world coordinates of a point given the local coordinates.
+     *
+     * @param body - body
+     * @param local_vector - localPoint a point on the body measured relative the the body's origin.
+     * @returns the same point expressed in world coordinates.
+     */
+    function get_world_point(body: Opaque<"b2Body">, local_vector: Vector3): Vector3;
+    /**
+     * Get the world coordinates of a vector given the local coordinates.
+     *
+     * @param body - body
+     * @param local_vector - a vector fixed in the body.
+     * @returns the same vector expressed in world coordinates.
+     */
+    function get_world_vector(body: Opaque<"b2Body">, local_vector: Vector3): Vector3;
+    /**
+     * Get the active state of the body.
+     *
+     * @param body - body
+     * @returns is the body active
+     */
+    function is_active(body: Opaque<"b2Body">): boolean;
+    /**
+     * Get the sleeping state of this body.
+     *
+     * @param body - body
+     * @returns true if the body is awake, false if it's sleeping.
+     */
+    function is_awake(body: Opaque<"b2Body">): boolean;
+    /**
+     * Is this body in bullet mode
+     *
+     * @param body - body
+     * @returns true if the body is in bullet mode
+     */
+    function is_bullet(body: Opaque<"b2Body">): boolean;
+    /**
+     * Does this body have fixed rotation?
+     *
+     * @param body - body
+     * @returns is the rotation fixed
+     */
+    function is_fixed_rotation(body: Opaque<"b2Body">): boolean;
+    /**
+     * Is this body allowed to sleep
+     *
+     * @param body - body
+     * @returns true if the body is allowed to sleep
+     */
+    function is_sleeping_enabled(body: Opaque<"b2Body">): boolean;
+    /**
+     * This resets the mass properties to the sum of the mass properties of the fixtures.
+     * This normally does not need to be called unless you called SetMassData to override
+     *
+     * @param body - body
+     */
+    function reset_mass_data(body: Opaque<"b2Body">): void;
+    /**
+     * Set the active state of the body. An inactive body is not
+     * simulated and cannot be collided with or woken up.
+     * If you pass a flag of true, all fixtures will be added to the
+     * broad-phase.
+     * If you pass a flag of false, all fixtures will be removed from
+     * the broad-phase and all contacts will be destroyed.
+     * Fixtures and joints are otherwise unaffected. You may continue
+     * to create/destroy fixtures and joints on inactive bodies.
+     * Fixtures on an inactive body are implicitly inactive and will
+     * not participate in collisions, ray-casts, or queries.
+     * Joints connected to an inactive body are implicitly inactive.
+     * An inactive body is still owned by a b2World object and remains
+     * in the body list.
+     *
+     * @param body - body
+     * @param enable - true if the body should be active
+     */
+    function set_active(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set the angular damping of the body.
+     *
+     * @param body - body
+     * @param damping - the damping
+     */
+    function set_angular_damping(body: Opaque<"b2Body">, damping: number): void;
+    /**
+     * Set the angular velocity.
+     *
+     * @param body - body
+     * @param omega - the new angular velocity in radians/second.
+     */
+    function set_angular_velocity(body: Opaque<"b2Body">, omega: number): void;
+    /**
+     * Set the sleep state of the body. A sleeping body has very low CPU cost.
+     *
+     * @param body - body
+     * @param enable - flag set to false to put body to sleep, true to wake it.
+     */
+    function set_awake(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Should this body be treated like a bullet for continuous collision detection?
+     *
+     * @param body - body
+     * @param enable - if true, the body will be in bullet mode
+     */
+    function set_bullet(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set this body to have fixed rotation. This causes the mass to be reset.
+     *
+     * @param body - body
+     * @param enable - true if the rotation should be fixed
+     */
+    function set_fixed_rotation(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set the gravity scale of the body.
+     *
+     * @param body - body
+     * @param scale - the scale
+     */
+    function set_gravity_scale(body: Opaque<"b2Body">, scale: number): void;
+    /**
+     * Set the linear damping of the body.
+     *
+     * @param body - body
+     * @param damping - the damping
+     */
+    function set_linear_damping(body: Opaque<"b2Body">, damping: number): void;
+    /**
+     * Set the linear velocity of the center of mass.
+     *
+     * @param body - body
+     * @param velocity - the new linear velocity of the center of mass.
+     */
+    function set_linear_velocity(body: Opaque<"b2Body">, velocity: Vector3): void;
+    /**
+     * Set the position of the body's origin and rotation.
+     * This breaks any contacts and wakes the other bodies.
+     * Manipulating a body's transform may cause non-physical behavior.
+     *
+     * @param body - body
+     * @param position - the world position of the body's local origin.
+     * @param angle - the world position of the body's local origin.
+     */
+    function set_transform(body: Opaque<"b2Body">, position: Vector3, angle: number): void;
+    /**
+     * Set the type of this body. This may alter the mass and velocity.
+     *
+     * @param body - body
+     * @param type - the body type
+     */
+    function set_type(body: Opaque<"b2Body">, type: (number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_STATIC_BODY" })): void;
+  }
+}
+
+export {};

package/generated/buffer.d.ts

@@ -92,8 +92,11 @@ declare global {
      *
      * @param element_count - The number of elements the buffer should hold
      * @param declaration - A table where each entry (table) describes a stream
+     *
      * - hash | string `name`: The name of the stream
+     *
      * - constant `type`: The data type of the stream
+     *
      * - number `count`: The number of values each element should hold
      * @returns the new buffer
      * @example

package/generated/camera.d.ts

@@ -1,9 +1,244 @@
 /** @noSelfInFile */
+import type { Matrix4, Url, Vector3 } from "../src/core-types";
+
 declare global {
   /**
-   * Functions for interacting with camera components.
+   * Camera functions, messages and constants.
    */
   namespace camera {
+    /**
+     * Computes zoom so the original display area covers the entire window while preserving aspect ratio.
+     * Equivalent to using max(window_width/width, window_height/height).
+     */
+    const ORTHO_MODE_AUTO_COVER: number & { readonly __brand: "camera.ORTHO_MODE_AUTO_COVER" };
+    /**
+     * Computes zoom so the original display area (game.project width/height) fits inside the window
+     * while preserving aspect ratio. Equivalent to using min(window_width/width, window_height/height).
+     */
+    const ORTHO_MODE_AUTO_FIT: number & { readonly __brand: "camera.ORTHO_MODE_AUTO_FIT" };
+    /**
+     * Uses the manually set orthographic zoom value (camera.set_orthographic_zoom).
+     */
+    const ORTHO_MODE_FIXED: number & { readonly __brand: "camera.ORTHO_MODE_FIXED" };
+    /**
+     * Gets the effective aspect ratio of the camera. If auto aspect ratio is enabled,
+     * returns the aspect ratio calculated from the current render target dimensions.
+     * Otherwise returns the manually set aspect ratio.
+     *
+     * @param camera - camera id
+     * @returns the effective aspect ratio.
+     */
+    function get_aspect_ratio(camera?: Url | number): number;
+    /**
+     * Returns whether auto aspect ratio is enabled. When enabled, the camera automatically
+     * calculates aspect ratio from render target dimensions. When disabled, uses the
+     * manually set aspect ratio value.
+     *
+     * @param camera - camera id
+     * @returns true if auto aspect ratio is enabled
+     */
+    function get_auto_aspect_ratio(camera?: Url | number): boolean;
+    /**
+     * This function returns a table with all the camera URLs that have been
+     * registered in the render context.
+     *
+     * @returns a table with all camera URLs
+     * @example
+     * ```ts
+     * for (const camera_id of camera.get_cameras()) {
+     *   render.set_camera(camera_id);
+     *   render.draw(predicate);
+     *   render.set_camera();
+     * }
+     * ```
+     */
+    function get_cameras(): Record<string | number, unknown>;
+    /**
+     * get enabled
+     *
+     * @param camera - camera id
+     * @returns true if the camera is enabled
+     */
+    function get_enabled(camera?: Url | number): boolean;
+    /**
+     * get far z
+     *
+     * @param camera - camera id
+     * @returns the far z.
+     */
+    function get_far_z(camera?: Url | number): number;
+    /**
+     * get field of view
+     *
+     * @param camera - camera id
+     * @returns the field of view.
+     */
+    function get_fov(camera?: Url | number): number;
+    /**
+     * get near z
+     *
+     * @param camera - camera id
+     * @returns the near z.
+     */
+    function get_near_z(camera?: Url | number): number;
+    /**
+     * get orthographic zoom mode
+     *
+     * @param camera - camera id
+     * @returns one of camera.ORTHO_MODE_FIXED, camera.ORTHO_MODE_AUTO_FIT or
+     * camera.ORTHO_MODE_AUTO_COVER
+     */
+    function get_orthographic_mode(camera?: Url | number): number;
+    /**
+     * get orthographic zoom
+     *
+     * @param camera - camera id
+     * @returns the zoom level when the camera uses orthographic projection.
+     */
+    function get_orthographic_zoom(camera?: Url | number): number;
+    /**
+     * get projection matrix
+     *
+     * @param camera - camera id
+     * @returns the projection matrix.
+     */
+    function get_projection(camera?: Url | number): Matrix4;
+    /**
+     * get view matrix
+     *
+     * @param camera - camera id
+     * @returns the view matrix.
+     */
+    function get_view(camera?: Url | number): Matrix4;
+    /**
+     * Converts a screen-space 2D point with view depth to a 3D world point.
+     * z is the view depth in world units measured from the camera plane along the camera forward axis.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param pos - Screen-space position (x, y) with z as view depth in world units
+     * @param camera - optional camera id
+     * @returns the world coordinate
+     * @example
+     * ```ts
+     * // Place objects at the touch point with a random Z position, keeping them
+     * // within the visible view zone.
+     * export default defineScript({
+     *   on_input(self, action_id, action) {
+     *     if (action_id === hash("touch")) {
+     *       if (action.pressed) {
+     *         const perspective_camera = msg.url("#perspective_camera");
+     *         const random_z = math.random(
+     *           camera.get_near_z(perspective_camera) + 0.01,
+     *           camera.get_far_z(perspective_camera) - 0.01,
+     *         );
+     *         const world_position = camera.screen_to_world(
+     *           vmath.vector3(action.screen_x, action.screen_y, random_z),
+     *           perspective_camera,
+     *         );
+     *         go.set_position(world_position, "/go1");
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function screen_to_world(pos: Vector3, camera?: Url | number): Vector3;
+    /**
+     * Converts 2D screen coordinates (x,y) to the 3D world-space point on the camera's near plane for that pixel.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param x - X coordinate on screen.
+     * @param y - Y coordinate on screen.
+     * @param camera - optional camera id
+     * @returns the world coordinate on the camera near plane
+     * @example
+     * ```ts
+     * // Place objects at the touch point.
+     * export default defineScript({
+     *   on_input(self, action_id, action) {
+     *     if (action_id === hash("touch")) {
+     *       if (action.pressed) {
+     *         const world_position = camera.screen_xy_to_world(action.screen_x, action.screen_y);
+     *         go.set_position(world_position, "/go1");
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function screen_xy_to_world(x: number, y: number, camera?: Url | number): Vector3;
+    /**
+     * Sets the manual aspect ratio for the camera. This value is only used when
+     * auto aspect ratio is disabled. To disable auto aspect ratio and use this
+     * manual value, call camera.set_auto_aspect_ratio(camera, false).
+     *
+     * @param camera - camera id
+     * @param aspect_ratio - the manual aspect ratio value.
+     */
+    function set_aspect_ratio(camera: Url | number, aspect_ratio: number): void;
+    /**
+     * Enables or disables automatic aspect ratio calculation. When enabled (true),
+     * the camera automatically calculates aspect ratio from render target dimensions.
+     * When disabled (false), uses the manually set aspect ratio value.
+     *
+     * @param camera - camera id
+     * @param auto_aspect_ratio - true to enable auto aspect ratio
+     */
+    function set_auto_aspect_ratio(camera: Url | number, auto_aspect_ratio: boolean): void;
+    /**
+     * set far z
+     *
+     * @param camera - camera id
+     * @param far_z - the far z.
+     */
+    function set_far_z(camera: Url | number, far_z: number): void;
+    /**
+     * set field of view
+     *
+     * @param camera - camera id
+     * @param fov - the field of view.
+     */
+    function set_fov(camera: Url | number, fov: number): void;
+    /**
+     * set near z
+     *
+     * @param camera - camera id
+     * @param near_z - the near z.
+     */
+    function set_near_z(camera: Url | number, near_z: number): void;
+    /**
+     * set orthographic zoom mode
+     *
+     * @param camera - camera id
+     * @param mode - camera.ORTHO_MODE_FIXED, camera.ORTHO_MODE_AUTO_FIT or camera.ORTHO_MODE_AUTO_COVER
+     */
+    function set_orthographic_mode(camera: Url | number, mode: number): void;
+    /**
+     * set orthographic zoom
+     *
+     * @param camera - camera id
+     * @param orthographic_zoom - the zoom level when the camera uses orthographic projection.
+     */
+    function set_orthographic_zoom(camera: Url | number, orthographic_zoom: number): void;
+    /**
+     * Converts a 3D world position to screen-space coordinates with view depth.
+     * Returns a vector3 where x and y are in screen pixels and z is the view depth in world units
+     * measured from the camera plane along the camera forward axis. The returned z can be used with
+     * camera.screen_to_world to reconstruct the world position on the same pixel ray.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param world_pos - World-space position
+     * @param camera - optional camera id
+     * @returns Screen position (x,y in pixels, z is view depth)
+     * @example
+     * ```ts
+     * // Convert a game object position into a screen position.
+     * go.update_world_transform("/go1");
+     * const world_pos = go.get_world_position("/go1");
+     * const screen_pos = camera.world_to_screen(world_pos);
+     * ```
+     */
+    function world_to_screen(world_pos: Vector3, camera?: Url | number): Vector3;
   }
 }
 

package/generated/collectionfactory.d.ts

@@ -85,8 +85,11 @@ declare global {
      *
      * @param url - the collection factory component to get status from
      * @returns status of the collection factory component
+     *
      * - `collectionfactory.STATUS_UNLOADED`
+     *
      * - `collectionfactory.STATUS_LOADING`
+     *
      * - `collectionfactory.STATUS_LOADED`
      */
     function get_status(url?: string | Hash | Url): Opaque<"constant">;
@@ -96,6 +99,7 @@ declare global {
      *
      * @param url - the collection factory component to load
      * @param complete_function - function to call when resources are loaded.
+     *
      * `self`
      * object The current object.
      * `url`

package/generated/factory.d.ts

@@ -63,8 +63,11 @@ declare global {
      *
      * @param url - the factory component to get status from
      * @returns status of the factory component
+     *
      * - `factory.STATUS_UNLOADED`
+     *
      * - `factory.STATUS_LOADING`
+     *
      * - `factory.STATUS_LOADED`
      */
     function get_status(url?: string | Hash | Url): Opaque<"constant">;
@@ -74,6 +77,7 @@ declare global {
      *
      * @param url - the factory component to load
      * @param complete_function - function to call when resources are loaded.
+     *
      * `self`
      * object The current object.
      * `url`